2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Intel IO-APIC support for multi-Pentium hosts.
|
|
|
|
*
|
2009-01-31 01:03:42 +00:00
|
|
|
* Copyright (C) 1997, 1998, 1999, 2000, 2009 Ingo Molnar, Hajnalka Szabo
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* Many thanks to Stig Venaas for trying out countless experimental
|
|
|
|
* patches and reporting/debugging problems patiently!
|
|
|
|
*
|
|
|
|
* (c) 1999, Multiple IO-APIC support, developed by
|
|
|
|
* Ken-ichi Yaku <yaku@css1.kbnes.nec.co.jp> and
|
|
|
|
* Hidemi Kishimoto <kisimoto@css1.kbnes.nec.co.jp>,
|
|
|
|
* further tested and cleaned up by Zach Brown <zab@redhat.com>
|
|
|
|
* and Ingo Molnar <mingo@redhat.com>
|
|
|
|
*
|
|
|
|
* Fixes
|
|
|
|
* Maciej W. Rozycki : Bits for genuine 82489DX APICs;
|
|
|
|
* thanks to Eric Gilmore
|
|
|
|
* and Rolf G. Tews
|
|
|
|
* for testing these extensively
|
|
|
|
* Paul Diefenbaugh : Added full ACPI support
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/sched.h>
|
2008-08-20 03:50:38 +00:00
|
|
|
#include <linux/pci.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/mc146818rtc.h>
|
|
|
|
#include <linux/compiler.h>
|
|
|
|
#include <linux/acpi.h>
|
2005-06-23 07:08:33 +00:00
|
|
|
#include <linux/module.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/sysdev.h>
|
2006-10-04 09:16:59 +00:00
|
|
|
#include <linux/msi.h>
|
2006-10-04 09:17:01 +00:00
|
|
|
#include <linux/htirq.h>
|
2006-12-07 04:34:23 +00:00
|
|
|
#include <linux/freezer.h>
|
2007-05-02 17:27:19 +00:00
|
|
|
#include <linux/kthread.h>
|
2008-08-20 07:07:45 +00:00
|
|
|
#include <linux/jiffies.h> /* time_after() */
|
2008-08-20 03:50:38 +00:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#endif
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/dmar.h>
|
2008-09-06 01:02:17 +00:00
|
|
|
#include <linux/hpet.h>
|
[PATCH] x86/x86_64: deferred handling of writes to /proc/irqxx/smp_affinity
When handling writes to /proc/irq, current code is re-programming rte
entries directly. This is not recommended and could potentially cause
chipset's to lockup, or cause missing interrupts.
CONFIG_IRQ_BALANCE does this correctly, where it re-programs only when the
interrupt is pending. The same needs to be done for /proc/irq handling as well.
Otherwise user space irq balancers are really not doing the right thing.
- Changed pending_irq_balance_cpumask to pending_irq_migrate_cpumask for
lack of a generic name.
- added move_irq out of IRQ_BALANCE, and added this same to X86_64
- Added new proc handler for write, so we can do deferred write at irq
handling time.
- Display of /proc/irq/XX/smp_affinity used to display CPU_MASKALL, instead
it now shows only active cpu masks, or exactly what was set.
- Provided a common move_irq implementation, instead of duplicating
when using generic irq framework.
Tested on i386/x86_64 and ia64 with CONFIG_PCI_MSI turned on and off.
Tested UP builds as well.
MSI testing: tbd: I have cards, need to look for a x-over cable, although I
did test an earlier version of this patch. Will test in a couple days.
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Acked-by: Zwane Mwaikambo <zwane@holomorphy.com>
Grudgingly-acked-by: Andi Kleen <ak@muc.de>
Signed-off-by: Coywolf Qi Hunt <coywolf@lovecn.org>
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-06 22:16:15 +00:00
|
|
|
|
2008-08-20 03:50:38 +00:00
|
|
|
#include <asm/idle.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/smp.h>
|
2009-01-07 16:08:59 +00:00
|
|
|
#include <asm/cpu.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/desc.h>
|
2008-08-20 03:50:38 +00:00
|
|
|
#include <asm/proto.h>
|
|
|
|
#include <asm/acpi.h>
|
|
|
|
#include <asm/dma.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/timer.h>
|
2005-06-30 09:58:55 +00:00
|
|
|
#include <asm/i8259.h>
|
2006-06-26 11:57:01 +00:00
|
|
|
#include <asm/nmi.h>
|
2006-10-04 09:16:43 +00:00
|
|
|
#include <asm/msidef.h>
|
2006-10-04 09:16:55 +00:00
|
|
|
#include <asm/hypertransport.h>
|
2008-07-25 09:14:28 +00:00
|
|
|
#include <asm/setup.h>
|
2008-08-20 03:50:38 +00:00
|
|
|
#include <asm/irq_remapping.h>
|
2008-09-06 01:02:17 +00:00
|
|
|
#include <asm/hpet.h>
|
2009-04-10 18:33:10 +00:00
|
|
|
#include <asm/hw_irq.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-17 12:58:15 +00:00
|
|
|
#include <asm/apic.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-20 23:52:49 +00:00
|
|
|
#define __apicdebuginit(type) static type __init
|
2009-08-01 07:47:59 +00:00
|
|
|
#define for_each_irq_pin(entry, head) \
|
|
|
|
for (entry = head; entry; entry = entry->next)
|
2008-07-20 23:52:49 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2008-08-20 07:07:45 +00:00
|
|
|
* Is the SiS APIC rmw bug present ?
|
|
|
|
* -1 = don't know, 0 = no, 1 = yes
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
int sis_apic_bug = -1;
|
|
|
|
|
2008-08-20 03:50:36 +00:00
|
|
|
static DEFINE_SPINLOCK(ioapic_lock);
|
|
|
|
static DEFINE_SPINLOCK(vector_lock);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* # of IRQ routing registers
|
|
|
|
*/
|
|
|
|
int nr_ioapic_registers[MAX_IO_APICS];
|
|
|
|
|
2008-04-04 19:41:13 +00:00
|
|
|
/* I/O APIC entries */
|
2009-01-12 12:16:17 +00:00
|
|
|
struct mpc_ioapic mp_ioapics[MAX_IO_APICS];
|
2008-04-04 19:41:13 +00:00
|
|
|
int nr_ioapics;
|
|
|
|
|
2009-07-08 03:01:15 +00:00
|
|
|
/* IO APIC gsi routing info */
|
|
|
|
struct mp_ioapic_gsi mp_gsi_routing[MAX_IO_APICS];
|
|
|
|
|
2008-04-04 19:41:32 +00:00
|
|
|
/* MP IRQ source entries */
|
2009-01-12 12:17:22 +00:00
|
|
|
struct mpc_intsrc mp_irqs[MAX_IRQ_SOURCES];
|
2008-04-04 19:41:32 +00:00
|
|
|
|
|
|
|
/* # of MP IRQ source entries */
|
|
|
|
int mp_irq_entries;
|
|
|
|
|
2009-08-29 16:09:57 +00:00
|
|
|
/* Number of legacy interrupts */
|
|
|
|
static int nr_legacy_irqs __read_mostly = NR_IRQS_LEGACY;
|
|
|
|
/* GSI interrupts */
|
|
|
|
static int nr_irqs_gsi = NR_IRQS_LEGACY;
|
|
|
|
|
2008-05-19 15:47:16 +00:00
|
|
|
#if defined (CONFIG_MCA) || defined (CONFIG_EISA)
|
|
|
|
int mp_bus_id_to_type[MAX_MP_BUSSES];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
DECLARE_BITMAP(mp_bus_not_pci, MAX_MP_BUSSES);
|
|
|
|
|
2008-08-20 03:50:36 +00:00
|
|
|
int skip_ioapic_setup;
|
|
|
|
|
2009-01-31 02:36:17 +00:00
|
|
|
void arch_disable_smp_support(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
noioapicquirk = 1;
|
|
|
|
noioapicreroute = -1;
|
|
|
|
#endif
|
|
|
|
skip_ioapic_setup = 1;
|
|
|
|
}
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
static int __init parse_noapic(char *str)
|
2008-08-20 03:50:36 +00:00
|
|
|
{
|
|
|
|
/* disable IO-APIC */
|
2009-01-31 02:36:17 +00:00
|
|
|
arch_disable_smp_support();
|
2008-08-20 03:50:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("noapic", parse_noapic);
|
2005-09-12 16:49:25 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_pin_list {
|
|
|
|
int apic, pin;
|
|
|
|
struct irq_pin_list *next;
|
|
|
|
};
|
|
|
|
|
2009-04-28 01:00:38 +00:00
|
|
|
static struct irq_pin_list *get_one_free_irq_2_pin(int node)
|
2008-12-06 02:58:31 +00:00
|
|
|
{
|
|
|
|
struct irq_pin_list *pin;
|
|
|
|
|
|
|
|
pin = kzalloc_node(sizeof(*pin), GFP_ATOMIC, node);
|
|
|
|
|
|
|
|
return pin;
|
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:24 +00:00
|
|
|
/* irq_cfg is indexed by the sum of all RTEs in all I/O APICs. */
|
2008-12-06 02:58:31 +00:00
|
|
|
#ifdef CONFIG_SPARSE_IRQ
|
|
|
|
static struct irq_cfg irq_cfgx[] = {
|
|
|
|
#else
|
2008-10-15 13:27:23 +00:00
|
|
|
static struct irq_cfg irq_cfgx[NR_IRQS] = {
|
2008-12-06 02:58:31 +00:00
|
|
|
#endif
|
2008-12-17 01:33:56 +00:00
|
|
|
[0] = { .vector = IRQ0_VECTOR, },
|
|
|
|
[1] = { .vector = IRQ1_VECTOR, },
|
|
|
|
[2] = { .vector = IRQ2_VECTOR, },
|
|
|
|
[3] = { .vector = IRQ3_VECTOR, },
|
|
|
|
[4] = { .vector = IRQ4_VECTOR, },
|
|
|
|
[5] = { .vector = IRQ5_VECTOR, },
|
|
|
|
[6] = { .vector = IRQ6_VECTOR, },
|
|
|
|
[7] = { .vector = IRQ7_VECTOR, },
|
|
|
|
[8] = { .vector = IRQ8_VECTOR, },
|
|
|
|
[9] = { .vector = IRQ9_VECTOR, },
|
|
|
|
[10] = { .vector = IRQ10_VECTOR, },
|
|
|
|
[11] = { .vector = IRQ11_VECTOR, },
|
|
|
|
[12] = { .vector = IRQ12_VECTOR, },
|
|
|
|
[13] = { .vector = IRQ13_VECTOR, },
|
|
|
|
[14] = { .vector = IRQ14_VECTOR, },
|
|
|
|
[15] = { .vector = IRQ15_VECTOR, },
|
2008-08-20 03:50:24 +00:00
|
|
|
};
|
|
|
|
|
2009-08-29 16:09:57 +00:00
|
|
|
void __init io_apic_disable_legacy(void)
|
|
|
|
{
|
|
|
|
nr_legacy_irqs = 0;
|
|
|
|
nr_irqs_gsi = 0;
|
|
|
|
}
|
|
|
|
|
2008-12-26 10:05:47 +00:00
|
|
|
int __init arch_early_irq_init(void)
|
2008-08-20 03:50:51 +00:00
|
|
|
{
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_cfg *cfg;
|
|
|
|
struct irq_desc *desc;
|
|
|
|
int count;
|
2009-05-29 01:14:40 +00:00
|
|
|
int node;
|
2008-12-06 02:58:31 +00:00
|
|
|
int i;
|
2008-10-15 13:27:23 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
cfg = irq_cfgx;
|
|
|
|
count = ARRAY_SIZE(irq_cfgx);
|
2009-05-29 01:14:40 +00:00
|
|
|
node= cpu_to_node(boot_cpu_id);
|
2008-08-20 03:50:51 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
desc = irq_to_desc(i);
|
|
|
|
desc->chip_data = &cfg[i];
|
2009-06-11 22:07:48 +00:00
|
|
|
zalloc_cpumask_var_node(&cfg[i].domain, GFP_NOWAIT, node);
|
|
|
|
zalloc_cpumask_var_node(&cfg[i].old_domain, GFP_NOWAIT, node);
|
2009-08-29 16:09:57 +00:00
|
|
|
if (i < nr_legacy_irqs)
|
2008-12-17 01:33:56 +00:00
|
|
|
cpumask_setall(cfg[i].domain);
|
2008-12-06 02:58:31 +00:00
|
|
|
}
|
2008-12-26 10:05:47 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-12-06 02:58:31 +00:00
|
|
|
}
|
2008-08-20 03:50:51 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
#ifdef CONFIG_SPARSE_IRQ
|
2009-10-13 20:32:36 +00:00
|
|
|
struct irq_cfg *irq_cfg(unsigned int irq)
|
2008-08-20 03:50:51 +00:00
|
|
|
{
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_cfg *cfg = NULL;
|
|
|
|
struct irq_desc *desc;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
desc = irq_to_desc(irq);
|
|
|
|
if (desc)
|
|
|
|
cfg = desc->chip_data;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
return cfg;
|
2008-08-20 03:50:51 +00:00
|
|
|
}
|
2008-10-15 13:27:23 +00:00
|
|
|
|
2009-04-28 01:00:38 +00:00
|
|
|
static struct irq_cfg *get_one_free_irq_cfg(int node)
|
2008-08-20 03:50:51 +00:00
|
|
|
{
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_cfg *cfg;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
cfg = kzalloc_node(sizeof(*cfg), GFP_ATOMIC, node);
|
2008-12-17 01:33:56 +00:00
|
|
|
if (cfg) {
|
2009-06-15 06:58:26 +00:00
|
|
|
if (!zalloc_cpumask_var_node(&cfg->domain, GFP_ATOMIC, node)) {
|
2008-12-17 01:33:56 +00:00
|
|
|
kfree(cfg);
|
|
|
|
cfg = NULL;
|
2009-06-15 06:58:26 +00:00
|
|
|
} else if (!zalloc_cpumask_var_node(&cfg->old_domain,
|
2009-01-01 02:08:47 +00:00
|
|
|
GFP_ATOMIC, node)) {
|
2008-12-17 01:33:56 +00:00
|
|
|
free_cpumask_var(cfg->domain);
|
|
|
|
kfree(cfg);
|
|
|
|
cfg = NULL;
|
|
|
|
}
|
|
|
|
}
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
return cfg;
|
2008-08-20 03:50:51 +00:00
|
|
|
}
|
|
|
|
|
2009-04-28 01:00:38 +00:00
|
|
|
int arch_init_chip_data(struct irq_desc *desc, int node)
|
2008-08-20 03:50:26 +00:00
|
|
|
{
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_cfg *cfg;
|
2008-10-15 13:27:23 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
cfg = desc->chip_data;
|
|
|
|
if (!cfg) {
|
2009-04-28 01:00:38 +00:00
|
|
|
desc->chip_data = get_one_free_irq_cfg(node);
|
2008-12-06 02:58:31 +00:00
|
|
|
if (!desc->chip_data) {
|
|
|
|
printk(KERN_ERR "can not alloc irq_cfg\n");
|
|
|
|
BUG_ON(1);
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-26 10:05:47 +00:00
|
|
|
return 0;
|
2008-12-06 02:58:31 +00:00
|
|
|
}
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2009-04-28 00:58:23 +00:00
|
|
|
/* for move_irq_desc */
|
2008-12-11 08:15:01 +00:00
|
|
|
static void
|
2009-04-28 01:00:38 +00:00
|
|
|
init_copy_irq_2_pin(struct irq_cfg *old_cfg, struct irq_cfg *cfg, int node)
|
2008-08-20 03:50:26 +00:00
|
|
|
{
|
2008-12-11 08:15:01 +00:00
|
|
|
struct irq_pin_list *old_entry, *head, *tail, *entry;
|
|
|
|
|
|
|
|
cfg->irq_2_pin = NULL;
|
|
|
|
old_entry = old_cfg->irq_2_pin;
|
|
|
|
if (!old_entry)
|
|
|
|
return;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2009-04-28 01:00:38 +00:00
|
|
|
entry = get_one_free_irq_2_pin(node);
|
2008-12-11 08:15:01 +00:00
|
|
|
if (!entry)
|
|
|
|
return;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
entry->apic = old_entry->apic;
|
|
|
|
entry->pin = old_entry->pin;
|
|
|
|
head = entry;
|
|
|
|
tail = entry;
|
|
|
|
old_entry = old_entry->next;
|
|
|
|
while (old_entry) {
|
2009-04-28 01:00:38 +00:00
|
|
|
entry = get_one_free_irq_2_pin(node);
|
2008-12-11 08:15:01 +00:00
|
|
|
if (!entry) {
|
|
|
|
entry = head;
|
|
|
|
while (entry) {
|
|
|
|
head = entry->next;
|
|
|
|
kfree(entry);
|
|
|
|
entry = head;
|
|
|
|
}
|
|
|
|
/* still use the old one */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
entry->apic = old_entry->apic;
|
|
|
|
entry->pin = old_entry->pin;
|
|
|
|
tail->next = entry;
|
|
|
|
tail = entry;
|
|
|
|
old_entry = old_entry->next;
|
|
|
|
}
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
tail->next = NULL;
|
|
|
|
cfg->irq_2_pin = head;
|
2008-08-20 03:50:26 +00:00
|
|
|
}
|
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
static void free_irq_2_pin(struct irq_cfg *old_cfg, struct irq_cfg *cfg)
|
2008-08-20 03:50:26 +00:00
|
|
|
{
|
2008-12-11 08:15:01 +00:00
|
|
|
struct irq_pin_list *entry, *next;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
if (old_cfg->irq_2_pin == cfg->irq_2_pin)
|
|
|
|
return;
|
2008-08-20 03:50:02 +00:00
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
entry = old_cfg->irq_2_pin;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
while (entry) {
|
|
|
|
next = entry->next;
|
|
|
|
kfree(entry);
|
|
|
|
entry = next;
|
|
|
|
}
|
|
|
|
old_cfg->irq_2_pin = NULL;
|
2008-08-20 03:50:26 +00:00
|
|
|
}
|
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
void arch_init_copy_chip_data(struct irq_desc *old_desc,
|
2009-04-28 01:00:38 +00:00
|
|
|
struct irq_desc *desc, int node)
|
2008-08-20 03:50:26 +00:00
|
|
|
{
|
2008-12-11 08:15:01 +00:00
|
|
|
struct irq_cfg *cfg;
|
|
|
|
struct irq_cfg *old_cfg;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2009-04-28 01:00:38 +00:00
|
|
|
cfg = get_one_free_irq_cfg(node);
|
2008-08-20 03:50:02 +00:00
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
if (!cfg)
|
|
|
|
return;
|
|
|
|
|
|
|
|
desc->chip_data = cfg;
|
|
|
|
|
|
|
|
old_cfg = old_desc->chip_data;
|
|
|
|
|
|
|
|
memcpy(cfg, old_cfg, sizeof(struct irq_cfg));
|
|
|
|
|
2009-04-28 01:00:38 +00:00
|
|
|
init_copy_irq_2_pin(old_cfg, cfg, node);
|
2008-08-20 03:50:26 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-11 08:15:01 +00:00
|
|
|
static void free_irq_cfg(struct irq_cfg *old_cfg)
|
|
|
|
{
|
|
|
|
kfree(old_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void arch_free_chip_data(struct irq_desc *old_desc, struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_cfg *old_cfg, *cfg;
|
|
|
|
|
|
|
|
old_cfg = old_desc->chip_data;
|
|
|
|
cfg = desc->chip_data;
|
|
|
|
|
|
|
|
if (old_cfg == cfg)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (old_cfg) {
|
|
|
|
free_irq_2_pin(old_cfg, cfg);
|
|
|
|
free_irq_cfg(old_cfg);
|
|
|
|
old_desc->chip_data = NULL;
|
|
|
|
}
|
|
|
|
}
|
2009-04-28 00:58:23 +00:00
|
|
|
/* end for move_irq_desc */
|
2008-12-11 08:15:01 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
#else
|
2009-10-13 20:32:36 +00:00
|
|
|
struct irq_cfg *irq_cfg(unsigned int irq)
|
2008-12-06 02:58:31 +00:00
|
|
|
{
|
|
|
|
return irq < nr_irqs ? irq_cfgx + irq : NULL;
|
2008-08-20 03:50:26 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
#endif
|
|
|
|
|
2006-11-01 17:11:00 +00:00
|
|
|
struct io_apic {
|
|
|
|
unsigned int index;
|
|
|
|
unsigned int unused[3];
|
|
|
|
unsigned int data;
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
unsigned int unused2[11];
|
|
|
|
unsigned int eoi;
|
2006-11-01 17:11:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static __attribute_const__ struct io_apic __iomem *io_apic_base(int idx)
|
|
|
|
{
|
|
|
|
return (void __iomem *) __fix_to_virt(FIX_IO_APIC_BASE_0 + idx)
|
2009-01-12 12:16:17 +00:00
|
|
|
+ (mp_ioapics[idx].apicaddr & ~PAGE_MASK);
|
2006-11-01 17:11:00 +00:00
|
|
|
}
|
|
|
|
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
static inline void io_apic_eoi(unsigned int apic, unsigned int vector)
|
|
|
|
{
|
|
|
|
struct io_apic __iomem *io_apic = io_apic_base(apic);
|
|
|
|
writel(vector, &io_apic->eoi);
|
|
|
|
}
|
|
|
|
|
2006-11-01 17:11:00 +00:00
|
|
|
static inline unsigned int io_apic_read(unsigned int apic, unsigned int reg)
|
|
|
|
{
|
|
|
|
struct io_apic __iomem *io_apic = io_apic_base(apic);
|
|
|
|
writel(reg, &io_apic->index);
|
|
|
|
return readl(&io_apic->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void io_apic_write(unsigned int apic, unsigned int reg, unsigned int value)
|
|
|
|
{
|
|
|
|
struct io_apic __iomem *io_apic = io_apic_base(apic);
|
|
|
|
writel(reg, &io_apic->index);
|
|
|
|
writel(value, &io_apic->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Re-write a value: to be used for read-modify-write
|
|
|
|
* cycles where the read already set up the index register.
|
|
|
|
*
|
|
|
|
* Older SiS APIC requires we rewrite the index register
|
|
|
|
*/
|
|
|
|
static inline void io_apic_modify(unsigned int apic, unsigned int reg, unsigned int value)
|
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
struct io_apic __iomem *io_apic = io_apic_base(apic);
|
2008-10-15 13:27:23 +00:00
|
|
|
|
|
|
|
if (sis_apic_bug)
|
|
|
|
writel(reg, &io_apic->index);
|
2006-11-01 17:11:00 +00:00
|
|
|
writel(value, &io_apic->data);
|
|
|
|
}
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static bool io_apic_level_ack_pending(struct irq_cfg *cfg)
|
2008-08-20 03:50:41 +00:00
|
|
|
{
|
|
|
|
struct irq_pin_list *entry;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2009-08-01 07:47:59 +00:00
|
|
|
for_each_irq_pin(entry, cfg->irq_2_pin) {
|
2008-08-20 03:50:41 +00:00
|
|
|
unsigned int reg;
|
|
|
|
int pin;
|
|
|
|
|
|
|
|
pin = entry->pin;
|
|
|
|
reg = io_apic_read(entry->apic, 0x10 + pin*2);
|
|
|
|
/* Is the remote IRR bit set? */
|
|
|
|
if (reg & IO_APIC_REDIR_REMOTE_IRR) {
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
union entry_union {
|
|
|
|
struct { u32 w1, w2; };
|
|
|
|
struct IO_APIC_route_entry entry;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct IO_APIC_route_entry ioapic_read_entry(int apic, int pin)
|
|
|
|
{
|
|
|
|
union entry_union eu;
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
eu.w1 = io_apic_read(apic, 0x10 + 2 * pin);
|
|
|
|
eu.w2 = io_apic_read(apic, 0x11 + 2 * pin);
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
return eu.entry;
|
|
|
|
}
|
|
|
|
|
2006-11-01 18:05:35 +00:00
|
|
|
/*
|
|
|
|
* When we write a new IO APIC routing entry, we need to write the high
|
|
|
|
* word first! If the mask bit in the low word is clear, we will enable
|
|
|
|
* the interrupt, and we need to make sure the entry is fully populated
|
|
|
|
* before that happens.
|
|
|
|
*/
|
2006-12-07 01:14:07 +00:00
|
|
|
static void
|
|
|
|
__ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
|
2006-09-26 08:52:30 +00:00
|
|
|
{
|
2009-06-17 14:25:20 +00:00
|
|
|
union entry_union eu = {{0, 0}};
|
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
eu.entry = e;
|
2006-11-01 18:05:35 +00:00
|
|
|
io_apic_write(apic, 0x11 + 2*pin, eu.w2);
|
|
|
|
io_apic_write(apic, 0x10 + 2*pin, eu.w1);
|
2006-12-07 01:14:07 +00:00
|
|
|
}
|
|
|
|
|
2009-02-09 20:05:47 +00:00
|
|
|
void ioapic_write_entry(int apic, int pin, struct IO_APIC_route_entry e)
|
2006-12-07 01:14:07 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
__ioapic_write_entry(apic, pin, e);
|
2006-11-01 18:05:35 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we mask an IO APIC routing entry, we need to write the low
|
|
|
|
* word first, in order to set the mask bit before we change the
|
|
|
|
* high bits!
|
|
|
|
*/
|
|
|
|
static void ioapic_mask_entry(int apic, int pin)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
union entry_union eu = { .entry.mask = 1 };
|
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
io_apic_write(apic, 0x10 + 2*pin, eu.w1);
|
|
|
|
io_apic_write(apic, 0x11 + 2*pin, eu.w2);
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The common case is 1:1 IRQ<->pin mappings. Sometimes there are
|
|
|
|
* shared ISA-space IRQs, so we have to support them. We are super
|
|
|
|
* fast in the common case, and fast for shared ISA-space IRQs.
|
|
|
|
*/
|
2009-08-05 20:09:31 +00:00
|
|
|
static int
|
|
|
|
add_pin_to_irq_node_nopanic(struct irq_cfg *cfg, int node, int apic, int pin)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-08-01 07:47:59 +00:00
|
|
|
struct irq_pin_list **last, *entry;
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2009-08-01 07:47:59 +00:00
|
|
|
/* don't allow duplicates */
|
|
|
|
last = &cfg->irq_2_pin;
|
|
|
|
for_each_irq_pin(entry, cfg->irq_2_pin) {
|
2008-08-20 03:50:26 +00:00
|
|
|
if (entry->apic == apic && entry->pin == pin)
|
2009-08-05 20:09:31 +00:00
|
|
|
return 0;
|
2009-08-01 07:47:59 +00:00
|
|
|
last = &entry->next;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2009-06-08 10:24:11 +00:00
|
|
|
entry = get_one_free_irq_2_pin(node);
|
2009-08-01 07:48:00 +00:00
|
|
|
if (!entry) {
|
2009-08-05 20:09:31 +00:00
|
|
|
printk(KERN_ERR "can not alloc irq_pin_list (%d,%d,%d)\n",
|
|
|
|
node, apic, pin);
|
|
|
|
return -ENOMEM;
|
2009-08-01 07:48:00 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
entry->apic = apic;
|
|
|
|
entry->pin = pin;
|
2009-06-08 10:24:11 +00:00
|
|
|
|
2009-08-01 07:47:59 +00:00
|
|
|
*last = entry;
|
2009-08-05 20:09:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_pin_to_irq_node(struct irq_cfg *cfg, int node, int apic, int pin)
|
|
|
|
{
|
|
|
|
if (add_pin_to_irq_node_nopanic(cfg, node, apic, pin))
|
|
|
|
panic("IO-APIC: failed to add irq-pin. Can not proceed\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Reroute an IRQ to a different pin.
|
|
|
|
*/
|
2009-04-28 01:00:38 +00:00
|
|
|
static void __init replace_pin_at_irq_node(struct irq_cfg *cfg, int node,
|
2009-06-08 10:32:15 +00:00
|
|
|
int oldapic, int oldpin,
|
|
|
|
int newapic, int newpin)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-06-08 10:29:26 +00:00
|
|
|
struct irq_pin_list *entry;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-08-01 07:47:59 +00:00
|
|
|
for_each_irq_pin(entry, cfg->irq_2_pin) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (entry->apic == oldapic && entry->pin == oldpin) {
|
|
|
|
entry->apic = newapic;
|
|
|
|
entry->pin = newpin;
|
2008-08-20 03:50:26 +00:00
|
|
|
/* every one is different, right? */
|
2009-06-08 10:32:15 +00:00
|
|
|
return;
|
2008-08-20 03:50:26 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-08-20 03:50:26 +00:00
|
|
|
|
2009-06-08 10:32:15 +00:00
|
|
|
/* old apic/pin didn't exist, so just add new ones */
|
|
|
|
add_pin_to_irq_node(cfg, node, newapic, newpin);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-12-01 23:31:16 +00:00
|
|
|
static void __io_apic_modify_irq(struct irq_pin_list *entry,
|
|
|
|
int mask_and, int mask_or,
|
|
|
|
void (*final)(struct irq_pin_list *entry))
|
|
|
|
{
|
|
|
|
unsigned int reg, pin;
|
|
|
|
|
|
|
|
pin = entry->pin;
|
|
|
|
reg = io_apic_read(entry->apic, 0x10 + pin * 2);
|
|
|
|
reg &= mask_and;
|
|
|
|
reg |= mask_or;
|
|
|
|
io_apic_modify(entry->apic, 0x10 + pin * 2, reg);
|
|
|
|
if (final)
|
|
|
|
final(entry);
|
|
|
|
}
|
|
|
|
|
2009-06-08 09:55:22 +00:00
|
|
|
static void io_apic_modify_irq(struct irq_cfg *cfg,
|
|
|
|
int mask_and, int mask_or,
|
|
|
|
void (*final)(struct irq_pin_list *entry))
|
2008-09-10 18:19:50 +00:00
|
|
|
{
|
|
|
|
struct irq_pin_list *entry;
|
2008-08-20 03:50:41 +00:00
|
|
|
|
2009-12-01 23:31:16 +00:00
|
|
|
for_each_irq_pin(entry, cfg->irq_2_pin)
|
|
|
|
__io_apic_modify_irq(entry, mask_and, mask_or, final);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __mask_and_edge_IO_APIC_irq(struct irq_pin_list *entry)
|
|
|
|
{
|
|
|
|
__io_apic_modify_irq(entry, ~IO_APIC_REDIR_LEVEL_TRIGGER,
|
|
|
|
IO_APIC_REDIR_MASKED, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __unmask_and_level_IO_APIC_irq(struct irq_pin_list *entry)
|
|
|
|
{
|
|
|
|
__io_apic_modify_irq(entry, ~IO_APIC_REDIR_MASKED,
|
|
|
|
IO_APIC_REDIR_LEVEL_TRIGGER, NULL);
|
2008-09-10 18:19:50 +00:00
|
|
|
}
|
2008-08-20 03:50:41 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void __unmask_IO_APIC_irq(struct irq_cfg *cfg)
|
2008-09-10 18:19:50 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
io_apic_modify_irq(cfg, ~IO_APIC_REDIR_MASKED, 0, NULL);
|
2008-09-10 18:19:50 +00:00
|
|
|
}
|
2008-08-20 03:50:41 +00:00
|
|
|
|
2008-12-29 15:04:35 +00:00
|
|
|
static void io_apic_sync(struct irq_pin_list *entry)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-09-10 18:19:50 +00:00
|
|
|
/*
|
|
|
|
* Synchronize the IO-APIC and the CPU by doing
|
|
|
|
* a dummy read from the IO-APIC
|
|
|
|
*/
|
|
|
|
struct io_apic __iomem *io_apic;
|
|
|
|
io_apic = io_apic_base(entry->apic);
|
2008-08-20 03:50:47 +00:00
|
|
|
readl(&io_apic->data);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void __mask_IO_APIC_irq(struct irq_cfg *cfg)
|
2008-09-10 18:19:50 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
io_apic_modify_irq(cfg, ~0, IO_APIC_REDIR_MASKED, &io_apic_sync);
|
2008-09-10 18:19:50 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void mask_IO_APIC_irq_desc(struct irq_desc *desc)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_cfg *cfg = desc->chip_data;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
BUG_ON(!cfg);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2008-12-06 02:58:34 +00:00
|
|
|
__mask_IO_APIC_irq(cfg);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void unmask_IO_APIC_irq_desc(struct irq_desc *desc)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_cfg *cfg = desc->chip_data;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2008-12-06 02:58:34 +00:00
|
|
|
__unmask_IO_APIC_irq(cfg);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void mask_IO_APIC_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
mask_IO_APIC_irq_desc(desc);
|
|
|
|
}
|
|
|
|
static void unmask_IO_APIC_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
unmask_IO_APIC_irq_desc(desc);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static void clear_IO_APIC_pin(unsigned int apic, unsigned int pin)
|
|
|
|
{
|
|
|
|
struct IO_APIC_route_entry entry;
|
2008-06-08 11:07:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Check delivery_mode to be sure we're not clearing an SMI pin */
|
2006-09-26 08:52:30 +00:00
|
|
|
entry = ioapic_read_entry(apic, pin);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (entry.delivery_mode == dest_SMI)
|
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* Disable it in the IO-APIC irq-routing table:
|
|
|
|
*/
|
2006-11-01 18:05:35 +00:00
|
|
|
ioapic_mask_entry(apic, pin);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
static void clear_IO_APIC (void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int apic, pin;
|
|
|
|
|
|
|
|
for (apic = 0; apic < nr_ioapics; apic++)
|
|
|
|
for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
|
|
|
|
clear_IO_APIC_pin(apic, pin);
|
|
|
|
}
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* support for broken MP BIOSs, enables hand-redirection of PIRQ0-7 to
|
|
|
|
* specific CPU-side IRQs.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define MAX_PIRQS 8
|
2009-02-15 10:54:03 +00:00
|
|
|
static int pirq_entries[MAX_PIRQS] = {
|
|
|
|
[0 ... MAX_PIRQS - 1] = -1
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static int __init ioapic_pirq_setup(char *str)
|
|
|
|
{
|
|
|
|
int i, max;
|
|
|
|
int ints[MAX_PIRQS+1];
|
|
|
|
|
|
|
|
get_options(str, ARRAY_SIZE(ints), ints);
|
|
|
|
|
|
|
|
apic_printk(APIC_VERBOSE, KERN_INFO
|
|
|
|
"PIRQ redirection, working around broken MP-BIOS.\n");
|
|
|
|
max = MAX_PIRQS;
|
|
|
|
if (ints[0] < MAX_PIRQS)
|
|
|
|
max = ints[0];
|
|
|
|
|
|
|
|
for (i = 0; i < max; i++) {
|
|
|
|
apic_printk(APIC_VERBOSE, KERN_DEBUG
|
|
|
|
"... PIRQ%d -> IRQ %d\n", i, ints[i+1]);
|
|
|
|
/*
|
|
|
|
* PIRQs are mapped upside down, usually.
|
|
|
|
*/
|
|
|
|
pirq_entries[MAX_PIRQS-i-1] = ints[i+1];
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("pirq=", ioapic_pirq_setup);
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif /* CONFIG_X86_32 */
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
struct IO_APIC_route_entry **alloc_ioapic_entries(void)
|
|
|
|
{
|
|
|
|
int apic;
|
|
|
|
struct IO_APIC_route_entry **ioapic_entries;
|
|
|
|
|
|
|
|
ioapic_entries = kzalloc(sizeof(*ioapic_entries) * nr_ioapics,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
if (!ioapic_entries)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (apic = 0; apic < nr_ioapics; apic++) {
|
|
|
|
ioapic_entries[apic] =
|
|
|
|
kzalloc(sizeof(struct IO_APIC_route_entry) *
|
|
|
|
nr_ioapic_registers[apic], GFP_ATOMIC);
|
|
|
|
if (!ioapic_entries[apic])
|
|
|
|
goto nomem;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ioapic_entries;
|
|
|
|
|
|
|
|
nomem:
|
|
|
|
while (--apic >= 0)
|
|
|
|
kfree(ioapic_entries[apic]);
|
|
|
|
kfree(ioapic_entries);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
/*
|
2009-03-17 00:05:03 +00:00
|
|
|
* Saves all the IO-APIC RTE's
|
2008-08-20 07:07:45 +00:00
|
|
|
*/
|
2009-03-27 21:22:44 +00:00
|
|
|
int save_IO_APIC_setup(struct IO_APIC_route_entry **ioapic_entries)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
|
|
|
int apic, pin;
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
if (!ioapic_entries)
|
|
|
|
return -ENOMEM;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
for (apic = 0; apic < nr_ioapics; apic++) {
|
2009-03-27 21:22:44 +00:00
|
|
|
if (!ioapic_entries[apic])
|
|
|
|
return -ENOMEM;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-03-17 00:05:03 +00:00
|
|
|
for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
|
2009-03-27 21:22:44 +00:00
|
|
|
ioapic_entries[apic][pin] =
|
2008-08-20 07:07:45 +00:00
|
|
|
ioapic_read_entry(apic, pin);
|
2009-03-27 21:22:44 +00:00
|
|
|
}
|
2008-09-18 19:37:57 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
/*
|
|
|
|
* Mask all IO APIC entries.
|
|
|
|
*/
|
|
|
|
void mask_IO_APIC_setup(struct IO_APIC_route_entry **ioapic_entries)
|
2009-03-17 00:05:03 +00:00
|
|
|
{
|
|
|
|
int apic, pin;
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
if (!ioapic_entries)
|
|
|
|
return;
|
|
|
|
|
2009-03-17 00:05:03 +00:00
|
|
|
for (apic = 0; apic < nr_ioapics; apic++) {
|
2009-03-27 21:22:44 +00:00
|
|
|
if (!ioapic_entries[apic])
|
2009-03-17 00:05:03 +00:00
|
|
|
break;
|
2009-03-27 21:22:44 +00:00
|
|
|
|
2009-03-17 00:05:03 +00:00
|
|
|
for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
|
|
|
|
struct IO_APIC_route_entry entry;
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
entry = ioapic_entries[apic][pin];
|
2009-03-17 00:05:03 +00:00
|
|
|
if (!entry.mask) {
|
|
|
|
entry.mask = 1;
|
|
|
|
ioapic_write_entry(apic, pin, entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
/*
|
|
|
|
* Restore IO APIC entries which was saved in ioapic_entries.
|
|
|
|
*/
|
|
|
|
int restore_IO_APIC_setup(struct IO_APIC_route_entry **ioapic_entries)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
|
|
|
int apic, pin;
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
if (!ioapic_entries)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-09-18 19:37:57 +00:00
|
|
|
for (apic = 0; apic < nr_ioapics; apic++) {
|
2009-03-27 21:22:44 +00:00
|
|
|
if (!ioapic_entries[apic])
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
for (pin = 0; pin < nr_ioapic_registers[apic]; pin++)
|
|
|
|
ioapic_write_entry(apic, pin,
|
2009-03-27 21:22:44 +00:00
|
|
|
ioapic_entries[apic][pin]);
|
2008-09-18 19:37:57 +00:00
|
|
|
}
|
2009-03-27 21:22:44 +00:00
|
|
|
return 0;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
|
|
|
|
2009-03-27 21:22:44 +00:00
|
|
|
void free_ioapic_entries(struct IO_APIC_route_entry **ioapic_entries)
|
|
|
|
{
|
|
|
|
int apic;
|
|
|
|
|
|
|
|
for (apic = 0; apic < nr_ioapics; apic++)
|
|
|
|
kfree(ioapic_entries[apic]);
|
|
|
|
|
|
|
|
kfree(ioapic_entries);
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the IRQ entry number of a certain pin.
|
|
|
|
*/
|
|
|
|
static int find_irq_entry(int apic, int pin, int type)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < mp_irq_entries; i++)
|
2009-01-12 12:17:22 +00:00
|
|
|
if (mp_irqs[i].irqtype == type &&
|
|
|
|
(mp_irqs[i].dstapic == mp_ioapics[apic].apicid ||
|
|
|
|
mp_irqs[i].dstapic == MP_APIC_ALL) &&
|
|
|
|
mp_irqs[i].dstirq == pin)
|
2005-04-16 22:20:36 +00:00
|
|
|
return i;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the pin to which IRQ[irq] (ISA) is connected
|
|
|
|
*/
|
2005-10-30 22:59:39 +00:00
|
|
|
static int __init find_isa_irq_pin(int irq, int type)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < mp_irq_entries; i++) {
|
2009-01-12 12:17:22 +00:00
|
|
|
int lbus = mp_irqs[i].srcbus;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-20 11:54:18 +00:00
|
|
|
if (test_bit(lbus, mp_bus_not_pci) &&
|
2009-01-12 12:17:22 +00:00
|
|
|
(mp_irqs[i].irqtype == type) &&
|
|
|
|
(mp_irqs[i].srcbusirq == irq))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-12 12:17:22 +00:00
|
|
|
return mp_irqs[i].dstirq;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-10-30 22:59:39 +00:00
|
|
|
static int __init find_isa_irq_apic(int irq, int type)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < mp_irq_entries; i++) {
|
2009-01-12 12:17:22 +00:00
|
|
|
int lbus = mp_irqs[i].srcbus;
|
2005-10-30 22:59:39 +00:00
|
|
|
|
2008-03-20 11:54:24 +00:00
|
|
|
if (test_bit(lbus, mp_bus_not_pci) &&
|
2009-01-12 12:17:22 +00:00
|
|
|
(mp_irqs[i].irqtype == type) &&
|
|
|
|
(mp_irqs[i].srcbusirq == irq))
|
2005-10-30 22:59:39 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i < mp_irq_entries) {
|
|
|
|
int apic;
|
2008-08-20 07:07:45 +00:00
|
|
|
for(apic = 0; apic < nr_ioapics; apic++) {
|
2009-01-12 12:17:22 +00:00
|
|
|
if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic)
|
2005-10-30 22:59:39 +00:00
|
|
|
return apic;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2008-03-20 11:55:02 +00:00
|
|
|
#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* EISA Edge/Level control register, ELCR
|
|
|
|
*/
|
|
|
|
static int EISA_ELCR(unsigned int irq)
|
|
|
|
{
|
2009-08-29 16:09:57 +00:00
|
|
|
if (irq < nr_legacy_irqs) {
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int port = 0x4d0 + (irq >> 3);
|
|
|
|
return (inb(port) >> (irq & 7)) & 1;
|
|
|
|
}
|
|
|
|
apic_printk(APIC_VERBOSE, KERN_INFO
|
|
|
|
"Broken MPtable reports ISA irq %d\n", irq);
|
|
|
|
return 0;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2008-03-20 11:55:02 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-20 11:54:36 +00:00
|
|
|
/* ISA interrupts are always polarity zero edge triggered,
|
|
|
|
* when listed as conforming in the MP table. */
|
|
|
|
|
|
|
|
#define default_ISA_trigger(idx) (0)
|
|
|
|
#define default_ISA_polarity(idx) (0)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* EISA interrupts are always polarity zero and can be edge or level
|
|
|
|
* trigger depending on the ELCR value. If an interrupt is listed as
|
|
|
|
* EISA conforming in the MP table, that means its trigger type must
|
|
|
|
* be read in from the ELCR */
|
|
|
|
|
2009-01-12 12:17:22 +00:00
|
|
|
#define default_EISA_trigger(idx) (EISA_ELCR(mp_irqs[idx].srcbusirq))
|
2008-03-20 11:54:36 +00:00
|
|
|
#define default_EISA_polarity(idx) default_ISA_polarity(idx)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* PCI interrupts are always polarity one level triggered,
|
|
|
|
* when listed as conforming in the MP table. */
|
|
|
|
|
|
|
|
#define default_PCI_trigger(idx) (1)
|
|
|
|
#define default_PCI_polarity(idx) (1)
|
|
|
|
|
|
|
|
/* MCA interrupts are always polarity zero level triggered,
|
|
|
|
* when listed as conforming in the MP table. */
|
|
|
|
|
|
|
|
#define default_MCA_trigger(idx) (1)
|
2008-03-20 11:54:36 +00:00
|
|
|
#define default_MCA_polarity(idx) default_ISA_polarity(idx)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-11-17 06:05:28 +00:00
|
|
|
static int MPBIOS_polarity(int idx)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-01-12 12:17:22 +00:00
|
|
|
int bus = mp_irqs[idx].srcbus;
|
2005-04-16 22:20:36 +00:00
|
|
|
int polarity;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine IRQ line polarity (high active or low active):
|
|
|
|
*/
|
2009-01-12 12:17:22 +00:00
|
|
|
switch (mp_irqs[idx].irqflag & 3)
|
2008-06-08 11:07:18 +00:00
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
case 0: /* conforms, ie. bus-type dependent polarity */
|
|
|
|
if (test_bit(bus, mp_bus_not_pci))
|
|
|
|
polarity = default_ISA_polarity(idx);
|
|
|
|
else
|
|
|
|
polarity = default_PCI_polarity(idx);
|
|
|
|
break;
|
|
|
|
case 1: /* high active */
|
|
|
|
{
|
|
|
|
polarity = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 2: /* reserved */
|
|
|
|
{
|
|
|
|
printk(KERN_WARNING "broken BIOS!!\n");
|
|
|
|
polarity = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 3: /* low active */
|
|
|
|
{
|
|
|
|
polarity = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: /* invalid */
|
|
|
|
{
|
|
|
|
printk(KERN_WARNING "broken BIOS!!\n");
|
|
|
|
polarity = 1;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
return polarity;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int MPBIOS_trigger(int idx)
|
|
|
|
{
|
2009-01-12 12:17:22 +00:00
|
|
|
int bus = mp_irqs[idx].srcbus;
|
2005-04-16 22:20:36 +00:00
|
|
|
int trigger;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine IRQ trigger mode (edge or level sensitive):
|
|
|
|
*/
|
2009-01-12 12:17:22 +00:00
|
|
|
switch ((mp_irqs[idx].irqflag>>2) & 3)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
case 0: /* conforms, ie. bus-type dependent */
|
|
|
|
if (test_bit(bus, mp_bus_not_pci))
|
|
|
|
trigger = default_ISA_trigger(idx);
|
|
|
|
else
|
|
|
|
trigger = default_PCI_trigger(idx);
|
2008-03-20 11:55:02 +00:00
|
|
|
#if defined(CONFIG_EISA) || defined(CONFIG_MCA)
|
2008-08-20 07:07:45 +00:00
|
|
|
switch (mp_bus_id_to_type[bus]) {
|
|
|
|
case MP_BUS_ISA: /* ISA pin */
|
|
|
|
{
|
|
|
|
/* set before the switch */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MP_BUS_EISA: /* EISA pin */
|
|
|
|
{
|
|
|
|
trigger = default_EISA_trigger(idx);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MP_BUS_PCI: /* PCI pin */
|
|
|
|
{
|
|
|
|
/* set before the switch */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case MP_BUS_MCA: /* MCA pin */
|
|
|
|
{
|
|
|
|
trigger = default_MCA_trigger(idx);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
printk(KERN_WARNING "broken BIOS!!\n");
|
|
|
|
trigger = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2008-08-20 07:07:45 +00:00
|
|
|
case 1: /* edge */
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
trigger = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
case 2: /* reserved */
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
printk(KERN_WARNING "broken BIOS!!\n");
|
|
|
|
trigger = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
case 3: /* level */
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
trigger = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
default: /* invalid */
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
printk(KERN_WARNING "broken BIOS!!\n");
|
2008-08-20 07:07:45 +00:00
|
|
|
trigger = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return trigger;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int irq_polarity(int idx)
|
|
|
|
{
|
|
|
|
return MPBIOS_polarity(idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int irq_trigger(int idx)
|
|
|
|
{
|
|
|
|
return MPBIOS_trigger(idx);
|
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:36 +00:00
|
|
|
int (*ioapic_renumber_irq)(int ioapic, int irq);
|
2005-04-16 22:20:36 +00:00
|
|
|
static int pin_2_irq(int idx, int apic, int pin)
|
|
|
|
{
|
|
|
|
int irq, i;
|
2009-01-12 12:17:22 +00:00
|
|
|
int bus = mp_irqs[idx].srcbus;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Debugging check, we are in big trouble if this message pops up!
|
|
|
|
*/
|
2009-01-12 12:17:22 +00:00
|
|
|
if (mp_irqs[idx].dstirq != pin)
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_ERR "broken BIOS or MPTABLE parser, ayiee!!\n");
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (test_bit(bus, mp_bus_not_pci)) {
|
2009-01-12 12:17:22 +00:00
|
|
|
irq = mp_irqs[idx].srcbusirq;
|
2008-08-20 07:07:45 +00:00
|
|
|
} else {
|
2008-03-20 11:54:49 +00:00
|
|
|
/*
|
|
|
|
* PCI IRQs are mapped in order
|
|
|
|
*/
|
|
|
|
i = irq = 0;
|
|
|
|
while (i < apic)
|
|
|
|
irq += nr_ioapic_registers[i++];
|
|
|
|
irq += pin;
|
2008-10-15 13:27:23 +00:00
|
|
|
/*
|
2008-08-20 07:07:45 +00:00
|
|
|
* For MPS mode, so far only needed by ES7000 platform
|
|
|
|
*/
|
2008-10-15 13:27:23 +00:00
|
|
|
if (ioapic_renumber_irq)
|
|
|
|
irq = ioapic_renumber_irq(apic, irq);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* PCI IRQ command line redirection. Yes, limits are hardcoded.
|
|
|
|
*/
|
|
|
|
if ((pin >= 16) && (pin <= 23)) {
|
|
|
|
if (pirq_entries[pin-16] != -1) {
|
|
|
|
if (!pirq_entries[pin-16]) {
|
|
|
|
apic_printk(APIC_VERBOSE, KERN_DEBUG
|
|
|
|
"disabling PIRQ%d\n", pin-16);
|
|
|
|
} else {
|
|
|
|
irq = pirq_entries[pin-16];
|
|
|
|
apic_printk(APIC_VERBOSE, KERN_DEBUG
|
|
|
|
"using PIRQ%d -> IRQ %d\n",
|
|
|
|
pin-16, irq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
|
2009-05-06 17:08:22 +00:00
|
|
|
/*
|
|
|
|
* Find a specific PCI IRQ entry.
|
|
|
|
* Not an __init, possibly needed by modules
|
|
|
|
*/
|
|
|
|
int IO_APIC_get_PCI_irq_vector(int bus, int slot, int pin,
|
2009-05-15 20:05:16 +00:00
|
|
|
struct io_apic_irq_attr *irq_attr)
|
2009-05-06 17:08:22 +00:00
|
|
|
{
|
|
|
|
int apic, i, best_guess = -1;
|
|
|
|
|
|
|
|
apic_printk(APIC_DEBUG,
|
|
|
|
"querying PCI -> IRQ mapping bus:%d, slot:%d, pin:%d.\n",
|
|
|
|
bus, slot, pin);
|
|
|
|
if (test_bit(bus, mp_bus_not_pci)) {
|
|
|
|
apic_printk(APIC_VERBOSE,
|
|
|
|
"PCI BIOS passed nonexistent PCI bus %d!\n", bus);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
for (i = 0; i < mp_irq_entries; i++) {
|
|
|
|
int lbus = mp_irqs[i].srcbus;
|
|
|
|
|
|
|
|
for (apic = 0; apic < nr_ioapics; apic++)
|
|
|
|
if (mp_ioapics[apic].apicid == mp_irqs[i].dstapic ||
|
|
|
|
mp_irqs[i].dstapic == MP_APIC_ALL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!test_bit(lbus, mp_bus_not_pci) &&
|
|
|
|
!mp_irqs[i].irqtype &&
|
|
|
|
(bus == lbus) &&
|
|
|
|
(slot == ((mp_irqs[i].srcbusirq >> 2) & 0x1f))) {
|
|
|
|
int irq = pin_2_irq(i, apic, mp_irqs[i].dstirq);
|
|
|
|
|
|
|
|
if (!(apic || IO_APIC_IRQ(irq)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (pin == (mp_irqs[i].srcbusirq & 3)) {
|
2009-05-15 20:05:16 +00:00
|
|
|
set_io_apic_irq_attr(irq_attr, apic,
|
|
|
|
mp_irqs[i].dstirq,
|
|
|
|
irq_trigger(i),
|
|
|
|
irq_polarity(i));
|
2009-05-06 17:08:22 +00:00
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Use the first all-but-pin matching entry as a
|
|
|
|
* best-guess fuzzy result for broken mptables.
|
|
|
|
*/
|
|
|
|
if (best_guess < 0) {
|
2009-05-15 20:05:16 +00:00
|
|
|
set_io_apic_irq_attr(irq_attr, apic,
|
|
|
|
mp_irqs[i].dstirq,
|
|
|
|
irq_trigger(i),
|
|
|
|
irq_polarity(i));
|
2009-05-06 17:08:22 +00:00
|
|
|
best_guess = irq;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return best_guess;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(IO_APIC_get_PCI_irq_vector);
|
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
void lock_vector_lock(void)
|
|
|
|
{
|
|
|
|
/* Used to the online set of cpus does not change
|
|
|
|
* during assign_irq_vector.
|
|
|
|
*/
|
|
|
|
spin_lock(&vector_lock);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
void unlock_vector_lock(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 03:50:28 +00:00
|
|
|
spin_unlock(&vector_lock);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-17 01:33:52 +00:00
|
|
|
static int
|
|
|
|
__assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
|
2008-08-20 03:50:28 +00:00
|
|
|
{
|
2008-08-20 03:50:41 +00:00
|
|
|
/*
|
|
|
|
* NOTE! The local APIC isn't very good at handling
|
|
|
|
* multiple interrupts at the same interrupt level.
|
|
|
|
* As the interrupt level is determined by taking the
|
|
|
|
* vector number and shifting that right by 4, we
|
|
|
|
* want to spread these out a bit so that they don't
|
|
|
|
* all fall in the same interrupt level.
|
|
|
|
*
|
|
|
|
* Also, we've got to be careful not to trash gate
|
|
|
|
* 0x80, because int 0x80 is hm, kind of importantish. ;)
|
|
|
|
*/
|
2008-08-20 07:07:45 +00:00
|
|
|
static int current_vector = FIRST_DEVICE_VECTOR, current_offset = 0;
|
|
|
|
unsigned int old_vector;
|
2008-12-17 01:33:56 +00:00
|
|
|
int cpu, err;
|
|
|
|
cpumask_var_t tmp_mask;
|
2006-10-04 09:16:47 +00:00
|
|
|
|
2009-10-26 22:24:33 +00:00
|
|
|
if (cfg->move_in_progress)
|
2008-08-20 07:07:45 +00:00
|
|
|
return -EBUSY;
|
2006-06-26 11:56:43 +00:00
|
|
|
|
2008-12-17 01:33:56 +00:00
|
|
|
if (!alloc_cpumask_var(&tmp_mask, GFP_ATOMIC))
|
|
|
|
return -ENOMEM;
|
2006-10-04 09:16:47 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
old_vector = cfg->vector;
|
|
|
|
if (old_vector) {
|
2008-12-17 01:33:56 +00:00
|
|
|
cpumask_and(tmp_mask, mask, cpu_online_mask);
|
|
|
|
cpumask_and(tmp_mask, cfg->domain, tmp_mask);
|
|
|
|
if (!cpumask_empty(tmp_mask)) {
|
|
|
|
free_cpumask_var(tmp_mask);
|
2008-08-20 07:07:45 +00:00
|
|
|
return 0;
|
2008-12-17 01:33:56 +00:00
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-12-17 01:33:52 +00:00
|
|
|
/* Only try and allocate irqs on cpus that are present */
|
2008-12-17 01:33:56 +00:00
|
|
|
err = -ENOSPC;
|
|
|
|
for_each_cpu_and(cpu, mask, cpu_online_mask) {
|
2008-08-20 07:07:45 +00:00
|
|
|
int new_cpu;
|
|
|
|
int vector, offset;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2009-01-28 05:50:47 +00:00
|
|
|
apic->vector_allocation_domain(cpu, tmp_mask);
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
vector = current_vector;
|
|
|
|
offset = current_offset;
|
2008-08-20 03:50:28 +00:00
|
|
|
next:
|
2008-08-20 07:07:45 +00:00
|
|
|
vector += 8;
|
|
|
|
if (vector >= first_system_vector) {
|
2008-12-17 01:33:52 +00:00
|
|
|
/* If out of vectors on large boxen, must share them. */
|
2008-08-20 07:07:45 +00:00
|
|
|
offset = (offset + 1) % 8;
|
|
|
|
vector = FIRST_DEVICE_VECTOR + offset;
|
|
|
|
}
|
|
|
|
if (unlikely(current_vector == vector))
|
|
|
|
continue;
|
2008-12-19 23:23:44 +00:00
|
|
|
|
|
|
|
if (test_bit(vector, used_vectors))
|
2008-08-20 07:07:45 +00:00
|
|
|
goto next;
|
2008-12-19 23:23:44 +00:00
|
|
|
|
2008-12-17 01:33:56 +00:00
|
|
|
for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
|
2008-08-20 07:07:45 +00:00
|
|
|
if (per_cpu(vector_irq, new_cpu)[vector] != -1)
|
|
|
|
goto next;
|
|
|
|
/* Found one! */
|
|
|
|
current_vector = vector;
|
|
|
|
current_offset = offset;
|
|
|
|
if (old_vector) {
|
|
|
|
cfg->move_in_progress = 1;
|
2008-12-17 01:33:56 +00:00
|
|
|
cpumask_copy(cfg->old_domain, cfg->domain);
|
2008-08-20 03:50:32 +00:00
|
|
|
}
|
2008-12-17 01:33:56 +00:00
|
|
|
for_each_cpu_and(new_cpu, tmp_mask, cpu_online_mask)
|
2008-08-20 07:07:45 +00:00
|
|
|
per_cpu(vector_irq, new_cpu)[vector] = irq;
|
|
|
|
cfg->vector = vector;
|
2008-12-17 01:33:56 +00:00
|
|
|
cpumask_copy(cfg->domain, tmp_mask);
|
|
|
|
err = 0;
|
|
|
|
break;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2008-12-17 01:33:56 +00:00
|
|
|
free_cpumask_var(tmp_mask);
|
|
|
|
return err;
|
2008-08-20 03:50:28 +00:00
|
|
|
}
|
|
|
|
|
2009-10-13 20:32:36 +00:00
|
|
|
int assign_irq_vector(int irq, struct irq_cfg *cfg, const struct cpumask *mask)
|
2008-08-20 03:50:28 +00:00
|
|
|
{
|
|
|
|
int err;
|
2006-10-04 09:16:47 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
2008-12-06 02:58:34 +00:00
|
|
|
err = __assign_irq_vector(irq, cfg, mask);
|
2006-06-26 11:57:16 +00:00
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
2008-08-20 03:50:28 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void __clear_irq_vector(int irq, struct irq_cfg *cfg)
|
2008-08-20 03:50:28 +00:00
|
|
|
{
|
|
|
|
int cpu, vector;
|
|
|
|
|
|
|
|
BUG_ON(!cfg->vector);
|
|
|
|
|
|
|
|
vector = cfg->vector;
|
2008-12-17 01:33:56 +00:00
|
|
|
for_each_cpu_and(cpu, cfg->domain, cpu_online_mask)
|
2008-08-20 03:50:28 +00:00
|
|
|
per_cpu(vector_irq, cpu)[vector] = -1;
|
|
|
|
|
|
|
|
cfg->vector = 0;
|
2008-12-17 01:33:56 +00:00
|
|
|
cpumask_clear(cfg->domain);
|
2008-11-20 21:09:33 +00:00
|
|
|
|
|
|
|
if (likely(!cfg->move_in_progress))
|
|
|
|
return;
|
2008-12-17 01:33:56 +00:00
|
|
|
for_each_cpu_and(cpu, cfg->old_domain, cpu_online_mask) {
|
2008-11-20 21:09:33 +00:00
|
|
|
for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS;
|
|
|
|
vector++) {
|
|
|
|
if (per_cpu(vector_irq, cpu)[vector] != irq)
|
|
|
|
continue;
|
|
|
|
per_cpu(vector_irq, cpu)[vector] = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cfg->move_in_progress = 0;
|
2008-08-20 03:50:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void __setup_vector_irq(int cpu)
|
|
|
|
{
|
|
|
|
/* Initialize vector_irq on a new cpu */
|
|
|
|
/* This function must be called with vector_lock held */
|
|
|
|
int irq, vector;
|
|
|
|
struct irq_cfg *cfg;
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_desc *desc;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
|
|
|
/* Mark the inuse vectors */
|
2008-12-06 02:58:31 +00:00
|
|
|
for_each_irq_desc(irq, desc) {
|
|
|
|
cfg = desc->chip_data;
|
2008-12-17 01:33:56 +00:00
|
|
|
if (!cpumask_test_cpu(cpu, cfg->domain))
|
2008-08-20 03:50:28 +00:00
|
|
|
continue;
|
|
|
|
vector = cfg->vector;
|
|
|
|
per_cpu(vector_irq, cpu)[vector] = irq;
|
|
|
|
}
|
|
|
|
/* Mark the free vectors */
|
|
|
|
for (vector = 0; vector < NR_VECTORS; ++vector) {
|
|
|
|
irq = per_cpu(vector_irq, cpu)[vector];
|
|
|
|
if (irq < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cfg = irq_cfg(irq);
|
2008-12-17 01:33:56 +00:00
|
|
|
if (!cpumask_test_cpu(cpu, cfg->domain))
|
2008-08-20 03:50:28 +00:00
|
|
|
per_cpu(vector_irq, cpu)[vector] = -1;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-05-29 03:34:19 +00:00
|
|
|
|
2006-10-04 09:16:26 +00:00
|
|
|
static struct irq_chip ioapic_chip;
|
2008-08-20 07:07:45 +00:00
|
|
|
static struct irq_chip ir_ioapic_chip;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#define IOAPIC_AUTO -1
|
|
|
|
#define IOAPIC_EDGE 0
|
|
|
|
#define IOAPIC_LEVEL 1
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 03:50:41 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-08-20 03:50:34 +00:00
|
|
|
static inline int IO_APIC_irq_trigger(int irq)
|
|
|
|
{
|
2008-10-15 13:27:23 +00:00
|
|
|
int apic, idx, pin;
|
2008-08-20 03:50:34 +00:00
|
|
|
|
2008-10-15 13:27:23 +00:00
|
|
|
for (apic = 0; apic < nr_ioapics; apic++) {
|
|
|
|
for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
|
|
|
|
idx = find_irq_entry(apic, pin, mp_INT);
|
|
|
|
if ((idx != -1) && (irq == pin_2_irq(idx, apic, pin)))
|
|
|
|
return irq_trigger(idx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
2008-08-20 07:07:45 +00:00
|
|
|
* nonexistent IRQs are edge default
|
|
|
|
*/
|
2008-10-15 13:27:23 +00:00
|
|
|
return 0;
|
2008-08-20 03:50:34 +00:00
|
|
|
}
|
2008-08-20 03:50:41 +00:00
|
|
|
#else
|
|
|
|
static inline int IO_APIC_irq_trigger(int irq)
|
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
return 1;
|
2008-08-20 03:50:41 +00:00
|
|
|
}
|
|
|
|
#endif
|
2008-08-20 03:50:34 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void ioapic_register_intr(int irq, struct irq_desc *desc, unsigned long trigger)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 03:50:27 +00:00
|
|
|
|
2006-06-26 11:56:46 +00:00
|
|
|
if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
|
2008-08-20 03:50:41 +00:00
|
|
|
trigger == IOAPIC_LEVEL)
|
2008-08-20 03:50:05 +00:00
|
|
|
desc->status |= IRQ_LEVEL;
|
2008-08-20 03:50:41 +00:00
|
|
|
else
|
|
|
|
desc->status &= ~IRQ_LEVEL;
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (irq_remapped(irq)) {
|
|
|
|
desc->status |= IRQ_MOVE_PCNTXT;
|
|
|
|
if (trigger)
|
|
|
|
set_irq_chip_and_handler_name(irq, &ir_ioapic_chip,
|
|
|
|
handle_fasteoi_irq,
|
|
|
|
"fasteoi");
|
|
|
|
else
|
|
|
|
set_irq_chip_and_handler_name(irq, &ir_ioapic_chip,
|
|
|
|
handle_edge_irq, "edge");
|
|
|
|
return;
|
|
|
|
}
|
2009-03-17 00:05:02 +00:00
|
|
|
|
2008-08-20 03:50:41 +00:00
|
|
|
if ((trigger == IOAPIC_AUTO && IO_APIC_irq_trigger(irq)) ||
|
|
|
|
trigger == IOAPIC_LEVEL)
|
2006-10-17 07:10:03 +00:00
|
|
|
set_irq_chip_and_handler_name(irq, &ioapic_chip,
|
2008-08-20 07:07:45 +00:00
|
|
|
handle_fasteoi_irq,
|
|
|
|
"fasteoi");
|
2008-08-20 03:50:41 +00:00
|
|
|
else
|
2006-10-17 07:10:03 +00:00
|
|
|
set_irq_chip_and_handler_name(irq, &ioapic_chip,
|
2008-08-20 07:07:45 +00:00
|
|
|
handle_edge_irq, "edge");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-02-09 20:05:47 +00:00
|
|
|
int setup_ioapic_entry(int apic_id, int irq,
|
|
|
|
struct IO_APIC_route_entry *entry,
|
|
|
|
unsigned int destination, int trigger,
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
int polarity, int vector, int pin)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 03:50:28 +00:00
|
|
|
/*
|
|
|
|
* add it to the IO-APIC irq-routing table:
|
|
|
|
*/
|
|
|
|
memset(entry,0,sizeof(*entry));
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (intr_remapping_enabled) {
|
2009-01-27 23:14:11 +00:00
|
|
|
struct intel_iommu *iommu = map_ioapic_to_ir(apic_id);
|
2008-08-20 07:07:45 +00:00
|
|
|
struct irte irte;
|
|
|
|
struct IR_IO_APIC_route_entry *ir_entry =
|
|
|
|
(struct IR_IO_APIC_route_entry *) entry;
|
|
|
|
int index;
|
|
|
|
|
|
|
|
if (!iommu)
|
2009-01-27 23:14:11 +00:00
|
|
|
panic("No mapping iommu for ioapic %d\n", apic_id);
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
index = alloc_irte(iommu, irq, 1);
|
|
|
|
if (index < 0)
|
2009-01-27 23:14:11 +00:00
|
|
|
panic("Failed to allocate IRTE for ioapic %d\n", apic_id);
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
memset(&irte, 0, sizeof(irte));
|
|
|
|
|
|
|
|
irte.present = 1;
|
2009-01-28 03:09:58 +00:00
|
|
|
irte.dst_mode = apic->irq_dest_mode;
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
/*
|
|
|
|
* Trigger mode in the IRTE will always be edge, and the
|
|
|
|
* actual level or edge trigger will be setup in the IO-APIC
|
|
|
|
* RTE. This will help simplify level triggered irq migration.
|
|
|
|
* For more details, see the comments above explainig IO-APIC
|
|
|
|
* irq migration in the presence of interrupt-remapping.
|
|
|
|
*/
|
|
|
|
irte.trigger_mode = 0;
|
2009-01-28 03:09:58 +00:00
|
|
|
irte.dlvry_mode = apic->irq_delivery_mode;
|
2008-08-20 07:07:45 +00:00
|
|
|
irte.vector = vector;
|
|
|
|
irte.dest_id = IRTE_DEST(destination);
|
|
|
|
|
2009-05-22 16:41:15 +00:00
|
|
|
/* Set source-id of interrupt request */
|
|
|
|
set_ioapic_sid(&irte, apic_id);
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
modify_irte(irq, &irte);
|
|
|
|
|
|
|
|
ir_entry->index2 = (index >> 15) & 0x1;
|
|
|
|
ir_entry->zero = 0;
|
|
|
|
ir_entry->format = 1;
|
|
|
|
ir_entry->index = (index & 0x7fff);
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
/*
|
|
|
|
* IO-APIC RTE will be configured with virtual vector.
|
|
|
|
* irq handler will do the explicit EOI to the io-apic.
|
|
|
|
*/
|
|
|
|
ir_entry->vector = pin;
|
2009-03-17 00:05:02 +00:00
|
|
|
} else {
|
2009-01-28 03:09:58 +00:00
|
|
|
entry->delivery_mode = apic->irq_delivery_mode;
|
|
|
|
entry->dest_mode = apic->irq_dest_mode;
|
2008-08-20 07:07:45 +00:00
|
|
|
entry->dest = destination;
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
entry->vector = vector;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
entry->mask = 0; /* enable IRQ */
|
2008-08-20 03:50:28 +00:00
|
|
|
entry->trigger = trigger;
|
|
|
|
entry->polarity = polarity;
|
|
|
|
|
|
|
|
/* Mask level triggered irqs.
|
|
|
|
* Use IRQ_DELAYED_DISABLE for edge triggered irqs.
|
|
|
|
*/
|
|
|
|
if (trigger)
|
|
|
|
entry->mask = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-27 23:14:11 +00:00
|
|
|
static void setup_IO_APIC_irq(int apic_id, int pin, unsigned int irq, struct irq_desc *desc,
|
2008-08-20 07:07:45 +00:00
|
|
|
int trigger, int polarity)
|
2008-08-20 03:50:28 +00:00
|
|
|
{
|
|
|
|
struct irq_cfg *cfg;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct IO_APIC_route_entry entry;
|
2008-12-17 01:33:56 +00:00
|
|
|
unsigned int dest;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
|
|
|
if (!IO_APIC_IRQ(irq))
|
|
|
|
return;
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2009-01-28 03:32:51 +00:00
|
|
|
if (assign_irq_vector(irq, cfg, apic->target_cpus()))
|
2008-08-20 03:50:28 +00:00
|
|
|
return;
|
|
|
|
|
2009-01-28 14:20:18 +00:00
|
|
|
dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
|
2008-08-20 03:50:28 +00:00
|
|
|
|
|
|
|
apic_printk(APIC_VERBOSE,KERN_DEBUG
|
|
|
|
"IOAPIC[%d]: Set routing entry (%d-%d -> 0x%x -> "
|
|
|
|
"IRQ %d Mode:%i Active:%i)\n",
|
2009-01-27 23:14:11 +00:00
|
|
|
apic_id, mp_ioapics[apic_id].apicid, pin, cfg->vector,
|
2008-08-20 03:50:28 +00:00
|
|
|
irq, trigger, polarity);
|
|
|
|
|
|
|
|
|
2009-01-27 23:14:11 +00:00
|
|
|
if (setup_ioapic_entry(mp_ioapics[apic_id].apicid, irq, &entry,
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
dest, trigger, polarity, cfg->vector, pin)) {
|
2008-08-20 03:50:28 +00:00
|
|
|
printk("Failed to setup ioapic entry for ioapic %d, pin %d\n",
|
2009-01-27 23:14:11 +00:00
|
|
|
mp_ioapics[apic_id].apicid, pin);
|
2008-12-06 02:58:34 +00:00
|
|
|
__clear_irq_vector(irq, cfg);
|
2008-08-20 03:50:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
ioapic_register_intr(irq, desc, trigger);
|
2009-08-29 16:09:57 +00:00
|
|
|
if (irq < nr_legacy_irqs)
|
2008-08-20 03:50:28 +00:00
|
|
|
disable_8259A_irq(irq);
|
|
|
|
|
2009-01-27 23:14:11 +00:00
|
|
|
ioapic_write_entry(apic_id, pin, entry);
|
2008-08-20 03:50:28 +00:00
|
|
|
}
|
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
static struct {
|
|
|
|
DECLARE_BITMAP(pin_programmed, MP_MAX_IOAPIC_PIN + 1);
|
|
|
|
} mp_ioapic_routing[MAX_IO_APICS];
|
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
static void __init setup_IO_APIC_irqs(void)
|
|
|
|
{
|
2009-05-06 17:10:06 +00:00
|
|
|
int apic_id = 0, pin, idx, irq;
|
2008-09-06 10:15:33 +00:00
|
|
|
int notcon = 0;
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_desc *desc;
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_cfg *cfg;
|
2009-04-28 01:00:38 +00:00
|
|
|
int node = cpu_to_node(boot_cpu_id);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
apic_printk(APIC_VERBOSE, KERN_DEBUG "init IO_APIC IRQs\n");
|
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
if (!acpi_disabled && acpi_ioapic) {
|
|
|
|
apic_id = mp_find_ioapic(0);
|
|
|
|
if (apic_id < 0)
|
|
|
|
apic_id = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2008-09-06 10:15:33 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
for (pin = 0; pin < nr_ioapic_registers[apic_id]; pin++) {
|
|
|
|
idx = find_irq_entry(apic_id, pin, mp_INT);
|
|
|
|
if (idx == -1) {
|
|
|
|
if (!notcon) {
|
|
|
|
notcon = 1;
|
|
|
|
apic_printk(APIC_VERBOSE,
|
|
|
|
KERN_DEBUG " %d-%d",
|
|
|
|
mp_ioapics[apic_id].apicid, pin);
|
|
|
|
} else
|
|
|
|
apic_printk(APIC_VERBOSE, " %d-%d",
|
|
|
|
mp_ioapics[apic_id].apicid, pin);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (notcon) {
|
|
|
|
apic_printk(APIC_VERBOSE,
|
|
|
|
" (apicid-pin) not connected\n");
|
|
|
|
notcon = 0;
|
|
|
|
}
|
2009-01-28 06:17:26 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
irq = pin_2_irq(idx, apic_id, pin);
|
2009-01-28 06:17:26 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
/*
|
|
|
|
* Skip the timer IRQ if there's a quirk handler
|
|
|
|
* installed and if it returns 1:
|
|
|
|
*/
|
|
|
|
if (apic->multi_timer_check &&
|
|
|
|
apic->multi_timer_check(apic_id, irq))
|
|
|
|
continue;
|
2008-06-08 11:07:18 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
desc = irq_to_desc_alloc_node(irq, node);
|
|
|
|
if (!desc) {
|
|
|
|
printk(KERN_INFO "can not get irq_desc for %d\n", irq);
|
|
|
|
continue;
|
2008-09-06 10:15:33 +00:00
|
|
|
}
|
2009-05-06 17:10:06 +00:00
|
|
|
cfg = desc->chip_data;
|
|
|
|
add_pin_to_irq_node(cfg, node, apic_id, pin);
|
2009-05-18 17:23:28 +00:00
|
|
|
/*
|
|
|
|
* don't mark it in pin_programmed, so later acpi could
|
|
|
|
* set it correctly when irq < 16
|
|
|
|
*/
|
2009-05-06 17:10:06 +00:00
|
|
|
setup_IO_APIC_irq(apic_id, pin, irq, desc,
|
|
|
|
irq_trigger(idx), irq_polarity(idx));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-09-06 10:15:33 +00:00
|
|
|
if (notcon)
|
|
|
|
apic_printk(APIC_VERBOSE,
|
2008-09-08 15:38:06 +00:00
|
|
|
" (apicid-pin) not connected\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-05-27 20:19:34 +00:00
|
|
|
* Set up the timer pin, possibly with the 8259A-master behind.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-01-27 23:14:11 +00:00
|
|
|
static void __init setup_timer_IRQ0_pin(unsigned int apic_id, unsigned int pin,
|
2008-05-27 20:19:34 +00:00
|
|
|
int vector)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct IO_APIC_route_entry entry;
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (intr_remapping_enabled)
|
|
|
|
return;
|
|
|
|
|
2008-06-08 11:07:18 +00:00
|
|
|
memset(&entry, 0, sizeof(entry));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We use logical delivery to get the timer IRQ
|
|
|
|
* to the first CPU.
|
|
|
|
*/
|
2009-01-28 03:09:58 +00:00
|
|
|
entry.dest_mode = apic->irq_dest_mode;
|
2009-02-09 00:18:03 +00:00
|
|
|
entry.mask = 0; /* don't mask IRQ for edge */
|
2009-01-28 14:20:18 +00:00
|
|
|
entry.dest = apic->cpu_mask_to_apicid(apic->target_cpus());
|
2009-01-28 03:09:58 +00:00
|
|
|
entry.delivery_mode = apic->irq_delivery_mode;
|
2005-04-16 22:20:36 +00:00
|
|
|
entry.polarity = 0;
|
|
|
|
entry.trigger = 0;
|
|
|
|
entry.vector = vector;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The timer IRQ doesn't have to know that behind the
|
2008-05-27 20:19:34 +00:00
|
|
|
* scene we may have a 8259A-master in AEOI mode ...
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-08-20 07:07:45 +00:00
|
|
|
set_irq_chip_and_handler_name(0, &ioapic_chip, handle_edge_irq, "edge");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add it to the IO-APIC irq-routing table:
|
|
|
|
*/
|
2009-01-27 23:14:11 +00:00
|
|
|
ioapic_write_entry(apic_id, pin, entry);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-20 23:52:49 +00:00
|
|
|
|
|
|
|
__apicdebuginit(void) print_IO_APIC(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int apic, i;
|
|
|
|
union IO_APIC_reg_00 reg_00;
|
|
|
|
union IO_APIC_reg_01 reg_01;
|
|
|
|
union IO_APIC_reg_02 reg_02;
|
|
|
|
union IO_APIC_reg_03 reg_03;
|
|
|
|
unsigned long flags;
|
2008-08-20 03:50:26 +00:00
|
|
|
struct irq_cfg *cfg;
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_desc *desc;
|
2008-08-20 03:50:51 +00:00
|
|
|
unsigned int irq;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-08 11:07:18 +00:00
|
|
|
printk(KERN_DEBUG "number of MP IRQ sources: %d.\n", mp_irq_entries);
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < nr_ioapics; i++)
|
|
|
|
printk(KERN_DEBUG "number of IO-APIC #%d registers: %d.\n",
|
2009-01-12 12:16:17 +00:00
|
|
|
mp_ioapics[i].apicid, nr_ioapic_registers[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We are a bit conservative about what we expect. We have to
|
|
|
|
* know about every hardware change ASAP.
|
|
|
|
*/
|
|
|
|
printk(KERN_INFO "testing the IO APIC.......................\n");
|
|
|
|
|
|
|
|
for (apic = 0; apic < nr_ioapics; apic++) {
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
reg_00.raw = io_apic_read(apic, 0);
|
|
|
|
reg_01.raw = io_apic_read(apic, 1);
|
|
|
|
if (reg_01.bits.version >= 0x10)
|
|
|
|
reg_02.raw = io_apic_read(apic, 2);
|
2008-10-15 13:27:23 +00:00
|
|
|
if (reg_01.bits.version >= 0x20)
|
|
|
|
reg_03.raw = io_apic_read(apic, 3);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
printk("\n");
|
2009-01-12 12:16:17 +00:00
|
|
|
printk(KERN_DEBUG "IO APIC #%d......\n", mp_ioapics[apic].apicid);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_DEBUG ".... register #00: %08X\n", reg_00.raw);
|
|
|
|
printk(KERN_DEBUG "....... : physical APIC id: %02X\n", reg_00.bits.ID);
|
|
|
|
printk(KERN_DEBUG "....... : Delivery Type: %X\n", reg_00.bits.delivery_type);
|
|
|
|
printk(KERN_DEBUG "....... : LTS : %X\n", reg_00.bits.LTS);
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
printk(KERN_DEBUG ".... register #01: %08X\n", *(int *)®_01);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_DEBUG "....... : max redirection entries: %04X\n", reg_01.bits.entries);
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "....... : PRQ implemented: %X\n", reg_01.bits.PRQ);
|
|
|
|
printk(KERN_DEBUG "....... : IO APIC version: %04X\n", reg_01.bits.version);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some Intel chipsets with IO APIC VERSION of 0x1? don't have reg_02,
|
|
|
|
* but the value of reg_02 is read as the previous read register
|
|
|
|
* value, so ignore it if reg_02 == reg_01.
|
|
|
|
*/
|
|
|
|
if (reg_01.bits.version >= 0x10 && reg_02.raw != reg_01.raw) {
|
|
|
|
printk(KERN_DEBUG ".... register #02: %08X\n", reg_02.raw);
|
|
|
|
printk(KERN_DEBUG "....... : arbitration: %02X\n", reg_02.bits.arbitration);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some Intel chipsets with IO APIC VERSION of 0x2? don't have reg_02
|
|
|
|
* or reg_03, but the value of reg_0[23] is read as the previous read
|
|
|
|
* register value, so ignore it if reg_03 == reg_0[12].
|
|
|
|
*/
|
|
|
|
if (reg_01.bits.version >= 0x20 && reg_03.raw != reg_02.raw &&
|
|
|
|
reg_03.raw != reg_01.raw) {
|
|
|
|
printk(KERN_DEBUG ".... register #03: %08X\n", reg_03.raw);
|
|
|
|
printk(KERN_DEBUG "....... : Boot DT : %X\n", reg_03.bits.boot_DT);
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_DEBUG ".... IRQ redirection table:\n");
|
|
|
|
|
2008-08-20 03:50:33 +00:00
|
|
|
printk(KERN_DEBUG " NR Dst Mask Trig IRR Pol"
|
|
|
|
" Stat Dmod Deli Vect: \n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (i = 0; i <= reg_01.bits.entries; i++) {
|
|
|
|
struct IO_APIC_route_entry entry;
|
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
entry = ioapic_read_entry(apic, i);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
printk(KERN_DEBUG " %02x %03X ",
|
|
|
|
i,
|
|
|
|
entry.dest
|
|
|
|
);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
printk("%1d %1d %1d %1d %1d %1d %1d %02X\n",
|
|
|
|
entry.mask,
|
|
|
|
entry.trigger,
|
|
|
|
entry.irr,
|
|
|
|
entry.polarity,
|
|
|
|
entry.delivery_status,
|
|
|
|
entry.dest_mode,
|
|
|
|
entry.delivery_mode,
|
|
|
|
entry.vector
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printk(KERN_DEBUG "IRQ to pin mappings:\n");
|
2008-12-06 02:58:31 +00:00
|
|
|
for_each_irq_desc(irq, desc) {
|
|
|
|
struct irq_pin_list *entry;
|
|
|
|
|
|
|
|
cfg = desc->chip_data;
|
|
|
|
entry = cfg->irq_2_pin;
|
2008-08-20 03:50:26 +00:00
|
|
|
if (!entry)
|
2005-04-16 22:20:36 +00:00
|
|
|
continue;
|
2008-08-20 03:50:51 +00:00
|
|
|
printk(KERN_DEBUG "IRQ%d ", irq);
|
2009-08-01 07:47:59 +00:00
|
|
|
for_each_irq_pin(entry, cfg->irq_2_pin)
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("-> %d:%d", entry->apic, entry->pin);
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO ".................................... done.\n");
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-07-02 06:54:01 +00:00
|
|
|
__apicdebuginit(void) print_APIC_field(int base)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-07-02 06:54:01 +00:00
|
|
|
int i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-02 06:54:01 +00:00
|
|
|
printk(KERN_DEBUG);
|
|
|
|
|
|
|
|
for (i = 0; i < 8; i++)
|
|
|
|
printk(KERN_CONT "%08x", apic_read(base + i*0x10));
|
|
|
|
|
|
|
|
printk(KERN_CONT "\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-20 23:52:49 +00:00
|
|
|
__apicdebuginit(void) print_local_APIC(void *dummy)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-05-08 16:23:50 +00:00
|
|
|
unsigned int i, v, ver, maxlvt;
|
2008-07-31 00:36:48 +00:00
|
|
|
u64 icr;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-02 06:54:01 +00:00
|
|
|
printk(KERN_DEBUG "printing local APIC contents on CPU#%d/%d:\n",
|
2005-04-16 22:20:36 +00:00
|
|
|
smp_processor_id(), hard_smp_processor_id());
|
2008-06-05 14:35:10 +00:00
|
|
|
v = apic_read(APIC_ID);
|
2008-08-20 07:07:45 +00:00
|
|
|
printk(KERN_INFO "... APIC ID: %08x (%01x)\n", v, read_apic_id());
|
2005-04-16 22:20:36 +00:00
|
|
|
v = apic_read(APIC_LVR);
|
|
|
|
printk(KERN_INFO "... APIC VERSION: %08x\n", v);
|
|
|
|
ver = GET_APIC_VERSION(v);
|
2007-02-16 09:27:58 +00:00
|
|
|
maxlvt = lapic_get_maxlvt();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
v = apic_read(APIC_TASKPRI);
|
|
|
|
printk(KERN_DEBUG "... APIC TASKPRI: %08x (%02x)\n", v, v & APIC_TPRI_MASK);
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (APIC_INTEGRATED(ver)) { /* !82489DX */
|
2008-09-03 23:58:31 +00:00
|
|
|
if (!APIC_XAPIC(ver)) {
|
|
|
|
v = apic_read(APIC_ARBPRI);
|
|
|
|
printk(KERN_DEBUG "... APIC ARBPRI: %08x (%02x)\n", v,
|
|
|
|
v & APIC_ARBPRI_MASK);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
v = apic_read(APIC_PROCPRI);
|
|
|
|
printk(KERN_DEBUG "... APIC PROCPRI: %08x\n", v);
|
|
|
|
}
|
|
|
|
|
2008-09-03 23:58:31 +00:00
|
|
|
/*
|
|
|
|
* Remote read supported only in the 82489DX and local APIC for
|
|
|
|
* Pentium processors.
|
|
|
|
*/
|
|
|
|
if (!APIC_INTEGRATED(ver) || maxlvt == 3) {
|
|
|
|
v = apic_read(APIC_RRR);
|
|
|
|
printk(KERN_DEBUG "... APIC RRR: %08x\n", v);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
v = apic_read(APIC_LDR);
|
|
|
|
printk(KERN_DEBUG "... APIC LDR: %08x\n", v);
|
2008-09-03 23:58:31 +00:00
|
|
|
if (!x2apic_enabled()) {
|
|
|
|
v = apic_read(APIC_DFR);
|
|
|
|
printk(KERN_DEBUG "... APIC DFR: %08x\n", v);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
v = apic_read(APIC_SPIV);
|
|
|
|
printk(KERN_DEBUG "... APIC SPIV: %08x\n", v);
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "... APIC ISR field:\n");
|
2009-07-02 06:54:01 +00:00
|
|
|
print_APIC_field(APIC_ISR);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_DEBUG "... APIC TMR field:\n");
|
2009-07-02 06:54:01 +00:00
|
|
|
print_APIC_field(APIC_TMR);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_DEBUG "... APIC IRR field:\n");
|
2009-07-02 06:54:01 +00:00
|
|
|
print_APIC_field(APIC_IRR);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (APIC_INTEGRATED(ver)) { /* !82489DX */
|
|
|
|
if (maxlvt > 3) /* Due to the Pentium erratum 3AP. */
|
2005-04-16 22:20:36 +00:00
|
|
|
apic_write(APIC_ESR, 0);
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
v = apic_read(APIC_ESR);
|
|
|
|
printk(KERN_DEBUG "... APIC ESR: %08x\n", v);
|
|
|
|
}
|
|
|
|
|
2008-07-31 00:36:48 +00:00
|
|
|
icr = apic_icr_read();
|
2008-08-18 11:04:26 +00:00
|
|
|
printk(KERN_DEBUG "... APIC ICR: %08x\n", (u32)icr);
|
|
|
|
printk(KERN_DEBUG "... APIC ICR2: %08x\n", (u32)(icr >> 32));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
v = apic_read(APIC_LVTT);
|
|
|
|
printk(KERN_DEBUG "... APIC LVTT: %08x\n", v);
|
|
|
|
|
|
|
|
if (maxlvt > 3) { /* PC is LVT#4. */
|
|
|
|
v = apic_read(APIC_LVTPC);
|
|
|
|
printk(KERN_DEBUG "... APIC LVTPC: %08x\n", v);
|
|
|
|
}
|
|
|
|
v = apic_read(APIC_LVT0);
|
|
|
|
printk(KERN_DEBUG "... APIC LVT0: %08x\n", v);
|
|
|
|
v = apic_read(APIC_LVT1);
|
|
|
|
printk(KERN_DEBUG "... APIC LVT1: %08x\n", v);
|
|
|
|
|
|
|
|
if (maxlvt > 2) { /* ERR is LVT#3. */
|
|
|
|
v = apic_read(APIC_LVTERR);
|
|
|
|
printk(KERN_DEBUG "... APIC LVTERR: %08x\n", v);
|
|
|
|
}
|
|
|
|
|
|
|
|
v = apic_read(APIC_TMICT);
|
|
|
|
printk(KERN_DEBUG "... APIC TMICT: %08x\n", v);
|
|
|
|
v = apic_read(APIC_TMCCT);
|
|
|
|
printk(KERN_DEBUG "... APIC TMCCT: %08x\n", v);
|
|
|
|
v = apic_read(APIC_TDCR);
|
|
|
|
printk(KERN_DEBUG "... APIC TDCR: %08x\n", v);
|
2009-05-08 16:23:50 +00:00
|
|
|
|
|
|
|
if (boot_cpu_has(X86_FEATURE_EXTAPIC)) {
|
|
|
|
v = apic_read(APIC_EFEAT);
|
|
|
|
maxlvt = (v >> 16) & 0xff;
|
|
|
|
printk(KERN_DEBUG "... APIC EFEAT: %08x\n", v);
|
|
|
|
v = apic_read(APIC_ECTRL);
|
|
|
|
printk(KERN_DEBUG "... APIC ECTRL: %08x\n", v);
|
|
|
|
for (i = 0; i < maxlvt; i++) {
|
|
|
|
v = apic_read(APIC_EILVTn(i));
|
|
|
|
printk(KERN_DEBUG "... APIC EILVT%d: %08x\n", i, v);
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
|
2009-10-13 20:07:05 +00:00
|
|
|
__apicdebuginit(void) print_local_APICs(int maxcpu)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 03:50:50 +00:00
|
|
|
int cpu;
|
|
|
|
|
2009-10-13 20:07:05 +00:00
|
|
|
if (!maxcpu)
|
|
|
|
return;
|
|
|
|
|
2008-08-20 03:50:50 +00:00
|
|
|
preempt_disable();
|
2009-10-13 20:07:05 +00:00
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
if (cpu >= maxcpu)
|
|
|
|
break;
|
2008-08-20 03:50:50 +00:00
|
|
|
smp_call_function_single(cpu, print_local_APIC, NULL, 1);
|
2009-10-13 20:07:05 +00:00
|
|
|
}
|
2008-08-20 03:50:50 +00:00
|
|
|
preempt_enable();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-07-20 23:52:49 +00:00
|
|
|
__apicdebuginit(void) print_PIC(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned int v;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-10-13 20:07:05 +00:00
|
|
|
if (!nr_legacy_irqs)
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "\nprinting PIC contents\n");
|
|
|
|
|
|
|
|
spin_lock_irqsave(&i8259A_lock, flags);
|
|
|
|
|
|
|
|
v = inb(0xa1) << 8 | inb(0x21);
|
|
|
|
printk(KERN_DEBUG "... PIC IMR: %04x\n", v);
|
|
|
|
|
|
|
|
v = inb(0xa0) << 8 | inb(0x20);
|
|
|
|
printk(KERN_DEBUG "... PIC IRR: %04x\n", v);
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
outb(0x0b,0xa0);
|
|
|
|
outb(0x0b,0x20);
|
2005-04-16 22:20:36 +00:00
|
|
|
v = inb(0xa0) << 8 | inb(0x20);
|
2008-08-20 07:07:45 +00:00
|
|
|
outb(0x0a,0xa0);
|
|
|
|
outb(0x0a,0x20);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&i8259A_lock, flags);
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "... PIC ISR: %04x\n", v);
|
|
|
|
|
|
|
|
v = inb(0x4d1) << 8 | inb(0x4d0);
|
|
|
|
printk(KERN_DEBUG "... PIC ELCR: %04x\n", v);
|
|
|
|
}
|
|
|
|
|
2009-10-13 20:07:05 +00:00
|
|
|
static int __initdata show_lapic = 1;
|
|
|
|
static __init int setup_show_lapic(char *arg)
|
|
|
|
{
|
|
|
|
int num = -1;
|
|
|
|
|
|
|
|
if (strcmp(arg, "all") == 0) {
|
|
|
|
show_lapic = CONFIG_NR_CPUS;
|
|
|
|
} else {
|
|
|
|
get_option(&arg, &num);
|
|
|
|
if (num >= 0)
|
|
|
|
show_lapic = num;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("show_lapic=", setup_show_lapic);
|
|
|
|
|
|
|
|
__apicdebuginit(int) print_ICs(void)
|
2008-07-20 23:52:49 +00:00
|
|
|
{
|
2009-10-13 20:07:05 +00:00
|
|
|
if (apic_verbosity == APIC_QUIET)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-20 23:52:49 +00:00
|
|
|
print_PIC();
|
x86: read apic ID in the !acpi_lapic case
Ed found that on 32-bit, boot_cpu_physical_apicid is not read right,
when the mptable is broken.
Interestingly, actually three paths use/set it:
1. acpi: at that time that is already read from reg
2. mptable: only read from mptable
3. no madt, and no mptable, that use default apic id 0 for 64-bit, -1 for 32-bit
so we could read the apic id for the 2/3 path. We trust the hardware
register more than we trust a BIOS data structure (the mptable).
We can also avoid the double set_fixmap() when acpi_lapic
is used, and also need to move cpu_has_apic earlier and
call apic_disable().
Also when need to update the apic id, we'd better read and
set the apic version as well - so that quirks are applied precisely.
v2: make path 3 with 64bit, use -1 as apic id, so could read it later.
v3: fix whitespace problem pointed out by Ed Swierk
v5: fix boot crash
[ Impact: get correct apic id for bsp other than acpi path ]
Reported-by: Ed Swierk <eswierk@aristanetworks.com>
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Acked-by: Cyrill Gorcunov <gorcunov@openvz.org>
LKML-Reference: <49FC85A9.2070702@kernel.org>
[ v4: sanity-check in the ACPI case too ]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-05-02 17:40:57 +00:00
|
|
|
|
|
|
|
/* don't print out if apic is not there */
|
2009-09-15 07:12:30 +00:00
|
|
|
if (!cpu_has_apic && !apic_from_smp_config())
|
x86: read apic ID in the !acpi_lapic case
Ed found that on 32-bit, boot_cpu_physical_apicid is not read right,
when the mptable is broken.
Interestingly, actually three paths use/set it:
1. acpi: at that time that is already read from reg
2. mptable: only read from mptable
3. no madt, and no mptable, that use default apic id 0 for 64-bit, -1 for 32-bit
so we could read the apic id for the 2/3 path. We trust the hardware
register more than we trust a BIOS data structure (the mptable).
We can also avoid the double set_fixmap() when acpi_lapic
is used, and also need to move cpu_has_apic earlier and
call apic_disable().
Also when need to update the apic id, we'd better read and
set the apic version as well - so that quirks are applied precisely.
v2: make path 3 with 64bit, use -1 as apic id, so could read it later.
v3: fix whitespace problem pointed out by Ed Swierk
v5: fix boot crash
[ Impact: get correct apic id for bsp other than acpi path ]
Reported-by: Ed Swierk <eswierk@aristanetworks.com>
Signed-off-by: Yinghai Lu <yinghai@kernel.org>
Acked-by: Cyrill Gorcunov <gorcunov@openvz.org>
LKML-Reference: <49FC85A9.2070702@kernel.org>
[ v4: sanity-check in the ACPI case too ]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-05-02 17:40:57 +00:00
|
|
|
return 0;
|
|
|
|
|
2009-10-13 20:07:05 +00:00
|
|
|
print_local_APICs(show_lapic);
|
2008-07-20 23:52:49 +00:00
|
|
|
print_IO_APIC();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-13 20:07:05 +00:00
|
|
|
fs_initcall(print_ICs);
|
2008-07-20 23:52:49 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 03:50:36 +00:00
|
|
|
/* Where if anywhere is the i8259 connect in external int mode */
|
|
|
|
static struct { int pin, apic; } ioapic_i8259 = { -1, -1 };
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
void __init enable_IO_APIC(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
union IO_APIC_reg_01 reg_01;
|
2005-10-30 22:59:39 +00:00
|
|
|
int i8259_apic, i8259_pin;
|
2008-08-20 07:07:45 +00:00
|
|
|
int apic;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The number of IO-APIC IRQ registers (== #pins):
|
|
|
|
*/
|
2005-10-30 22:59:39 +00:00
|
|
|
for (apic = 0; apic < nr_ioapics; apic++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2005-10-30 22:59:39 +00:00
|
|
|
reg_01.raw = io_apic_read(apic, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
2005-10-30 22:59:39 +00:00
|
|
|
nr_ioapic_registers[apic] = reg_01.bits.entries+1;
|
|
|
|
}
|
2009-08-29 16:09:57 +00:00
|
|
|
|
|
|
|
if (!nr_legacy_irqs)
|
|
|
|
return;
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
for(apic = 0; apic < nr_ioapics; apic++) {
|
2005-10-30 22:59:39 +00:00
|
|
|
int pin;
|
|
|
|
/* See if any of the pins is in ExtINT mode */
|
2006-01-11 21:46:06 +00:00
|
|
|
for (pin = 0; pin < nr_ioapic_registers[apic]; pin++) {
|
2005-10-30 22:59:39 +00:00
|
|
|
struct IO_APIC_route_entry entry;
|
2006-09-26 08:52:30 +00:00
|
|
|
entry = ioapic_read_entry(apic, pin);
|
2005-10-30 22:59:39 +00:00
|
|
|
|
|
|
|
/* If the interrupt line is enabled and in ExtInt mode
|
|
|
|
* I have found the pin where the i8259 is connected.
|
|
|
|
*/
|
|
|
|
if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) {
|
|
|
|
ioapic_i8259.apic = apic;
|
|
|
|
ioapic_i8259.pin = pin;
|
|
|
|
goto found_i8259;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
found_i8259:
|
|
|
|
/* Look to see what if the MP table has reported the ExtINT */
|
|
|
|
/* If we could not find the appropriate pin by looking at the ioapic
|
|
|
|
* the i8259 probably is not connected the ioapic but give the
|
|
|
|
* mptable a chance anyway.
|
|
|
|
*/
|
|
|
|
i8259_pin = find_isa_irq_pin(0, mp_ExtINT);
|
|
|
|
i8259_apic = find_isa_irq_apic(0, mp_ExtINT);
|
|
|
|
/* Trust the MP table if nothing is setup in the hardware */
|
|
|
|
if ((ioapic_i8259.pin == -1) && (i8259_pin >= 0)) {
|
|
|
|
printk(KERN_WARNING "ExtINT not setup in hardware but reported by MP table\n");
|
|
|
|
ioapic_i8259.pin = i8259_pin;
|
|
|
|
ioapic_i8259.apic = i8259_apic;
|
|
|
|
}
|
|
|
|
/* Complain if the MP table and the hardware disagree */
|
|
|
|
if (((ioapic_i8259.apic != i8259_apic) || (ioapic_i8259.pin != i8259_pin)) &&
|
|
|
|
(i8259_pin >= 0) && (ioapic_i8259.pin >= 0))
|
|
|
|
{
|
|
|
|
printk(KERN_WARNING "ExtINT in hardware and MP table differ\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do not trust the IO-APIC being empty at bootup
|
|
|
|
*/
|
|
|
|
clear_IO_APIC();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not an __init, needed by the reboot code
|
|
|
|
*/
|
|
|
|
void disable_IO_APIC(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Clear the IO-APIC before rebooting:
|
|
|
|
*/
|
|
|
|
clear_IO_APIC();
|
|
|
|
|
2009-08-29 16:09:57 +00:00
|
|
|
if (!nr_legacy_irqs)
|
|
|
|
return;
|
|
|
|
|
2005-06-25 21:57:44 +00:00
|
|
|
/*
|
2005-09-09 10:59:04 +00:00
|
|
|
* If the i8259 is routed through an IOAPIC
|
2005-06-25 21:57:44 +00:00
|
|
|
* Put that IOAPIC in virtual wire mode
|
2005-09-09 10:59:04 +00:00
|
|
|
* so legacy interrupts can be delivered.
|
2009-03-17 00:04:59 +00:00
|
|
|
*
|
|
|
|
* With interrupt-remapping, for now we will use virtual wire A mode,
|
|
|
|
* as virtual wire B is little complex (need to configure both
|
|
|
|
* IOAPIC RTE aswell as interrupt-remapping table entry).
|
|
|
|
* As this gets called during crash dump, keep this simple for now.
|
2005-06-25 21:57:44 +00:00
|
|
|
*/
|
2009-03-17 00:04:59 +00:00
|
|
|
if (ioapic_i8259.pin != -1 && !intr_remapping_enabled) {
|
2005-06-25 21:57:44 +00:00
|
|
|
struct IO_APIC_route_entry entry;
|
|
|
|
|
|
|
|
memset(&entry, 0, sizeof(entry));
|
|
|
|
entry.mask = 0; /* Enabled */
|
|
|
|
entry.trigger = 0; /* Edge */
|
|
|
|
entry.irr = 0;
|
|
|
|
entry.polarity = 0; /* High */
|
|
|
|
entry.delivery_status = 0;
|
|
|
|
entry.dest_mode = 0; /* Physical */
|
2005-10-30 22:59:39 +00:00
|
|
|
entry.delivery_mode = dest_ExtINT; /* ExtInt */
|
2005-06-25 21:57:44 +00:00
|
|
|
entry.vector = 0;
|
2008-08-20 07:07:45 +00:00
|
|
|
entry.dest = read_apic_id();
|
2005-06-25 21:57:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add it to the IO-APIC irq-routing table:
|
|
|
|
*/
|
2006-09-26 08:52:30 +00:00
|
|
|
ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry);
|
2005-06-25 21:57:44 +00:00
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-03-17 00:04:59 +00:00
|
|
|
/*
|
|
|
|
* Use virtual wire A mode when interrupt remapping is enabled.
|
|
|
|
*/
|
2009-09-15 07:12:30 +00:00
|
|
|
if (cpu_has_apic || apic_from_smp_config())
|
2009-06-17 18:13:22 +00:00
|
|
|
disconnect_bsp_APIC(!intr_remapping_enabled &&
|
|
|
|
ioapic_i8259.pin != -1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* function to set the IO-APIC physical IDs based on the
|
|
|
|
* values stored in the MPC table.
|
|
|
|
*
|
|
|
|
* by Matt Domsch <Matt_Domsch@dell.com> Tue Dec 21 12:25:05 CST 1999
|
|
|
|
*/
|
|
|
|
|
2009-08-20 07:27:29 +00:00
|
|
|
void __init setup_ioapic_ids_from_mpc(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
union IO_APIC_reg_00 reg_00;
|
|
|
|
physid_mask_t phys_id_present_map;
|
2009-01-27 23:14:11 +00:00
|
|
|
int apic_id;
|
2005-04-16 22:20:36 +00:00
|
|
|
int i;
|
|
|
|
unsigned char old_id;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-08-20 07:27:29 +00:00
|
|
|
if (acpi_ioapic)
|
2008-06-09 01:31:54 +00:00
|
|
|
return;
|
2005-06-23 07:08:22 +00:00
|
|
|
/*
|
|
|
|
* Don't check I/O APIC IDs for xAPIC systems. They have
|
|
|
|
* no meaning without the serial APIC bus.
|
|
|
|
*/
|
2006-03-23 10:59:53 +00:00
|
|
|
if (!(boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
|
|
|
|
|| APIC_XAPIC(apic_version[boot_cpu_physical_apicid]))
|
2005-06-23 07:08:22 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* This is broken; anything with a real cpu count has to
|
|
|
|
* circumvent this idiocy regardless.
|
|
|
|
*/
|
2009-11-09 22:06:59 +00:00
|
|
|
apic->ioapic_phys_id_map(&phys_cpu_present_map, &phys_id_present_map);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the IOAPIC ID to the value stored in the MPC table.
|
|
|
|
*/
|
2009-01-27 23:14:11 +00:00
|
|
|
for (apic_id = 0; apic_id < nr_ioapics; apic_id++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Read the register 0 value */
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2009-01-27 23:14:11 +00:00
|
|
|
reg_00.raw = io_apic_read(apic_id, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
2008-06-08 11:07:18 +00:00
|
|
|
|
2009-01-27 23:14:11 +00:00
|
|
|
old_id = mp_ioapics[apic_id].apicid;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-27 23:14:11 +00:00
|
|
|
if (mp_ioapics[apic_id].apicid >= get_physical_broadcast()) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_ERR "BIOS bug, IO-APIC#%d ID is %d in the MPC table!...\n",
|
2009-01-27 23:14:11 +00:00
|
|
|
apic_id, mp_ioapics[apic_id].apicid);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
|
|
|
|
reg_00.bits.ID);
|
2009-01-27 23:14:11 +00:00
|
|
|
mp_ioapics[apic_id].apicid = reg_00.bits.ID;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Sanity check, is the ID really free? Every APIC in a
|
|
|
|
* system must have a unique ID or we get lots of nice
|
|
|
|
* 'stuck on smp_invalidate_needed IPI wait' messages.
|
|
|
|
*/
|
2009-11-09 22:06:59 +00:00
|
|
|
if (apic->check_apicid_used(&phys_id_present_map,
|
2009-01-27 23:14:11 +00:00
|
|
|
mp_ioapics[apic_id].apicid)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
printk(KERN_ERR "BIOS bug, IO-APIC#%d ID %d is already used!...\n",
|
2009-01-27 23:14:11 +00:00
|
|
|
apic_id, mp_ioapics[apic_id].apicid);
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < get_physical_broadcast(); i++)
|
|
|
|
if (!physid_isset(i, phys_id_present_map))
|
|
|
|
break;
|
|
|
|
if (i >= get_physical_broadcast())
|
|
|
|
panic("Max APIC ID exceeded!\n");
|
|
|
|
printk(KERN_ERR "... fixing up to %d. (tell your hw vendor)\n",
|
|
|
|
i);
|
|
|
|
physid_set(i, phys_id_present_map);
|
2009-01-27 23:14:11 +00:00
|
|
|
mp_ioapics[apic_id].apicid = i;
|
2005-04-16 22:20:36 +00:00
|
|
|
} else {
|
|
|
|
physid_mask_t tmp;
|
2009-11-09 22:06:59 +00:00
|
|
|
apic->apicid_to_cpu_present(mp_ioapics[apic_id].apicid, &tmp);
|
2005-04-16 22:20:36 +00:00
|
|
|
apic_printk(APIC_VERBOSE, "Setting %d in the "
|
|
|
|
"phys_id_present_map\n",
|
2009-01-27 23:14:11 +00:00
|
|
|
mp_ioapics[apic_id].apicid);
|
2005-04-16 22:20:36 +00:00
|
|
|
physids_or(phys_id_present_map, phys_id_present_map, tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to adjust the IRQ routing table
|
|
|
|
* if the ID changed.
|
|
|
|
*/
|
2009-01-27 23:14:11 +00:00
|
|
|
if (old_id != mp_ioapics[apic_id].apicid)
|
2005-04-16 22:20:36 +00:00
|
|
|
for (i = 0; i < mp_irq_entries; i++)
|
2009-01-12 12:17:22 +00:00
|
|
|
if (mp_irqs[i].dstapic == old_id)
|
|
|
|
mp_irqs[i].dstapic
|
2009-01-27 23:14:11 +00:00
|
|
|
= mp_ioapics[apic_id].apicid;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Read the right value from the MPC table and
|
|
|
|
* write it into the ID register.
|
2008-06-08 11:07:18 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
apic_printk(APIC_VERBOSE, KERN_INFO
|
|
|
|
"...changing IO-APIC physical APIC ID to %d ...",
|
2009-01-27 23:14:11 +00:00
|
|
|
mp_ioapics[apic_id].apicid);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-27 23:14:11 +00:00
|
|
|
reg_00.bits.ID = mp_ioapics[apic_id].apicid;
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2009-01-27 23:14:11 +00:00
|
|
|
io_apic_write(apic_id, 0, reg_00.raw);
|
2008-08-21 19:56:32 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Sanity check
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2009-01-27 23:14:11 +00:00
|
|
|
reg_00.raw = io_apic_read(apic_id, 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
2009-01-27 23:14:11 +00:00
|
|
|
if (reg_00.bits.ID != mp_ioapics[apic_id].apicid)
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("could not set ID!\n");
|
|
|
|
else
|
|
|
|
apic_printk(APIC_VERBOSE, " ok.\n");
|
|
|
|
}
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-02-13 12:26:21 +00:00
|
|
|
int no_timer_check __initdata;
|
2006-12-07 01:14:09 +00:00
|
|
|
|
|
|
|
static int __init notimercheck(char *s)
|
|
|
|
{
|
|
|
|
no_timer_check = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
__setup("no_timer_check", notimercheck);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* There is a nasty bug in some older SMP boards, their mptable lies
|
|
|
|
* about the timer IRQ. We do the following to work around the situation:
|
|
|
|
*
|
|
|
|
* - timer IRQ defaults to IO-APIC IRQ
|
|
|
|
* - if this function detects that timer IRQs are defunct, then we fall
|
|
|
|
* back to ISA timer IRQs
|
|
|
|
*/
|
2007-07-21 15:10:29 +00:00
|
|
|
static int __init timer_irq_works(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned long t1 = jiffies;
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-07 01:14:09 +00:00
|
|
|
if (no_timer_check)
|
|
|
|
return 1;
|
|
|
|
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
local_save_flags(flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
local_irq_enable();
|
|
|
|
/* Let ten ticks pass... */
|
|
|
|
mdelay((10 * 1000) / HZ);
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
local_irq_restore(flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Expect a few ticks at least, to be sure some possible
|
|
|
|
* glue logic does not lock up after one or two first
|
|
|
|
* ticks in a non-ExtINT mode. Also the local APIC
|
|
|
|
* might have cached one ExtINT interrupt. Finally, at
|
|
|
|
* least one tick may be lost due to delays.
|
|
|
|
*/
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
/* jiffies wrap? */
|
2008-01-30 12:32:19 +00:00
|
|
|
if (time_after(jiffies, t1 + 4))
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the SMP+IOAPIC case it might happen that there are an unspecified
|
|
|
|
* number of pending IRQ events unhandled. These cases are very rare,
|
|
|
|
* so we 'resend' these IRQs via IPIs, to the same CPU. It's much
|
|
|
|
* better to do it this way as thus we do not have to be aware of
|
|
|
|
* 'pending' interrupts in the IRQ path, except at this point.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* Edge triggered needs to resend any interrupt
|
|
|
|
* that was delayed but this is now handled in the device
|
|
|
|
* independent code.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Starting up a edge-triggered IO-APIC interrupt is
|
|
|
|
* nasty - we need to make sure that we get the edge.
|
|
|
|
* If it is already asserted for some reason, we need
|
|
|
|
* return 1 to indicate that is was pending.
|
|
|
|
*
|
|
|
|
* This is not complete - we should be able to fake
|
|
|
|
* an edge even if it isn't on the 8259A...
|
|
|
|
*/
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2006-10-04 09:16:26 +00:00
|
|
|
static unsigned int startup_ioapic_irq(unsigned int irq)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int was_pending = 0;
|
|
|
|
unsigned long flags;
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_cfg *cfg;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2009-08-29 16:09:57 +00:00
|
|
|
if (irq < nr_legacy_irqs) {
|
2005-04-16 22:20:36 +00:00
|
|
|
disable_8259A_irq(irq);
|
|
|
|
if (i8259A_irq_pending(irq))
|
|
|
|
was_pending = 1;
|
|
|
|
}
|
2008-12-06 02:58:31 +00:00
|
|
|
cfg = irq_cfg(irq);
|
2008-12-06 02:58:34 +00:00
|
|
|
__unmask_IO_APIC_irq(cfg);
|
2005-04-16 22:20:36 +00:00
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
|
|
|
|
return was_pending;
|
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:47 +00:00
|
|
|
static int ioapic_retrigger_irq(unsigned int irq)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
struct irq_cfg *cfg = irq_cfg(irq);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
2009-01-28 14:42:24 +00:00
|
|
|
apic->send_IPI_mask(cpumask_of(cpumask_first(cfg->domain)), cfg->vector);
|
2008-08-20 07:07:45 +00:00
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
2006-06-29 09:24:44 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
/*
|
|
|
|
* Level and edge triggered IO-APIC interrupts need different handling,
|
|
|
|
* so we use two separate IRQ descriptors. Edge triggered IRQs can be
|
|
|
|
* handled with the level-triggered descriptor, but that one has slightly
|
|
|
|
* more overhead. Level-triggered interrupts cannot be handled with the
|
|
|
|
* edge-triggered handler, without risking IRQ storms and other ugly
|
|
|
|
* races.
|
|
|
|
*/
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2009-10-13 20:32:36 +00:00
|
|
|
void send_cleanup_vector(struct irq_cfg *cfg)
|
2009-04-08 21:07:25 +00:00
|
|
|
{
|
|
|
|
cpumask_var_t cleanup_mask;
|
|
|
|
|
|
|
|
if (unlikely(!alloc_cpumask_var(&cleanup_mask, GFP_ATOMIC))) {
|
|
|
|
unsigned int i;
|
|
|
|
for_each_cpu_and(i, cfg->old_domain, cpu_online_mask)
|
|
|
|
apic->send_IPI_mask(cpumask_of(i), IRQ_MOVE_CLEANUP_VECTOR);
|
|
|
|
} else {
|
|
|
|
cpumask_and(cleanup_mask, cfg->old_domain, cpu_online_mask);
|
|
|
|
apic->send_IPI_mask(cleanup_mask, IRQ_MOVE_CLEANUP_VECTOR);
|
|
|
|
free_cpumask_var(cleanup_mask);
|
|
|
|
}
|
|
|
|
cfg->move_in_progress = 0;
|
|
|
|
}
|
|
|
|
|
2009-05-01 17:02:50 +00:00
|
|
|
static void __target_IO_APIC_irq(unsigned int irq, unsigned int dest, struct irq_cfg *cfg)
|
2009-04-08 21:07:25 +00:00
|
|
|
{
|
|
|
|
int apic, pin;
|
|
|
|
struct irq_pin_list *entry;
|
|
|
|
u8 vector = cfg->vector;
|
|
|
|
|
2009-08-01 07:47:59 +00:00
|
|
|
for_each_irq_pin(entry, cfg->irq_2_pin) {
|
2009-04-08 21:07:25 +00:00
|
|
|
unsigned int reg;
|
|
|
|
|
|
|
|
apic = entry->apic;
|
|
|
|
pin = entry->pin;
|
|
|
|
/*
|
|
|
|
* With interrupt-remapping, destination information comes
|
|
|
|
* from interrupt-remapping table entry.
|
|
|
|
*/
|
|
|
|
if (!irq_remapped(irq))
|
|
|
|
io_apic_write(apic, 0x11 + pin*2, dest);
|
|
|
|
reg = io_apic_read(apic, 0x10 + pin*2);
|
|
|
|
reg &= ~IO_APIC_REDIR_VECTOR_MASK;
|
|
|
|
reg |= vector;
|
|
|
|
io_apic_modify(apic, 0x10 + pin*2, reg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Either sets desc->affinity to a valid value, and returns
|
2009-12-18 02:29:46 +00:00
|
|
|
* ->cpu_mask_to_apicid of that in dest_id, or returns -1 and
|
2009-04-08 21:07:25 +00:00
|
|
|
* leaves desc->affinity untouched.
|
|
|
|
*/
|
2009-10-13 20:32:36 +00:00
|
|
|
unsigned int
|
2009-12-18 02:29:46 +00:00
|
|
|
set_desc_affinity(struct irq_desc *desc, const struct cpumask *mask,
|
|
|
|
unsigned int *dest_id)
|
2009-04-08 21:07:25 +00:00
|
|
|
{
|
|
|
|
struct irq_cfg *cfg;
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
if (!cpumask_intersects(mask, cpu_online_mask))
|
2009-12-18 02:29:46 +00:00
|
|
|
return -1;
|
2009-04-08 21:07:25 +00:00
|
|
|
|
|
|
|
irq = desc->irq;
|
|
|
|
cfg = desc->chip_data;
|
|
|
|
if (assign_irq_vector(irq, cfg, mask))
|
2009-12-18 02:29:46 +00:00
|
|
|
return -1;
|
2009-04-08 21:07:25 +00:00
|
|
|
|
|
|
|
cpumask_copy(desc->affinity, mask);
|
|
|
|
|
2009-12-18 02:29:46 +00:00
|
|
|
*dest_id = apic->cpu_mask_to_apicid_and(desc->affinity, cfg->domain);
|
|
|
|
return 0;
|
2009-04-08 21:07:25 +00:00
|
|
|
}
|
|
|
|
|
2009-05-01 17:02:50 +00:00
|
|
|
static int
|
2009-04-08 21:07:25 +00:00
|
|
|
set_ioapic_affinity_irq_desc(struct irq_desc *desc, const struct cpumask *mask)
|
|
|
|
{
|
|
|
|
struct irq_cfg *cfg;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int dest;
|
|
|
|
unsigned int irq;
|
2009-05-01 17:02:50 +00:00
|
|
|
int ret = -1;
|
2009-04-08 21:07:25 +00:00
|
|
|
|
|
|
|
irq = desc->irq;
|
|
|
|
cfg = desc->chip_data;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
2009-12-18 02:29:46 +00:00
|
|
|
ret = set_desc_affinity(desc, mask, &dest);
|
|
|
|
if (!ret) {
|
2009-04-08 21:07:25 +00:00
|
|
|
/* Only the high 8 bits are valid. */
|
|
|
|
dest = SET_APIC_LOGICAL_ID(dest);
|
|
|
|
__target_IO_APIC_irq(irq, dest, cfg);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
2009-05-01 17:02:50 +00:00
|
|
|
|
|
|
|
return ret;
|
2009-04-08 21:07:25 +00:00
|
|
|
}
|
|
|
|
|
2009-05-01 17:02:50 +00:00
|
|
|
static int
|
2009-04-08 21:07:25 +00:00
|
|
|
set_ioapic_affinity_irq(unsigned int irq, const struct cpumask *mask)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
|
|
|
|
desc = irq_to_desc(irq);
|
|
|
|
|
2009-05-01 17:02:50 +00:00
|
|
|
return set_ioapic_affinity_irq_desc(desc, mask);
|
2009-04-08 21:07:25 +00:00
|
|
|
}
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_INTR_REMAP
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
/*
|
|
|
|
* Migrate the IO-APIC irq in the presence of intr-remapping.
|
|
|
|
*
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
* For both level and edge triggered, irq migration is a simple atomic
|
|
|
|
* update(of vector and cpu destination) of IRTE and flush the hardware cache.
|
2008-08-20 07:07:45 +00:00
|
|
|
*
|
x86, x2apic: cleanup the IO-APIC level migration with interrupt-remapping
Impact: simplification
In the current code, for level triggered migration, we need to modify the
io-apic RTE with the update vector information, along with modifying interrupt
remapping table entry(IRTE) with vector and destination. This is to ensure that
remote IRR bit inthe IOAPIC RTE gets cleared when the cpu does EOI.
With this patch, for level triggered, we eliminate the io-apic RTE modification
(with the updated vector information), by using a virtual vector (io-apic pin
number). Real vector that is used for interrupting cpu will be coming from
the interrupt-remapping table entry. Trigger mode in the IRTE will always be
edge, and the actual level or edge trigger will be setup in the IO-APIC RTE.
So a level triggered interrupt will appear as an edge to the local apic
cpu but still as level to the IO-APIC.
With this change, level irq migration can be done by simply modifying
the interrupt-remapping table entry with out changing the io-apic RTE.
And as the interrupt appears as edge at the cpu, in addition to do the
local apic EOI, we need to do IO-APIC directed EOI to clear the remote
IRR bit in the IO-APIC RTE.
This simplies the irq migration in the presence of interrupt-remapping.
Idea-by: Rajesh Sankaran <rajesh.sankaran@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2009-03-17 00:05:01 +00:00
|
|
|
* For level triggered, we eliminate the io-apic RTE modification (with the
|
|
|
|
* updated vector information), by using a virtual vector (io-apic pin number).
|
|
|
|
* Real vector that is used for interrupting cpu will be coming from
|
|
|
|
* the interrupt-remapping table entry.
|
2008-08-20 07:07:45 +00:00
|
|
|
*/
|
2009-04-28 00:59:21 +00:00
|
|
|
static int
|
2008-12-17 01:33:52 +00:00
|
|
|
migrate_ioapic_irq_desc(struct irq_desc *desc, const struct cpumask *mask)
|
2008-08-20 03:50:28 +00:00
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
struct irq_cfg *cfg;
|
|
|
|
struct irte irte;
|
|
|
|
unsigned int dest;
|
2008-12-06 02:58:34 +00:00
|
|
|
unsigned int irq;
|
2009-04-28 00:59:21 +00:00
|
|
|
int ret = -1;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-12-17 01:33:56 +00:00
|
|
|
if (!cpumask_intersects(mask, cpu_online_mask))
|
2009-04-28 00:59:21 +00:00
|
|
|
return ret;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
irq = desc->irq;
|
2008-08-20 07:07:45 +00:00
|
|
|
if (get_irte(irq, &irte))
|
2009-04-28 00:59:21 +00:00
|
|
|
return ret;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
|
|
|
if (assign_irq_vector(irq, cfg, mask))
|
2009-04-28 00:59:21 +00:00
|
|
|
return ret;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-01-28 14:20:18 +00:00
|
|
|
dest = apic->cpu_mask_to_apicid_and(cfg->domain, mask);
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
irte.vector = cfg->vector;
|
|
|
|
irte.dest_id = IRTE_DEST(dest);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Modified the IRTE and flushes the Interrupt entry cache.
|
|
|
|
*/
|
|
|
|
modify_irte(irq, &irte);
|
|
|
|
|
2008-12-17 01:33:56 +00:00
|
|
|
if (cfg->move_in_progress)
|
|
|
|
send_cleanup_vector(cfg);
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-01-11 05:58:08 +00:00
|
|
|
cpumask_copy(desc->affinity, mask);
|
2009-04-28 00:59:21 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Migrates the IRQ destination in the process context.
|
|
|
|
*/
|
2009-04-28 00:59:21 +00:00
|
|
|
static int set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc,
|
2008-12-13 11:25:51 +00:00
|
|
|
const struct cpumask *mask)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
2009-04-28 00:59:21 +00:00
|
|
|
return migrate_ioapic_irq_desc(desc, mask);
|
2008-12-06 02:58:34 +00:00
|
|
|
}
|
2009-04-28 00:59:21 +00:00
|
|
|
static int set_ir_ioapic_affinity_irq(unsigned int irq,
|
2008-12-13 11:25:51 +00:00
|
|
|
const struct cpumask *mask)
|
2008-12-06 02:58:34 +00:00
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
2009-04-28 00:59:21 +00:00
|
|
|
return set_ir_ioapic_affinity_irq_desc(desc, mask);
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2009-03-17 00:05:02 +00:00
|
|
|
#else
|
2009-04-28 00:59:21 +00:00
|
|
|
static inline int set_ir_ioapic_affinity_irq_desc(struct irq_desc *desc,
|
2009-03-17 00:05:02 +00:00
|
|
|
const struct cpumask *mask)
|
|
|
|
{
|
2009-04-28 00:59:21 +00:00
|
|
|
return 0;
|
2009-03-17 00:05:02 +00:00
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
asmlinkage void smp_irq_move_cleanup_interrupt(void)
|
|
|
|
{
|
|
|
|
unsigned vector, me;
|
2008-12-09 03:19:07 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
ack_APIC_irq();
|
|
|
|
exit_idle();
|
|
|
|
irq_enter();
|
|
|
|
|
|
|
|
me = smp_processor_id();
|
|
|
|
for (vector = FIRST_EXTERNAL_VECTOR; vector < NR_VECTORS; vector++) {
|
|
|
|
unsigned int irq;
|
2009-03-17 00:05:04 +00:00
|
|
|
unsigned int irr;
|
2008-08-20 07:07:45 +00:00
|
|
|
struct irq_desc *desc;
|
|
|
|
struct irq_cfg *cfg;
|
|
|
|
irq = __get_cpu_var(vector_irq)[vector];
|
|
|
|
|
2008-12-06 02:58:31 +00:00
|
|
|
if (irq == -1)
|
|
|
|
continue;
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
desc = irq_to_desc(irq);
|
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cfg = irq_cfg(irq);
|
2009-11-17 15:46:45 +00:00
|
|
|
raw_spin_lock(&desc->lock);
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2010-01-06 18:56:31 +00:00
|
|
|
/*
|
|
|
|
* Check if the irq migration is in progress. If so, we
|
|
|
|
* haven't received the cleanup request yet for this irq.
|
|
|
|
*/
|
|
|
|
if (cfg->move_in_progress)
|
|
|
|
goto unlock;
|
|
|
|
|
2008-12-17 01:33:56 +00:00
|
|
|
if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
|
2008-08-20 07:07:45 +00:00
|
|
|
goto unlock;
|
|
|
|
|
2009-03-17 00:05:04 +00:00
|
|
|
irr = apic_read(APIC_IRR + (vector / 32 * 0x10));
|
|
|
|
/*
|
|
|
|
* Check if the vector that needs to be cleanedup is
|
|
|
|
* registered at the cpu's IRR. If so, then this is not
|
|
|
|
* the best time to clean it up. Lets clean it up in the
|
|
|
|
* next attempt by sending another IRQ_MOVE_CLEANUP_VECTOR
|
|
|
|
* to myself.
|
|
|
|
*/
|
|
|
|
if (irr & (1 << (vector % 32))) {
|
|
|
|
apic->send_IPI_self(IRQ_MOVE_CLEANUP_VECTOR);
|
|
|
|
goto unlock;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
__get_cpu_var(vector_irq)[vector] = -1;
|
|
|
|
unlock:
|
2009-11-17 15:46:45 +00:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
irq_exit();
|
|
|
|
}
|
|
|
|
|
2009-10-26 22:24:34 +00:00
|
|
|
static void __irq_complete_move(struct irq_desc **descp, unsigned vector)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = *descp;
|
|
|
|
struct irq_cfg *cfg = desc->chip_data;
|
2009-10-26 22:24:34 +00:00
|
|
|
unsigned me;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-04-28 00:58:23 +00:00
|
|
|
if (likely(!cfg->move_in_progress))
|
2008-08-20 07:07:45 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
me = smp_processor_id();
|
2009-01-31 22:50:07 +00:00
|
|
|
|
2009-04-28 00:58:23 +00:00
|
|
|
if (vector == cfg->vector && cpumask_test_cpu(me, cfg->domain))
|
2008-12-17 01:33:56 +00:00
|
|
|
send_cleanup_vector(cfg);
|
2008-08-20 03:50:28 +00:00
|
|
|
}
|
2009-10-26 22:24:34 +00:00
|
|
|
|
|
|
|
static void irq_complete_move(struct irq_desc **descp)
|
|
|
|
{
|
|
|
|
__irq_complete_move(descp, ~get_irq_regs()->orig_ax);
|
|
|
|
}
|
|
|
|
|
|
|
|
void irq_force_complete_move(int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
struct irq_cfg *cfg = desc->chip_data;
|
|
|
|
|
|
|
|
__irq_complete_move(&desc, cfg->vector);
|
|
|
|
}
|
2008-08-20 03:50:28 +00:00
|
|
|
#else
|
2008-12-06 02:58:34 +00:00
|
|
|
static inline void irq_complete_move(struct irq_desc **descp) {}
|
2008-08-20 03:50:28 +00:00
|
|
|
#endif
|
2008-12-06 02:58:34 +00:00
|
|
|
|
2008-08-20 03:50:34 +00:00
|
|
|
static void ack_apic_edge(unsigned int irq)
|
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
irq_complete_move(&desc);
|
2008-08-20 03:50:34 +00:00
|
|
|
move_native_irq(irq);
|
|
|
|
ack_APIC_irq();
|
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:48 +00:00
|
|
|
atomic_t irq_mis_count;
|
|
|
|
|
2009-12-01 23:31:16 +00:00
|
|
|
/*
|
|
|
|
* IO-APIC versions below 0x20 don't support EOI register.
|
|
|
|
* For the record, here is the information about various versions:
|
|
|
|
* 0Xh 82489DX
|
|
|
|
* 1Xh I/OAPIC or I/O(x)APIC which are not PCI 2.2 Compliant
|
|
|
|
* 2Xh I/O(x)APIC which is PCI 2.2 Compliant
|
|
|
|
* 30h-FFh Reserved
|
|
|
|
*
|
|
|
|
* Some of the Intel ICH Specs (ICH2 to ICH5) documents the io-apic
|
|
|
|
* version as 0x2. This is an error with documentation and these ICH chips
|
|
|
|
* use io-apic's of version 0x20.
|
|
|
|
*
|
|
|
|
* For IO-APIC's with EOI register, we use that to do an explicit EOI.
|
|
|
|
* Otherwise, we simulate the EOI message manually by changing the trigger
|
|
|
|
* mode to edge and then back to level, with RTE being masked during this.
|
|
|
|
*/
|
2009-10-26 22:24:35 +00:00
|
|
|
static void __eoi_ioapic_irq(unsigned int irq, struct irq_cfg *cfg)
|
|
|
|
{
|
|
|
|
struct irq_pin_list *entry;
|
|
|
|
|
|
|
|
for_each_irq_pin(entry, cfg->irq_2_pin) {
|
2009-12-01 23:31:16 +00:00
|
|
|
if (mp_ioapics[entry->apic].apicver >= 0x20) {
|
|
|
|
/*
|
|
|
|
* Intr-remapping uses pin number as the virtual vector
|
|
|
|
* in the RTE. Actual vector is programmed in
|
|
|
|
* intr-remapping table entry. Hence for the io-apic
|
|
|
|
* EOI we use the pin number.
|
|
|
|
*/
|
|
|
|
if (irq_remapped(irq))
|
|
|
|
io_apic_eoi(entry->apic, entry->pin);
|
|
|
|
else
|
|
|
|
io_apic_eoi(entry->apic, cfg->vector);
|
|
|
|
} else {
|
|
|
|
__mask_and_edge_IO_APIC_irq(entry);
|
|
|
|
__unmask_and_level_IO_APIC_irq(entry);
|
|
|
|
}
|
2009-10-26 22:24:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void eoi_ioapic_irq(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_cfg *cfg;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
irq = desc->irq;
|
|
|
|
cfg = desc->chip_data;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
__eoi_ioapic_irq(irq, cfg);
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:41 +00:00
|
|
|
static void ack_apic_level(unsigned int irq)
|
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-08-20 03:50:48 +00:00
|
|
|
unsigned long v;
|
|
|
|
int i;
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_cfg *cfg;
|
2008-08-20 07:07:45 +00:00
|
|
|
int do_unmask_irq = 0;
|
2008-08-20 03:50:41 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
irq_complete_move(&desc);
|
2008-08-20 03:50:41 +00:00
|
|
|
#ifdef CONFIG_GENERIC_PENDING_IRQ
|
2008-08-20 07:07:45 +00:00
|
|
|
/* If we are moving the irq we need to mask it */
|
2008-12-06 02:58:34 +00:00
|
|
|
if (unlikely(desc->status & IRQ_MOVE_PENDING)) {
|
2008-08-20 07:07:45 +00:00
|
|
|
do_unmask_irq = 1;
|
2008-12-06 02:58:34 +00:00
|
|
|
mask_IO_APIC_irq_desc(desc);
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2008-08-20 03:50:41 +00:00
|
|
|
#endif
|
|
|
|
|
2008-08-20 03:50:48 +00:00
|
|
|
/*
|
2009-06-08 10:00:22 +00:00
|
|
|
* It appears there is an erratum which affects at least version 0x11
|
|
|
|
* of I/O APIC (that's the 82093AA and cores integrated into various
|
|
|
|
* chipsets). Under certain conditions a level-triggered interrupt is
|
|
|
|
* erroneously delivered as edge-triggered one but the respective IRR
|
|
|
|
* bit gets set nevertheless. As a result the I/O unit expects an EOI
|
|
|
|
* message but it will never arrive and further interrupts are blocked
|
|
|
|
* from the source. The exact reason is so far unknown, but the
|
|
|
|
* phenomenon was observed when two consecutive interrupt requests
|
|
|
|
* from a given source get delivered to the same CPU and the source is
|
|
|
|
* temporarily disabled in between.
|
|
|
|
*
|
|
|
|
* A workaround is to simulate an EOI message manually. We achieve it
|
|
|
|
* by setting the trigger mode to edge and then to level when the edge
|
|
|
|
* trigger mode gets detected in the TMR of a local APIC for a
|
|
|
|
* level-triggered interrupt. We mask the source for the time of the
|
|
|
|
* operation to prevent an edge-triggered interrupt escaping meanwhile.
|
|
|
|
* The idea is from Manfred Spraul. --macro
|
2009-12-01 23:31:17 +00:00
|
|
|
*
|
|
|
|
* Also in the case when cpu goes offline, fixup_irqs() will forward
|
|
|
|
* any unhandled interrupt on the offlined cpu to the new cpu
|
|
|
|
* destination that is handling the corresponding interrupt. This
|
|
|
|
* interrupt forwarding is done via IPI's. Hence, in this case also
|
|
|
|
* level-triggered io-apic interrupt will be seen as an edge
|
|
|
|
* interrupt in the IRR. And we can't rely on the cpu's EOI
|
|
|
|
* to be broadcasted to the IO-APIC's which will clear the remoteIRR
|
|
|
|
* corresponding to the level-triggered interrupt. Hence on IO-APIC's
|
|
|
|
* supporting EOI register, we do an explicit EOI to clear the
|
|
|
|
* remote IRR and on IO-APIC's which don't have an EOI register,
|
|
|
|
* we use the above logic (mask+edge followed by unmask+level) from
|
|
|
|
* Manfred Spraul to clear the remote IRR.
|
2009-06-08 10:00:22 +00:00
|
|
|
*/
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
|
|
|
i = cfg->vector;
|
2008-08-20 03:50:48 +00:00
|
|
|
v = apic_read(APIC_TMR + ((i & ~0x1f) >> 1));
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
/*
|
|
|
|
* We must acknowledge the irq before we move it or the acknowledge will
|
|
|
|
* not propagate properly.
|
|
|
|
*/
|
|
|
|
ack_APIC_irq();
|
|
|
|
|
2009-12-01 23:31:17 +00:00
|
|
|
/*
|
|
|
|
* Tail end of clearing remote IRR bit (either by delivering the EOI
|
|
|
|
* message via io-apic EOI register write or simulating it using
|
|
|
|
* mask+edge followed by unnask+level logic) manually when the
|
|
|
|
* level triggered interrupt is seen as the edge triggered interrupt
|
|
|
|
* at the cpu.
|
|
|
|
*/
|
2009-12-01 23:31:15 +00:00
|
|
|
if (!(v & (1 << (i & 0x1f)))) {
|
|
|
|
atomic_inc(&irq_mis_count);
|
|
|
|
|
2009-12-01 23:31:16 +00:00
|
|
|
eoi_ioapic_irq(desc);
|
2009-12-01 23:31:15 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
/* Now we can move and renable the irq */
|
|
|
|
if (unlikely(do_unmask_irq)) {
|
|
|
|
/* Only migrate the irq if the ack has been received.
|
|
|
|
*
|
|
|
|
* On rare occasions the broadcast level triggered ack gets
|
|
|
|
* delayed going to ioapics, and if we reprogram the
|
|
|
|
* vector while Remote IRR is still set the irq will never
|
|
|
|
* fire again.
|
|
|
|
*
|
|
|
|
* To prevent this scenario we read the Remote IRR bit
|
|
|
|
* of the ioapic. This has two effects.
|
|
|
|
* - On any sane system the read of the ioapic will
|
|
|
|
* flush writes (and acks) going to the ioapic from
|
|
|
|
* this cpu.
|
|
|
|
* - We get to see if the ACK has actually been delivered.
|
|
|
|
*
|
|
|
|
* Based on failed experiments of reprogramming the
|
|
|
|
* ioapic entry from outside of irq context starting
|
|
|
|
* with masking the ioapic entry and then polling until
|
|
|
|
* Remote IRR was clear before reprogramming the
|
|
|
|
* ioapic I don't trust the Remote IRR bit to be
|
|
|
|
* completey accurate.
|
|
|
|
*
|
|
|
|
* However there appears to be no other way to plug
|
|
|
|
* this race, so if the Remote IRR bit is not
|
|
|
|
* accurate and is causing problems then it is a hardware bug
|
|
|
|
* and you can go talk to the chipset vendor about it.
|
|
|
|
*/
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
|
|
|
if (!io_apic_level_ack_pending(cfg))
|
2008-08-20 07:07:45 +00:00
|
|
|
move_masked_irq(irq);
|
2008-12-06 02:58:34 +00:00
|
|
|
unmask_IO_APIC_irq_desc(desc);
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2008-08-20 03:50:48 +00:00
|
|
|
}
|
2008-08-20 03:50:34 +00:00
|
|
|
|
2009-04-03 09:15:50 +00:00
|
|
|
#ifdef CONFIG_INTR_REMAP
|
|
|
|
static void ir_ack_apic_edge(unsigned int irq)
|
|
|
|
{
|
2009-04-17 08:42:13 +00:00
|
|
|
ack_APIC_irq();
|
2009-04-03 09:15:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ir_ack_apic_level(unsigned int irq)
|
|
|
|
{
|
2009-04-17 08:42:13 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
ack_APIC_irq();
|
|
|
|
eoi_ioapic_irq(desc);
|
2009-04-03 09:15:50 +00:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_INTR_REMAP */
|
|
|
|
|
2006-10-04 09:16:26 +00:00
|
|
|
static struct irq_chip ioapic_chip __read_mostly = {
|
2008-10-15 13:27:23 +00:00
|
|
|
.name = "IO-APIC",
|
|
|
|
.startup = startup_ioapic_irq,
|
|
|
|
.mask = mask_IO_APIC_irq,
|
|
|
|
.unmask = unmask_IO_APIC_irq,
|
|
|
|
.ack = ack_apic_edge,
|
|
|
|
.eoi = ack_apic_level,
|
[PATCH] x86/x86_64: deferred handling of writes to /proc/irqxx/smp_affinity
When handling writes to /proc/irq, current code is re-programming rte
entries directly. This is not recommended and could potentially cause
chipset's to lockup, or cause missing interrupts.
CONFIG_IRQ_BALANCE does this correctly, where it re-programs only when the
interrupt is pending. The same needs to be done for /proc/irq handling as well.
Otherwise user space irq balancers are really not doing the right thing.
- Changed pending_irq_balance_cpumask to pending_irq_migrate_cpumask for
lack of a generic name.
- added move_irq out of IRQ_BALANCE, and added this same to X86_64
- Added new proc handler for write, so we can do deferred write at irq
handling time.
- Display of /proc/irq/XX/smp_affinity used to display CPU_MASKALL, instead
it now shows only active cpu masks, or exactly what was set.
- Provided a common move_irq implementation, instead of duplicating
when using generic irq framework.
Tested on i386/x86_64 and ia64 with CONFIG_PCI_MSI turned on and off.
Tested UP builds as well.
MSI testing: tbd: I have cards, need to look for a x-over cable, although I
did test an earlier version of this patch. Will test in a couple days.
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Acked-by: Zwane Mwaikambo <zwane@holomorphy.com>
Grudgingly-acked-by: Andi Kleen <ak@muc.de>
Signed-off-by: Coywolf Qi Hunt <coywolf@lovecn.org>
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-06 22:16:15 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2008-10-15 13:27:23 +00:00
|
|
|
.set_affinity = set_ioapic_affinity_irq,
|
[PATCH] x86/x86_64: deferred handling of writes to /proc/irqxx/smp_affinity
When handling writes to /proc/irq, current code is re-programming rte
entries directly. This is not recommended and could potentially cause
chipset's to lockup, or cause missing interrupts.
CONFIG_IRQ_BALANCE does this correctly, where it re-programs only when the
interrupt is pending. The same needs to be done for /proc/irq handling as well.
Otherwise user space irq balancers are really not doing the right thing.
- Changed pending_irq_balance_cpumask to pending_irq_migrate_cpumask for
lack of a generic name.
- added move_irq out of IRQ_BALANCE, and added this same to X86_64
- Added new proc handler for write, so we can do deferred write at irq
handling time.
- Display of /proc/irq/XX/smp_affinity used to display CPU_MASKALL, instead
it now shows only active cpu masks, or exactly what was set.
- Provided a common move_irq implementation, instead of duplicating
when using generic irq framework.
Tested on i386/x86_64 and ia64 with CONFIG_PCI_MSI turned on and off.
Tested UP builds as well.
MSI testing: tbd: I have cards, need to look for a x-over cable, although I
did test an earlier version of this patch. Will test in a couple days.
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Acked-by: Zwane Mwaikambo <zwane@holomorphy.com>
Grudgingly-acked-by: Andi Kleen <ak@muc.de>
Signed-off-by: Coywolf Qi Hunt <coywolf@lovecn.org>
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-06 22:16:15 +00:00
|
|
|
#endif
|
2006-10-04 09:16:47 +00:00
|
|
|
.retrigger = ioapic_retrigger_irq,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
static struct irq_chip ir_ioapic_chip __read_mostly = {
|
2008-10-15 13:27:23 +00:00
|
|
|
.name = "IR-IO-APIC",
|
|
|
|
.startup = startup_ioapic_irq,
|
|
|
|
.mask = mask_IO_APIC_irq,
|
|
|
|
.unmask = unmask_IO_APIC_irq,
|
2009-03-22 20:41:25 +00:00
|
|
|
#ifdef CONFIG_INTR_REMAP
|
2009-04-03 09:15:50 +00:00
|
|
|
.ack = ir_ack_apic_edge,
|
|
|
|
.eoi = ir_ack_apic_level,
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2008-10-15 13:27:23 +00:00
|
|
|
.set_affinity = set_ir_ioapic_affinity_irq,
|
2009-03-22 20:41:25 +00:00
|
|
|
#endif
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
|
|
|
.retrigger = ioapic_retrigger_irq,
|
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static inline void init_IO_APIC_traps(void)
|
|
|
|
{
|
|
|
|
int irq;
|
2008-08-20 03:50:05 +00:00
|
|
|
struct irq_desc *desc;
|
2008-08-20 03:50:25 +00:00
|
|
|
struct irq_cfg *cfg;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* NOTE! The local APIC isn't very good at handling
|
|
|
|
* multiple interrupts at the same interrupt level.
|
|
|
|
* As the interrupt level is determined by taking the
|
|
|
|
* vector number and shifting that right by 4, we
|
|
|
|
* want to spread these out a bit so that they don't
|
|
|
|
* all fall in the same interrupt level.
|
|
|
|
*
|
|
|
|
* Also, we've got to be careful not to trash gate
|
|
|
|
* 0x80, because int 0x80 is hm, kind of importantish. ;)
|
|
|
|
*/
|
2008-12-06 02:58:31 +00:00
|
|
|
for_each_irq_desc(irq, desc) {
|
|
|
|
cfg = desc->chip_data;
|
|
|
|
if (IO_APIC_IRQ(irq) && cfg && !cfg->vector) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Hmm.. We don't have an entry for this,
|
|
|
|
* so default to an old-fashioned 8259
|
|
|
|
* interrupt if we can..
|
|
|
|
*/
|
2009-08-29 16:09:57 +00:00
|
|
|
if (irq < nr_legacy_irqs)
|
2005-04-16 22:20:36 +00:00
|
|
|
make_8259A_irq(irq);
|
2008-12-06 02:58:31 +00:00
|
|
|
else
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Strange. Oh, well.. */
|
2008-08-20 03:50:05 +00:00
|
|
|
desc->chip = &no_irq_chip;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:26 +00:00
|
|
|
/*
|
|
|
|
* The local APIC irq-chip implementation:
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-08 11:07:18 +00:00
|
|
|
static void mask_lapic_irq(unsigned int irq)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
unsigned long v;
|
|
|
|
|
|
|
|
v = apic_read(APIC_LVT0);
|
x86: APIC: remove apic_write_around(); use alternatives
Use alternatives to select the workaround for the 11AP Pentium erratum
for the affected steppings on the fly rather than build time. Remove the
X86_GOOD_APIC configuration option and replace all the calls to
apic_write_around() with plain apic_write(), protecting accesses to the
ESR as appropriate due to the 3AP Pentium erratum. Remove
apic_read_around() and all its invocations altogether as not needed.
Remove apic_write_atomic() and all its implementing backends. The use of
ASM_OUTPUT2() is not strictly needed for input constraints, but I have
used it for readability's sake.
I had the feeling no one else was brave enough to do it, so I went ahead
and here it is. Verified by checking the generated assembly and tested
with both a 32-bit and a 64-bit configuration, also with the 11AP
"feature" forced on and verified with gdb on /proc/kcore to work as
expected (as an 11AP machines are quite hard to get hands on these days).
Some script complained about the use of "volatile", but apic_write() needs
it for the same reason and is effectively a replacement for writel(), so I
have disregarded it.
I am not sure what the policy wrt defconfig files is, they are generated
and there is risk of a conflict resulting from an unrelated change, so I
have left changes to them out. The option will get removed from them at
the next run.
Some testing with machines other than mine will be needed to avoid some
stupid mistake, but despite its volume, the change is not really that
intrusive, so I am fairly confident that because it works for me, it will
everywhere.
Signed-off-by: Maciej W. Rozycki <macro@linux-mips.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-16 18:15:30 +00:00
|
|
|
apic_write(APIC_LVT0, v | APIC_LVT_MASKED);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-06-08 11:07:18 +00:00
|
|
|
static void unmask_lapic_irq(unsigned int irq)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-10-04 09:16:26 +00:00
|
|
|
unsigned long v;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-04 09:16:26 +00:00
|
|
|
v = apic_read(APIC_LVT0);
|
x86: APIC: remove apic_write_around(); use alternatives
Use alternatives to select the workaround for the 11AP Pentium erratum
for the affected steppings on the fly rather than build time. Remove the
X86_GOOD_APIC configuration option and replace all the calls to
apic_write_around() with plain apic_write(), protecting accesses to the
ESR as appropriate due to the 3AP Pentium erratum. Remove
apic_read_around() and all its invocations altogether as not needed.
Remove apic_write_atomic() and all its implementing backends. The use of
ASM_OUTPUT2() is not strictly needed for input constraints, but I have
used it for readability's sake.
I had the feeling no one else was brave enough to do it, so I went ahead
and here it is. Verified by checking the generated assembly and tested
with both a 32-bit and a 64-bit configuration, also with the 11AP
"feature" forced on and verified with gdb on /proc/kcore to work as
expected (as an 11AP machines are quite hard to get hands on these days).
Some script complained about the use of "volatile", but apic_write() needs
it for the same reason and is effectively a replacement for writel(), so I
have disregarded it.
I am not sure what the policy wrt defconfig files is, they are generated
and there is risk of a conflict resulting from an unrelated change, so I
have left changes to them out. The option will get removed from them at
the next run.
Some testing with machines other than mine will be needed to avoid some
stupid mistake, but despite its volume, the change is not really that
intrusive, so I am fairly confident that because it works for me, it will
everywhere.
Signed-off-by: Maciej W. Rozycki <macro@linux-mips.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-16 18:15:30 +00:00
|
|
|
apic_write(APIC_LVT0, v & ~APIC_LVT_MASKED);
|
2006-10-04 09:16:26 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void ack_lapic_irq(unsigned int irq)
|
2008-08-20 03:50:34 +00:00
|
|
|
{
|
|
|
|
ack_APIC_irq();
|
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:26 +00:00
|
|
|
static struct irq_chip lapic_chip __read_mostly = {
|
2008-05-27 20:19:09 +00:00
|
|
|
.name = "local-APIC",
|
2006-10-04 09:16:26 +00:00
|
|
|
.mask = mask_lapic_irq,
|
|
|
|
.unmask = unmask_lapic_irq,
|
2008-07-11 18:35:17 +00:00
|
|
|
.ack = ack_lapic_irq,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static void lapic_register_intr(int irq, struct irq_desc *desc)
|
2008-07-11 18:35:17 +00:00
|
|
|
{
|
2008-08-20 03:50:05 +00:00
|
|
|
desc->status &= ~IRQ_LEVEL;
|
2008-07-11 18:35:17 +00:00
|
|
|
set_irq_chip_and_handler_name(irq, &lapic_chip, handle_edge_irq,
|
|
|
|
"edge");
|
|
|
|
}
|
|
|
|
|
2008-01-30 12:31:24 +00:00
|
|
|
static void __init setup_nmi(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
/*
|
2008-06-08 11:07:18 +00:00
|
|
|
* Dirty trick to enable the NMI watchdog ...
|
2005-04-16 22:20:36 +00:00
|
|
|
* We put the 8259A master into AEOI mode and
|
|
|
|
* unmask on all local APICs LVT0 as NMI.
|
|
|
|
*
|
|
|
|
* The idea to use the 8259A in AEOI mode ('8259A Virtual Wire')
|
|
|
|
* is from Maciej W. Rozycki - so we do not have to EOI from
|
|
|
|
* the NMI handler or the timer interrupt.
|
2008-06-08 11:07:18 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
apic_printk(APIC_VERBOSE, KERN_INFO "activating NMI Watchdog ...");
|
|
|
|
|
2008-01-30 12:31:24 +00:00
|
|
|
enable_NMI_through_LVT0();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
apic_printk(APIC_VERBOSE, " done.\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This looks a bit hackish but it's about the only one way of sending
|
|
|
|
* a few INTA cycles to 8259As and any associated glue logic. ICR does
|
|
|
|
* not support the ExtINT mode, unfortunately. We need to send these
|
|
|
|
* cycles as some i82489DX-based boards have glue logic that keeps the
|
|
|
|
* 8259A interrupt line asserted until INTA. --macro
|
|
|
|
*/
|
2008-04-12 15:41:12 +00:00
|
|
|
static inline void __init unlock_ExtINT_logic(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-10-30 22:59:39 +00:00
|
|
|
int apic, pin, i;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct IO_APIC_route_entry entry0, entry1;
|
|
|
|
unsigned char save_control, save_freq_select;
|
|
|
|
|
2005-10-30 22:59:39 +00:00
|
|
|
pin = find_isa_irq_pin(8, mp_INT);
|
2006-12-07 01:14:11 +00:00
|
|
|
if (pin == -1) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return;
|
|
|
|
}
|
2005-10-30 22:59:39 +00:00
|
|
|
apic = find_isa_irq_apic(8, mp_INT);
|
2006-12-07 01:14:11 +00:00
|
|
|
if (apic == -1) {
|
|
|
|
WARN_ON_ONCE(1);
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
2006-12-07 01:14:11 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
entry0 = ioapic_read_entry(apic, pin);
|
2005-10-30 22:59:39 +00:00
|
|
|
clear_IO_APIC_pin(apic, pin);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
memset(&entry1, 0, sizeof(entry1));
|
|
|
|
|
|
|
|
entry1.dest_mode = 0; /* physical delivery */
|
|
|
|
entry1.mask = 0; /* unmask IRQ now */
|
2008-08-20 03:50:33 +00:00
|
|
|
entry1.dest = hard_smp_processor_id();
|
2005-04-16 22:20:36 +00:00
|
|
|
entry1.delivery_mode = dest_ExtINT;
|
|
|
|
entry1.polarity = entry0.polarity;
|
|
|
|
entry1.trigger = 0;
|
|
|
|
entry1.vector = 0;
|
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
ioapic_write_entry(apic, pin, entry1);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
save_control = CMOS_READ(RTC_CONTROL);
|
|
|
|
save_freq_select = CMOS_READ(RTC_FREQ_SELECT);
|
|
|
|
CMOS_WRITE((save_freq_select & ~RTC_RATE_SELECT) | 0x6,
|
|
|
|
RTC_FREQ_SELECT);
|
|
|
|
CMOS_WRITE(save_control | RTC_PIE, RTC_CONTROL);
|
|
|
|
|
|
|
|
i = 100;
|
|
|
|
while (i-- > 0) {
|
|
|
|
mdelay(10);
|
|
|
|
if ((CMOS_READ(RTC_INTR_FLAGS) & RTC_PF) == RTC_PF)
|
|
|
|
i -= 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
CMOS_WRITE(save_control, RTC_CONTROL);
|
|
|
|
CMOS_WRITE(save_freq_select, RTC_FREQ_SELECT);
|
2005-10-30 22:59:39 +00:00
|
|
|
clear_IO_APIC_pin(apic, pin);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-26 08:52:30 +00:00
|
|
|
ioapic_write_entry(apic, pin, entry0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:36 +00:00
|
|
|
static int disable_timer_pin_1 __initdata;
|
2008-08-20 03:50:41 +00:00
|
|
|
/* Actually the next is obsolete, but keep it for paranoid reasons -AK */
|
2008-08-20 07:07:45 +00:00
|
|
|
static int __init disable_timer_pin_setup(char *arg)
|
2008-08-20 03:50:36 +00:00
|
|
|
{
|
|
|
|
disable_timer_pin_1 = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
early_param("disable_timer_pin_1", disable_timer_pin_setup);
|
2008-08-20 03:50:36 +00:00
|
|
|
|
|
|
|
int timer_through_8259 __initdata;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* This code may look a bit paranoid, but it's supposed to cooperate with
|
|
|
|
* a wide range of boards and BIOS bugs. Fortunately only the timer IRQ
|
|
|
|
* is so screwy. Thanks to Brian Perkins for testing/hacking this beast
|
|
|
|
* fanatically on his truly buggy board.
|
2008-08-20 07:07:45 +00:00
|
|
|
*
|
|
|
|
* FIXME: really need to revamp this for all platforms.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-12-07 01:14:09 +00:00
|
|
|
static inline void __init check_timer(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(0);
|
|
|
|
struct irq_cfg *cfg = desc->chip_data;
|
2009-04-28 01:00:38 +00:00
|
|
|
int node = cpu_to_node(boot_cpu_id);
|
2005-10-30 22:59:39 +00:00
|
|
|
int apic1, pin1, apic2, pin2;
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
unsigned long flags;
|
2008-08-20 03:50:41 +00:00
|
|
|
int no_pin1 = 0;
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
|
|
|
|
local_irq_save(flags);
|
2007-11-26 19:42:19 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* get/set the timer IRQ vector:
|
|
|
|
*/
|
|
|
|
disable_8259A_irq(0);
|
2009-01-28 03:32:51 +00:00
|
|
|
assign_irq_vector(0, cfg, apic->target_cpus());
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2008-05-21 21:09:11 +00:00
|
|
|
* As IRQ0 is to be enabled in the 8259A, the virtual
|
|
|
|
* wire has to be disabled in the local APIC. Also
|
|
|
|
* timer interrupts need to be acknowledged manually in
|
|
|
|
* the 8259A for the i82489DX when using the NMI
|
|
|
|
* watchdog as that APIC treats NMIs as level-triggered.
|
|
|
|
* The AEOI mode will finish them in the 8259A
|
|
|
|
* automatically.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
x86: APIC: remove apic_write_around(); use alternatives
Use alternatives to select the workaround for the 11AP Pentium erratum
for the affected steppings on the fly rather than build time. Remove the
X86_GOOD_APIC configuration option and replace all the calls to
apic_write_around() with plain apic_write(), protecting accesses to the
ESR as appropriate due to the 3AP Pentium erratum. Remove
apic_read_around() and all its invocations altogether as not needed.
Remove apic_write_atomic() and all its implementing backends. The use of
ASM_OUTPUT2() is not strictly needed for input constraints, but I have
used it for readability's sake.
I had the feeling no one else was brave enough to do it, so I went ahead
and here it is. Verified by checking the generated assembly and tested
with both a 32-bit and a 64-bit configuration, also with the 11AP
"feature" forced on and verified with gdb on /proc/kcore to work as
expected (as an 11AP machines are quite hard to get hands on these days).
Some script complained about the use of "volatile", but apic_write() needs
it for the same reason and is effectively a replacement for writel(), so I
have disregarded it.
I am not sure what the policy wrt defconfig files is, they are generated
and there is risk of a conflict resulting from an unrelated change, so I
have left changes to them out. The option will get removed from them at
the next run.
Some testing with machines other than mine will be needed to avoid some
stupid mistake, but despite its volume, the change is not really that
intrusive, so I am fairly confident that because it works for me, it will
everywhere.
Signed-off-by: Maciej W. Rozycki <macro@linux-mips.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-16 18:15:30 +00:00
|
|
|
apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_EXTINT);
|
2005-04-16 22:20:36 +00:00
|
|
|
init_8259A(1);
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2009-02-09 00:18:03 +00:00
|
|
|
{
|
|
|
|
unsigned int ver;
|
|
|
|
|
|
|
|
ver = apic_read(APIC_LVR);
|
|
|
|
ver = GET_APIC_VERSION(ver);
|
|
|
|
timer_ack = (nmi_watchdog == NMI_IO_APIC && !APIC_INTEGRATED(ver));
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-10-30 22:59:39 +00:00
|
|
|
pin1 = find_isa_irq_pin(0, mp_INT);
|
|
|
|
apic1 = find_isa_irq_apic(0, mp_INT);
|
|
|
|
pin2 = ioapic_i8259.pin;
|
|
|
|
apic2 = ioapic_i8259.apic;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "..TIMER: vector=0x%02X "
|
|
|
|
"apic1=%d pin1=%d apic2=%d pin2=%d\n",
|
2008-08-20 03:50:28 +00:00
|
|
|
cfg->vector, apic1, pin1, apic2, pin2);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-05-27 20:19:51 +00:00
|
|
|
/*
|
|
|
|
* Some BIOS writers are clueless and report the ExtINTA
|
|
|
|
* I/O APIC input from the cascaded 8259A as the timer
|
|
|
|
* interrupt input. So just in case, if only one pin
|
|
|
|
* was found above, try it both directly and through the
|
|
|
|
* 8259A.
|
|
|
|
*/
|
|
|
|
if (pin1 == -1) {
|
2008-08-20 07:07:45 +00:00
|
|
|
if (intr_remapping_enabled)
|
|
|
|
panic("BIOS bug: timer not connected to IO-APIC");
|
2008-05-27 20:19:51 +00:00
|
|
|
pin1 = pin2;
|
|
|
|
apic1 = apic2;
|
|
|
|
no_pin1 = 1;
|
|
|
|
} else if (pin2 == -1) {
|
|
|
|
pin2 = pin1;
|
|
|
|
apic2 = apic1;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (pin1 != -1) {
|
|
|
|
/*
|
|
|
|
* Ok, does IRQ0 through the IOAPIC work?
|
|
|
|
*/
|
2008-05-27 20:19:51 +00:00
|
|
|
if (no_pin1) {
|
2009-04-28 01:00:38 +00:00
|
|
|
add_pin_to_irq_node(cfg, node, apic1, pin1);
|
2008-08-20 03:50:28 +00:00
|
|
|
setup_timer_IRQ0_pin(apic1, pin1, cfg->vector);
|
2009-02-09 00:18:03 +00:00
|
|
|
} else {
|
|
|
|
/* for edge trigger, setup_IO_APIC_irq already
|
|
|
|
* leave it unmasked.
|
|
|
|
* so only need to unmask if it is level-trigger
|
|
|
|
* do we really have level trigger timer?
|
|
|
|
*/
|
|
|
|
int idx;
|
|
|
|
idx = find_irq_entry(apic1, pin1, mp_INT);
|
|
|
|
if (idx != -1 && irq_trigger(idx))
|
|
|
|
unmask_IO_APIC_irq_desc(desc);
|
2008-05-27 20:19:51 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
if (timer_irq_works()) {
|
|
|
|
if (nmi_watchdog == NMI_IO_APIC) {
|
|
|
|
setup_nmi();
|
|
|
|
enable_8259A_irq(0);
|
|
|
|
}
|
2005-09-12 16:49:25 +00:00
|
|
|
if (disable_timer_pin_1 > 0)
|
|
|
|
clear_IO_APIC_pin(0, pin1);
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
if (intr_remapping_enabled)
|
|
|
|
panic("timer doesn't work through Interrupt-remapped IO-APIC");
|
2009-02-09 00:18:03 +00:00
|
|
|
local_irq_disable();
|
2005-10-30 22:59:39 +00:00
|
|
|
clear_IO_APIC_pin(apic1, pin1);
|
2008-05-27 20:19:51 +00:00
|
|
|
if (!no_pin1)
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_ERR "..MP-BIOS bug: "
|
|
|
|
"8254 timer not connected to IO-APIC\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "...trying to set up timer "
|
|
|
|
"(IRQ0) through the 8259A ...\n");
|
|
|
|
apic_printk(APIC_QUIET, KERN_INFO
|
|
|
|
"..... (found apic %d pin %d) ...\n", apic2, pin2);
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* legacy devices should be connected to IO APIC #0
|
|
|
|
*/
|
2009-04-28 01:00:38 +00:00
|
|
|
replace_pin_at_irq_node(cfg, node, apic1, pin1, apic2, pin2);
|
2008-08-20 03:50:28 +00:00
|
|
|
setup_timer_IRQ0_pin(apic2, pin2, cfg->vector);
|
2008-05-21 21:09:19 +00:00
|
|
|
enable_8259A_irq(0);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (timer_irq_works()) {
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "....... works.\n");
|
2008-05-21 21:10:22 +00:00
|
|
|
timer_through_8259 = 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
if (nmi_watchdog == NMI_IO_APIC) {
|
2008-05-21 21:09:34 +00:00
|
|
|
disable_8259A_irq(0);
|
2005-04-16 22:20:36 +00:00
|
|
|
setup_nmi();
|
2008-05-21 21:09:34 +00:00
|
|
|
enable_8259A_irq(0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Cleanup, just in case ...
|
|
|
|
*/
|
2009-02-09 00:18:03 +00:00
|
|
|
local_irq_disable();
|
2008-05-21 21:09:19 +00:00
|
|
|
disable_8259A_irq(0);
|
2005-10-30 22:59:39 +00:00
|
|
|
clear_IO_APIC_pin(apic2, pin2);
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "....... failed.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nmi_watchdog == NMI_IO_APIC) {
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_WARNING "timer doesn't work "
|
|
|
|
"through the IO-APIC - disabling NMI Watchdog!\n");
|
2008-05-29 18:32:30 +00:00
|
|
|
nmi_watchdog = NMI_NONE;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-05-21 21:09:11 +00:00
|
|
|
timer_ack = 0;
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO
|
|
|
|
"...trying to set up timer as Virtual Wire IRQ...\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
lapic_register_intr(0, desc);
|
2008-08-20 03:50:28 +00:00
|
|
|
apic_write(APIC_LVT0, APIC_DM_FIXED | cfg->vector); /* Fixed mode */
|
2005-04-16 22:20:36 +00:00
|
|
|
enable_8259A_irq(0);
|
|
|
|
|
|
|
|
if (timer_irq_works()) {
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-02-09 00:18:03 +00:00
|
|
|
local_irq_disable();
|
2008-05-21 21:09:26 +00:00
|
|
|
disable_8259A_irq(0);
|
2008-08-20 03:50:28 +00:00
|
|
|
apic_write(APIC_LVT0, APIC_LVT_MASKED | APIC_DM_FIXED | cfg->vector);
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "..... failed.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO
|
|
|
|
"...trying to set up timer as ExtINT IRQ...\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
init_8259A(0);
|
|
|
|
make_8259A_irq(0);
|
x86: APIC: remove apic_write_around(); use alternatives
Use alternatives to select the workaround for the 11AP Pentium erratum
for the affected steppings on the fly rather than build time. Remove the
X86_GOOD_APIC configuration option and replace all the calls to
apic_write_around() with plain apic_write(), protecting accesses to the
ESR as appropriate due to the 3AP Pentium erratum. Remove
apic_read_around() and all its invocations altogether as not needed.
Remove apic_write_atomic() and all its implementing backends. The use of
ASM_OUTPUT2() is not strictly needed for input constraints, but I have
used it for readability's sake.
I had the feeling no one else was brave enough to do it, so I went ahead
and here it is. Verified by checking the generated assembly and tested
with both a 32-bit and a 64-bit configuration, also with the 11AP
"feature" forced on and verified with gdb on /proc/kcore to work as
expected (as an 11AP machines are quite hard to get hands on these days).
Some script complained about the use of "volatile", but apic_write() needs
it for the same reason and is effectively a replacement for writel(), so I
have disregarded it.
I am not sure what the policy wrt defconfig files is, they are generated
and there is risk of a conflict resulting from an unrelated change, so I
have left changes to them out. The option will get removed from them at
the next run.
Some testing with machines other than mine will be needed to avoid some
stupid mistake, but despite its volume, the change is not really that
intrusive, so I am fairly confident that because it works for me, it will
everywhere.
Signed-off-by: Maciej W. Rozycki <macro@linux-mips.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-16 18:15:30 +00:00
|
|
|
apic_write(APIC_LVT0, APIC_DM_EXTINT);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
unlock_ExtINT_logic();
|
|
|
|
|
|
|
|
if (timer_irq_works()) {
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "..... works.\n");
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-02-09 00:18:03 +00:00
|
|
|
local_irq_disable();
|
2008-07-14 18:08:13 +00:00
|
|
|
apic_printk(APIC_QUIET, KERN_INFO "..... failed :(.\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
panic("IO-APIC + timer doesn't work! Boot with apic=debug and send a "
|
2008-07-14 18:08:13 +00:00
|
|
|
"report. Then try booting with the 'noapic' option.\n");
|
x86: fix "Kernel panic - not syncing: IO-APIC + timer doesn't work!"
this is the tale of a full day spent debugging an ancient but elusive bug.
after booting up thousands of random .config kernels, i finally happened
to generate a .config that produced the following rare bootup failure
on 32-bit x86:
| ..TIMER: vector=0x31 apic1=0 pin1=2 apic2=-1 pin2=-1
| ..MP-BIOS bug: 8254 timer not connected to IO-APIC
| ...trying to set up timer (IRQ0) through the 8259A ... failed.
| ...trying to set up timer as Virtual Wire IRQ... failed.
| ...trying to set up timer as ExtINT IRQ... failed :(.
| Kernel panic - not syncing: IO-APIC + timer doesn't work! Boot with apic=debug
| and send a report. Then try booting with the 'noapic' option
this bug has been reported many times during the years, but it was never
reproduced nor fixed.
the bug that i hit was extremely sensitive to .config details.
First i did a .config-bisection - suspecting some .config detail.
That led to CONFIG_X86_MCE: enabling X86_MCE magically made the bug disappear
and the system would boot up just fine.
Debugging my way through the MCE code ended up identifying two unlikely
candidates: the thing that made a real difference to the hang was that
X86_MCE did two printks:
Intel machine check architecture supported.
Intel machine check reporting enabled on CPU#1.
Adding the same printks to a !CONFIG_X86_MCE kernel made the bug go away!
this left timing as the main suspect: i experimented with adding various
udelay()s to the arch/x86/kernel/io_apic_32.c:check_timer() function, and
the race window turned out to be narrower than 30 microseconds (!).
That made debugging especially funny, debugging without having printk
ability before the bug hits is ... interesting ;-)
eventually i started suspecting IRQ activities - those are pretty much the
only thing that happen this early during bootup and have the timescale of
a few dozen microseconds. Also, check_timer() changes the IRQ hardware
in various creative ways, so the main candidate became IRQ0 interaction.
i've added a counter to track timer irqs (on which core they arrived, at
what exact time, etc.) and found that no timer IRQ would arrive after the
bug condition hits - even if we re-enable IRQ0 and re-initialize the i8259A,
but that we'd get a small number of timer irqs right around the time when we
call the check_timer() function.
Eventually i got the following backtrace triggered from debug code in the
timer interrupt:
...trying to set up timer as Virtual Wire IRQ... failed.
...trying to set up timer as ExtINT IRQ...
Pid: 1, comm: swapper Not tainted (2.6.24-rc5 #57)
EIP: 0060:[<c044d57e>] EFLAGS: 00000246 CPU: 0
EIP is at _spin_unlock_irqrestore+0x5/0x1c
EAX: c0634178 EBX: 00000000 ECX: c4947d63 EDX: 00000246
ESI: 00000002 EDI: 00010031 EBP: c04e0f2e ESP: f7c41df4
DS: 007b ES: 007b FS: 00d8 GS: 0000 SS: 0068
CR0: 8005003b CR2: ffe04000 CR3: 00630000 CR4: 000006d0
DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000
DR6: ffff0ff0 DR7: 00000400
[<c05f5784>] setup_IO_APIC+0x9c3/0xc5c
the spin_unlock() was called from init_8259A(). Wait ... we have an IRQ0
entry while we are in the middle of setting up the local APIC, the i8259A
and the PIT??
That is certainly not how it's supposed to work! check_timer() was supposed
to be called with irqs turned off - but this eroded away sometime in the
past. This code would still work most of the time because this code runs
very quickly, but just the right timing conditions are present and IRQ0
hits in this small, ~30 usecs window, timer irqs stop and the system does
not boot up. Also, given how early this is during bootup, the hang is
very deterministic - but it would only occur on certain machines (and
certain configs).
The fix was quite simple: disable/restore interrupts properly in this
function. With that in place the test-system now boots up just fine.
(64-bit x86 io_apic_64.c had the same bug.)
Phew! One down, only 1500 other kernel bugs are left ;-)
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2007-12-18 17:05:58 +00:00
|
|
|
out:
|
|
|
|
local_irq_restore(flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
x86: I/O APIC: Never configure IRQ2
There is no such entity as ISA IRQ2. The ACPI spec does not make it
explicitly clear, but does not preclude it either -- all it says is ISA
legacy interrupts are identity mapped by default (subject to overrides),
but it does not state whether IRQ2 exists or not. As a result if there is
no IRQ0 override, then IRQ2 is normally initialised as an ISA interrupt,
which implies an edge-triggered line, which is unmasked by default as this
is what we do for edge-triggered I/O APIC interrupts so as not to miss an
edge.
To the best of my knowledge it is useless, as IRQ2 has not been in use
since the PC/AT as back then it was taken by the 8259A cascade interrupt
to the slave, with the line position in the slot rerouted to newly-created
IRQ9. No device could thus make use of this line with the pair of 8259A
chips. Now in theory INTIN2 of the I/O APIC may be usable, but the
interrupt of the device wired to it would not be available in the PIC mode
at all, so I seriously doubt if anybody decided to reuse it for a regular
device.
However there are two common uses of INTIN2. One is for IRQ0, with an
ACPI interrupt override (or its equivalent in the MP table). But in this
case IRQ2 is gone entirely with INTIN0 left vacant. The other one is for
an 8959A ExtINTA cascade. In this case IRQ0 goes to INTIN0 and if ACPI is
used INTIN2 is assumed to be IRQ2 (there is no override and ACPI has no
way to report ExtINTA interrupts). This is where a problem happens.
The problem is INTIN2 is configured as a native APIC interrupt, with a
vector assigned and the mask cleared. And the line may indeed get active
and inject interrupts if the master 8959A has its timer interrupt enabled
(it might happen for other interrupts too, but they are normally masked in
the process of rerouting them to the I/O APIC). There are two cases where
it will happen:
* When the I/O APIC NMI watchdog is enabled. This is actually a misnomer
as the watchdog pulses are delivered through the 8259A to the LINT0
inputs of all the local APICs in the system. The implication is the
output of the master 8259A goes high and low repeatedly, signalling
interrupts to INTIN2 which is enabled too!
[The origin of the name is I think for a brief period during the
development we had a capability in our code to configure the watchdog to
use an I/O APIC input; that would be INTIN2 in this scenario.]
* When the native route of IRQ0 via INTIN0 fails for whatever reason -- as
it happens with the system considered here. In this scenario the timer
pulse is delivered through the 8259A to LINT0 input of the local APIC of
the bootstrap processor, quite similarly to how is done for the watchdog
described above. The result is, again, INTIN2 receives these pulses
too. Rafael's system used to escape this scenario, because an incorrect
IRQ0 override would occupy INTIN2 and prevent it from being unmasked.
My conclusion is IRQ2 should be excluded from configuration in all the
cases and the current exception for ACPI systems should be lifted. The
reason being the exception not only being useless, but harmful as well.
Signed-off-by: Maciej W. Rozycki <macro@linux-mips.org>
Cc: "Rafael J. Wysocki" <rjw@sisk.pl>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Andreas Herrmann <andreas.herrmann3@amd.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-07-11 18:35:23 +00:00
|
|
|
* Traditionally ISA IRQ2 is the cascade IRQ, and is not available
|
|
|
|
* to devices. However there may be an I/O APIC pin available for
|
|
|
|
* this interrupt regardless. The pin may be left unconnected, but
|
|
|
|
* typically it will be reused as an ExtINT cascade interrupt for
|
|
|
|
* the master 8259A. In the MPS case such a pin will normally be
|
|
|
|
* reported as an ExtINT interrupt in the MP table. With ACPI
|
|
|
|
* there is no provision for ExtINT interrupts, and in the absence
|
|
|
|
* of an override it would be treated as an ordinary ISA I/O APIC
|
|
|
|
* interrupt, that is edge-triggered and unmasked by default. We
|
|
|
|
* used to do this, but it caused problems on some systems because
|
|
|
|
* of the NMI watchdog and sometimes IRQ0 of the 8254 timer using
|
|
|
|
* the same ExtINT cascade interrupt to drive the local APIC of the
|
|
|
|
* bootstrap processor. Therefore we refrain from routing IRQ2 to
|
|
|
|
* the I/O APIC in all cases now. No actual device should request
|
|
|
|
* it anyway. --macro
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2009-08-29 16:09:57 +00:00
|
|
|
#define PIC_IRQS (1UL << PIC_CASCADE_IR)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
void __init setup_IO_APIC(void)
|
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* calling enable_IO_APIC() is moved to setup_local_APIC for BP
|
|
|
|
*/
|
2009-08-29 16:09:57 +00:00
|
|
|
io_apic_irqs = nr_legacy_irqs ? ~PIC_IRQS : ~0UL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
apic_printk(APIC_VERBOSE, "ENABLING IO-APIC IRQs\n");
|
2008-10-15 13:27:23 +00:00
|
|
|
/*
|
2008-08-20 07:07:45 +00:00
|
|
|
* Set up IO-APIC IRQ routing.
|
|
|
|
*/
|
2009-08-20 07:27:29 +00:00
|
|
|
x86_init.mpparse.setup_ioapic_ids();
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
sync_Arb_IDs();
|
|
|
|
setup_IO_APIC_irqs();
|
|
|
|
init_IO_APIC_traps();
|
2009-08-29 16:09:57 +00:00
|
|
|
if (nr_legacy_irqs)
|
|
|
|
check_timer();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-08-20 07:07:45 +00:00
|
|
|
* Called after all the initialization is done. If we didnt find any
|
|
|
|
* APIC bugs then we can allow the modify fast path
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2008-06-08 11:07:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __init io_apic_bug_finalize(void)
|
|
|
|
{
|
2008-10-15 13:27:23 +00:00
|
|
|
if (sis_apic_bug == -1)
|
|
|
|
sis_apic_bug = 0;
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(io_apic_bug_finalize);
|
|
|
|
|
|
|
|
struct sysfs_ioapic_data {
|
|
|
|
struct sys_device dev;
|
|
|
|
struct IO_APIC_route_entry entry[0];
|
|
|
|
};
|
2008-08-20 07:07:45 +00:00
|
|
|
static struct sysfs_ioapic_data * mp_ioapic_data[MAX_IO_APICS];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-04-16 22:25:24 +00:00
|
|
|
static int ioapic_suspend(struct sys_device *dev, pm_message_t state)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct IO_APIC_route_entry *entry;
|
|
|
|
struct sysfs_ioapic_data *data;
|
|
|
|
int i;
|
2008-06-08 11:07:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
data = container_of(dev, struct sysfs_ioapic_data, dev);
|
|
|
|
entry = data->entry;
|
2008-08-20 07:07:45 +00:00
|
|
|
for (i = 0; i < nr_ioapic_registers[dev->id]; i ++, entry ++ )
|
|
|
|
*entry = ioapic_read_entry(dev->id, i);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ioapic_resume(struct sys_device *dev)
|
|
|
|
{
|
|
|
|
struct IO_APIC_route_entry *entry;
|
|
|
|
struct sysfs_ioapic_data *data;
|
|
|
|
unsigned long flags;
|
|
|
|
union IO_APIC_reg_00 reg_00;
|
|
|
|
int i;
|
2008-06-08 11:07:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
data = container_of(dev, struct sysfs_ioapic_data, dev);
|
|
|
|
entry = data->entry;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
reg_00.raw = io_apic_read(dev->id, 0);
|
2009-01-12 12:16:17 +00:00
|
|
|
if (reg_00.bits.ID != mp_ioapics[dev->id].apicid) {
|
|
|
|
reg_00.bits.ID = mp_ioapics[dev->id].apicid;
|
2005-04-16 22:20:36 +00:00
|
|
|
io_apic_write(dev->id, 0, reg_00.raw);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
2008-06-08 11:07:18 +00:00
|
|
|
for (i = 0; i < nr_ioapic_registers[dev->id]; i++)
|
2006-09-26 08:52:30 +00:00
|
|
|
ioapic_write_entry(dev->id, i, entry[i]);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct sysdev_class ioapic_sysdev_class = {
|
2007-12-20 01:09:39 +00:00
|
|
|
.name = "ioapic",
|
2005-04-16 22:20:36 +00:00
|
|
|
.suspend = ioapic_suspend,
|
|
|
|
.resume = ioapic_resume,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init ioapic_init_sysfs(void)
|
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
struct sys_device * dev;
|
|
|
|
int i, size, error;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
error = sysdev_class_register(&ioapic_sysdev_class);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
for (i = 0; i < nr_ioapics; i++ ) {
|
2008-06-08 11:07:18 +00:00
|
|
|
size = sizeof(struct sys_device) + nr_ioapic_registers[i]
|
2005-04-16 22:20:36 +00:00
|
|
|
* sizeof(struct IO_APIC_route_entry);
|
2008-06-22 20:13:48 +00:00
|
|
|
mp_ioapic_data[i] = kzalloc(size, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (!mp_ioapic_data[i]) {
|
|
|
|
printk(KERN_ERR "Can't suspend/resume IOAPIC %d\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
dev = &mp_ioapic_data[i]->dev;
|
2008-06-08 11:07:18 +00:00
|
|
|
dev->id = i;
|
2005-04-16 22:20:36 +00:00
|
|
|
dev->cls = &ioapic_sysdev_class;
|
|
|
|
error = sysdev_register(dev);
|
|
|
|
if (error) {
|
|
|
|
kfree(mp_ioapic_data[i]);
|
|
|
|
mp_ioapic_data[i] = NULL;
|
|
|
|
printk(KERN_ERR "Can't suspend/resume IOAPIC %d\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
device_initcall(ioapic_init_sysfs);
|
|
|
|
|
2006-10-04 09:16:39 +00:00
|
|
|
/*
|
2006-10-04 09:17:01 +00:00
|
|
|
* Dynamic irq allocate and deallocation
|
2006-10-04 09:16:39 +00:00
|
|
|
*/
|
2009-04-28 01:02:23 +00:00
|
|
|
unsigned int create_irq_nr(unsigned int irq_want, int node)
|
2006-10-04 09:16:39 +00:00
|
|
|
{
|
2006-10-04 09:16:47 +00:00
|
|
|
/* Allocate an unused irq */
|
2008-08-20 07:07:45 +00:00
|
|
|
unsigned int irq;
|
|
|
|
unsigned int new;
|
2006-10-04 09:16:39 +00:00
|
|
|
unsigned long flags;
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_cfg *cfg_new = NULL;
|
|
|
|
struct irq_desc *desc_new = NULL;
|
2008-08-20 03:50:27 +00:00
|
|
|
|
|
|
|
irq = 0;
|
2009-02-09 00:18:03 +00:00
|
|
|
if (irq_want < nr_irqs_gsi)
|
|
|
|
irq_want = nr_irqs_gsi;
|
|
|
|
|
2006-10-04 09:16:47 +00:00
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
2009-01-11 06:24:06 +00:00
|
|
|
for (new = irq_want; new < nr_irqs; new++) {
|
2009-04-28 01:00:38 +00:00
|
|
|
desc_new = irq_to_desc_alloc_node(new, node);
|
2008-12-06 02:58:31 +00:00
|
|
|
if (!desc_new) {
|
|
|
|
printk(KERN_INFO "can not get irq_desc for %d\n", new);
|
2006-10-04 09:16:47 +00:00
|
|
|
continue;
|
2008-12-06 02:58:31 +00:00
|
|
|
}
|
|
|
|
cfg_new = desc_new->chip_data;
|
|
|
|
|
|
|
|
if (cfg_new->vector != 0)
|
2006-10-04 09:16:47 +00:00
|
|
|
continue;
|
2009-04-28 01:02:23 +00:00
|
|
|
|
2009-04-30 08:17:50 +00:00
|
|
|
desc_new = move_irq_desc(desc_new, node);
|
2009-11-21 08:23:37 +00:00
|
|
|
cfg_new = desc_new->chip_data;
|
2009-04-28 01:02:23 +00:00
|
|
|
|
2009-01-28 03:32:51 +00:00
|
|
|
if (__assign_irq_vector(new, cfg_new, apic->target_cpus()) == 0)
|
2006-10-04 09:16:47 +00:00
|
|
|
irq = new;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
2006-10-04 09:16:39 +00:00
|
|
|
|
2010-02-10 09:20:06 +00:00
|
|
|
if (irq > 0)
|
|
|
|
dynamic_irq_init_keep_chip_data(irq);
|
|
|
|
|
2006-10-04 09:16:39 +00:00
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:27 +00:00
|
|
|
int create_irq(void)
|
|
|
|
{
|
2009-04-28 01:02:23 +00:00
|
|
|
int node = cpu_to_node(boot_cpu_id);
|
2008-12-06 02:58:33 +00:00
|
|
|
unsigned int irq_want;
|
2008-08-20 07:07:45 +00:00
|
|
|
int irq;
|
|
|
|
|
2008-12-06 02:58:33 +00:00
|
|
|
irq_want = nr_irqs_gsi;
|
2009-04-28 01:02:23 +00:00
|
|
|
irq = create_irq_nr(irq_want, node);
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
if (irq == 0)
|
|
|
|
irq = -1;
|
|
|
|
|
|
|
|
return irq;
|
2008-08-20 03:50:27 +00:00
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:39 +00:00
|
|
|
void destroy_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2008-12-06 02:58:31 +00:00
|
|
|
struct irq_cfg *cfg;
|
2006-10-04 09:16:39 +00:00
|
|
|
|
2010-02-10 09:20:06 +00:00
|
|
|
dynamic_irq_cleanup_keep_chip_data(irq);
|
2006-10-04 09:16:39 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
free_irte(irq);
|
2006-10-04 09:16:39 +00:00
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
2010-02-10 09:20:06 +00:00
|
|
|
cfg = irq_to_desc(irq)->chip_data;
|
2008-12-06 02:58:34 +00:00
|
|
|
__clear_irq_vector(irq, cfg);
|
2006-10-04 09:16:39 +00:00
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:43 +00:00
|
|
|
/*
|
2007-10-19 23:13:56 +00:00
|
|
|
* MSI message composition
|
2006-10-04 09:16:43 +00:00
|
|
|
*/
|
|
|
|
#ifdef CONFIG_PCI_MSI
|
2009-08-04 19:07:09 +00:00
|
|
|
static int msi_compose_msg(struct pci_dev *pdev, unsigned int irq,
|
|
|
|
struct msi_msg *msg, u8 hpet_id)
|
2006-10-04 09:16:43 +00:00
|
|
|
{
|
2008-08-20 03:50:28 +00:00
|
|
|
struct irq_cfg *cfg;
|
|
|
|
int err;
|
2006-10-04 09:16:43 +00:00
|
|
|
unsigned dest;
|
|
|
|
|
2009-01-14 12:27:35 +00:00
|
|
|
if (disable_apic)
|
|
|
|
return -ENXIO;
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = irq_cfg(irq);
|
2009-01-28 03:32:51 +00:00
|
|
|
err = assign_irq_vector(irq, cfg, apic->target_cpus());
|
2008-08-20 03:50:28 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
2006-10-04 09:16:43 +00:00
|
|
|
|
2009-01-28 14:20:18 +00:00
|
|
|
dest = apic->cpu_mask_to_apicid_and(cfg->domain, apic->target_cpus());
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (irq_remapped(irq)) {
|
|
|
|
struct irte irte;
|
|
|
|
int ir_index;
|
|
|
|
u16 sub_handle;
|
|
|
|
|
|
|
|
ir_index = map_irq_to_irte_handle(irq, &sub_handle);
|
|
|
|
BUG_ON(ir_index == -1);
|
|
|
|
|
|
|
|
memset (&irte, 0, sizeof(irte));
|
|
|
|
|
|
|
|
irte.present = 1;
|
2009-01-28 03:09:58 +00:00
|
|
|
irte.dst_mode = apic->irq_dest_mode;
|
2008-08-20 07:07:45 +00:00
|
|
|
irte.trigger_mode = 0; /* edge */
|
2009-01-28 03:09:58 +00:00
|
|
|
irte.dlvry_mode = apic->irq_delivery_mode;
|
2008-08-20 07:07:45 +00:00
|
|
|
irte.vector = cfg->vector;
|
|
|
|
irte.dest_id = IRTE_DEST(dest);
|
|
|
|
|
2009-05-22 16:41:15 +00:00
|
|
|
/* Set source-id of interrupt request */
|
2009-08-04 19:07:09 +00:00
|
|
|
if (pdev)
|
|
|
|
set_msi_sid(&irte, pdev);
|
|
|
|
else
|
|
|
|
set_hpet_sid(&irte, hpet_id);
|
2009-05-22 16:41:15 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
modify_irte(irq, &irte);
|
|
|
|
|
|
|
|
msg->address_hi = MSI_ADDR_BASE_HI;
|
|
|
|
msg->data = sub_handle;
|
|
|
|
msg->address_lo = MSI_ADDR_BASE_LO | MSI_ADDR_IR_EXT_INT |
|
|
|
|
MSI_ADDR_IR_SHV |
|
|
|
|
MSI_ADDR_IR_INDEX1(ir_index) |
|
|
|
|
MSI_ADDR_IR_INDEX2(ir_index);
|
2009-03-17 00:05:02 +00:00
|
|
|
} else {
|
2009-03-17 00:04:55 +00:00
|
|
|
if (x2apic_enabled())
|
|
|
|
msg->address_hi = MSI_ADDR_BASE_HI |
|
|
|
|
MSI_ADDR_EXT_DEST_ID(dest);
|
|
|
|
else
|
|
|
|
msg->address_hi = MSI_ADDR_BASE_HI;
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
msg->address_lo =
|
|
|
|
MSI_ADDR_BASE_LO |
|
2009-01-28 03:09:58 +00:00
|
|
|
((apic->irq_dest_mode == 0) ?
|
2008-08-20 07:07:45 +00:00
|
|
|
MSI_ADDR_DEST_MODE_PHYSICAL:
|
|
|
|
MSI_ADDR_DEST_MODE_LOGICAL) |
|
2009-01-28 03:09:58 +00:00
|
|
|
((apic->irq_delivery_mode != dest_LowestPrio) ?
|
2008-08-20 07:07:45 +00:00
|
|
|
MSI_ADDR_REDIRECTION_CPU:
|
|
|
|
MSI_ADDR_REDIRECTION_LOWPRI) |
|
|
|
|
MSI_ADDR_DEST_ID(dest);
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
msg->data =
|
|
|
|
MSI_DATA_TRIGGER_EDGE |
|
|
|
|
MSI_DATA_LEVEL_ASSERT |
|
2009-01-28 03:09:58 +00:00
|
|
|
((apic->irq_delivery_mode != dest_LowestPrio) ?
|
2008-08-20 07:07:45 +00:00
|
|
|
MSI_DATA_DELIVERY_FIXED:
|
|
|
|
MSI_DATA_DELIVERY_LOWPRI) |
|
|
|
|
MSI_DATA_VECTOR(cfg->vector);
|
|
|
|
}
|
2008-08-20 03:50:28 +00:00
|
|
|
return err;
|
2006-10-04 09:16:43 +00:00
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:59 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2009-04-28 00:59:21 +00:00
|
|
|
static int set_msi_irq_affinity(unsigned int irq, const struct cpumask *mask)
|
2006-10-04 09:16:43 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-08-20 03:50:28 +00:00
|
|
|
struct irq_cfg *cfg;
|
2006-10-04 09:16:59 +00:00
|
|
|
struct msi_msg msg;
|
|
|
|
unsigned int dest;
|
|
|
|
|
2009-12-18 02:29:46 +00:00
|
|
|
if (set_desc_affinity(desc, mask, &dest))
|
2009-04-28 00:59:21 +00:00
|
|
|
return -1;
|
2006-10-04 09:16:43 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
2006-10-04 09:16:43 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
read_msi_msg_desc(desc, &msg);
|
2006-10-04 09:16:59 +00:00
|
|
|
|
|
|
|
msg.data &= ~MSI_DATA_VECTOR_MASK;
|
2008-08-20 03:50:28 +00:00
|
|
|
msg.data |= MSI_DATA_VECTOR(cfg->vector);
|
2006-10-04 09:16:59 +00:00
|
|
|
msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
|
|
|
|
msg.address_lo |= MSI_ADDR_DEST_ID(dest);
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
write_msi_msg_desc(desc, &msg);
|
2009-04-28 00:59:21 +00:00
|
|
|
|
|
|
|
return 0;
|
2006-10-04 09:16:43 +00:00
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_INTR_REMAP
|
|
|
|
/*
|
|
|
|
* Migrate the MSI irq to another cpumask. This migration is
|
|
|
|
* done in the process context using interrupt-remapping hardware.
|
|
|
|
*/
|
2009-04-28 00:59:21 +00:00
|
|
|
static int
|
2008-12-17 01:33:52 +00:00
|
|
|
ir_set_msi_irq_affinity(unsigned int irq, const struct cpumask *mask)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-12-18 23:59:09 +00:00
|
|
|
struct irq_cfg *cfg = desc->chip_data;
|
2008-08-20 07:07:45 +00:00
|
|
|
unsigned int dest;
|
|
|
|
struct irte irte;
|
|
|
|
|
|
|
|
if (get_irte(irq, &irte))
|
2009-04-28 00:59:21 +00:00
|
|
|
return -1;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-12-18 02:29:46 +00:00
|
|
|
if (set_desc_affinity(desc, mask, &dest))
|
2009-04-28 00:59:21 +00:00
|
|
|
return -1;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
irte.vector = cfg->vector;
|
|
|
|
irte.dest_id = IRTE_DEST(dest);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* atomically update the IRTE with the new destination and vector.
|
|
|
|
*/
|
|
|
|
modify_irte(irq, &irte);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* After this point, all the interrupts will start arriving
|
|
|
|
* at the new destination. So, time to cleanup the previous
|
|
|
|
* vector allocation.
|
|
|
|
*/
|
2008-12-17 01:33:56 +00:00
|
|
|
if (cfg->move_in_progress)
|
|
|
|
send_cleanup_vector(cfg);
|
2009-04-28 00:59:21 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2008-12-06 02:58:34 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
2006-10-04 09:16:59 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
2006-10-04 09:16:43 +00:00
|
|
|
|
2006-10-04 09:16:59 +00:00
|
|
|
/*
|
|
|
|
* IRQ Chip for MSI PCI/PCI-X/PCI-Express Devices,
|
|
|
|
* which implement the MSI or MSI-X Capability Structure.
|
|
|
|
*/
|
|
|
|
static struct irq_chip msi_chip = {
|
|
|
|
.name = "PCI-MSI",
|
|
|
|
.unmask = unmask_msi_irq,
|
|
|
|
.mask = mask_msi_irq,
|
2008-08-20 03:50:34 +00:00
|
|
|
.ack = ack_apic_edge,
|
2006-10-04 09:16:59 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
.set_affinity = set_msi_irq_affinity,
|
|
|
|
#endif
|
|
|
|
.retrigger = ioapic_retrigger_irq,
|
2006-10-04 09:16:43 +00:00
|
|
|
};
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
static struct irq_chip msi_ir_chip = {
|
|
|
|
.name = "IR-PCI-MSI",
|
|
|
|
.unmask = unmask_msi_irq,
|
|
|
|
.mask = mask_msi_irq,
|
2009-03-22 20:41:25 +00:00
|
|
|
#ifdef CONFIG_INTR_REMAP
|
2009-04-03 09:15:50 +00:00
|
|
|
.ack = ir_ack_apic_edge,
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
.set_affinity = ir_set_msi_irq_affinity,
|
2009-03-22 20:41:25 +00:00
|
|
|
#endif
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
|
|
|
.retrigger = ioapic_retrigger_irq,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Map the PCI dev to the corresponding remapping hardware unit
|
|
|
|
* and allocate 'nvec' consecutive interrupt-remapping table entries
|
|
|
|
* in it.
|
|
|
|
*/
|
|
|
|
static int msi_alloc_irte(struct pci_dev *dev, int irq, int nvec)
|
|
|
|
{
|
|
|
|
struct intel_iommu *iommu;
|
|
|
|
int index;
|
|
|
|
|
|
|
|
iommu = map_dev_to_ir(dev);
|
|
|
|
if (!iommu) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"Unable to map PCI %s to iommu\n", pci_name(dev));
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = alloc_irte(iommu, irq, nvec);
|
|
|
|
if (index < 0) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"Unable to allocate %d IRTE for PCI %s\n", nvec,
|
2008-10-15 13:27:23 +00:00
|
|
|
pci_name(dev));
|
2008-08-20 07:07:45 +00:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
return index;
|
|
|
|
}
|
2008-08-20 03:50:34 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
static int setup_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int irq)
|
2008-08-20 03:50:34 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct msi_msg msg;
|
|
|
|
|
2009-08-04 19:07:09 +00:00
|
|
|
ret = msi_compose_msg(dev, irq, &msg, -1);
|
2008-08-20 03:50:34 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
set_irq_msi(irq, msidesc);
|
2008-08-20 03:50:34 +00:00
|
|
|
write_msi_msg(irq, &msg);
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
if (irq_remapped(irq)) {
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
/*
|
|
|
|
* irq migration in process context
|
|
|
|
*/
|
|
|
|
desc->status |= IRQ_MOVE_PCNTXT;
|
|
|
|
set_irq_chip_and_handler_name(irq, &msi_ir_chip, handle_edge_irq, "edge");
|
|
|
|
} else
|
|
|
|
set_irq_chip_and_handler_name(irq, &msi_chip, handle_edge_irq, "edge");
|
2008-08-20 03:50:34 +00:00
|
|
|
|
2008-09-25 18:53:11 +00:00
|
|
|
dev_printk(KERN_DEBUG, &dev->dev, "irq %d for MSI/MSI-X\n", irq);
|
|
|
|
|
2008-08-20 03:50:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:41 +00:00
|
|
|
int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
|
|
|
|
{
|
2008-08-20 07:07:45 +00:00
|
|
|
unsigned int irq;
|
|
|
|
int ret, sub_handle;
|
2008-12-06 02:58:31 +00:00
|
|
|
struct msi_desc *msidesc;
|
2008-08-20 07:07:45 +00:00
|
|
|
unsigned int irq_want;
|
2009-03-22 17:11:09 +00:00
|
|
|
struct intel_iommu *iommu = NULL;
|
2008-08-20 07:07:45 +00:00
|
|
|
int index = 0;
|
2009-04-28 01:02:23 +00:00
|
|
|
int node;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-03-17 12:54:10 +00:00
|
|
|
/* x86 doesn't support multiple MSI yet */
|
|
|
|
if (type == PCI_CAP_ID_MSI && nvec > 1)
|
|
|
|
return 1;
|
|
|
|
|
2009-04-28 01:02:23 +00:00
|
|
|
node = dev_to_node(&dev->dev);
|
2008-12-06 02:58:33 +00:00
|
|
|
irq_want = nr_irqs_gsi;
|
2008-08-20 07:07:45 +00:00
|
|
|
sub_handle = 0;
|
2008-12-06 02:58:31 +00:00
|
|
|
list_for_each_entry(msidesc, &dev->msi_list, list) {
|
2009-04-28 01:02:23 +00:00
|
|
|
irq = create_irq_nr(irq_want, node);
|
2008-08-20 07:07:45 +00:00
|
|
|
if (irq == 0)
|
|
|
|
return -1;
|
2009-02-09 00:18:03 +00:00
|
|
|
irq_want = irq + 1;
|
2008-08-20 07:07:45 +00:00
|
|
|
if (!intr_remapping_enabled)
|
|
|
|
goto no_ir;
|
|
|
|
|
|
|
|
if (!sub_handle) {
|
|
|
|
/*
|
|
|
|
* allocate the consecutive block of IRTE's
|
|
|
|
* for 'nvec'
|
|
|
|
*/
|
|
|
|
index = msi_alloc_irte(dev, irq, nvec);
|
|
|
|
if (index < 0) {
|
|
|
|
ret = index;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
iommu = map_dev_to_ir(dev);
|
|
|
|
if (!iommu) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* setup the mapping between the irq and the IRTE
|
|
|
|
* base index, the sub_handle pointing to the
|
|
|
|
* appropriate interrupt remap table entry.
|
|
|
|
*/
|
|
|
|
set_irte_irq(irq, iommu, index, sub_handle);
|
|
|
|
}
|
|
|
|
no_ir:
|
2008-12-06 02:58:31 +00:00
|
|
|
ret = setup_msi_irq(dev, msidesc, irq);
|
2008-08-20 07:07:45 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
|
|
|
sub_handle++;
|
|
|
|
}
|
|
|
|
return 0;
|
2008-08-20 03:50:41 +00:00
|
|
|
|
|
|
|
error:
|
2008-08-20 07:07:45 +00:00
|
|
|
destroy_irq(irq);
|
|
|
|
return ret;
|
2008-08-20 03:50:41 +00:00
|
|
|
}
|
|
|
|
|
2006-10-04 09:16:59 +00:00
|
|
|
void arch_teardown_msi_irq(unsigned int irq)
|
|
|
|
{
|
2007-01-28 19:56:37 +00:00
|
|
|
destroy_irq(irq);
|
2006-10-04 09:16:59 +00:00
|
|
|
}
|
|
|
|
|
2009-03-17 00:04:55 +00:00
|
|
|
#if defined (CONFIG_DMAR) || defined (CONFIG_INTR_REMAP)
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2009-04-28 00:59:21 +00:00
|
|
|
static int dmar_msi_set_affinity(unsigned int irq, const struct cpumask *mask)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-08-20 07:07:45 +00:00
|
|
|
struct irq_cfg *cfg;
|
|
|
|
struct msi_msg msg;
|
|
|
|
unsigned int dest;
|
|
|
|
|
2009-12-18 02:29:46 +00:00
|
|
|
if (set_desc_affinity(desc, mask, &dest))
|
2009-04-28 00:59:21 +00:00
|
|
|
return -1;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
|
|
|
dmar_msi_read(irq, &msg);
|
|
|
|
|
|
|
|
msg.data &= ~MSI_DATA_VECTOR_MASK;
|
|
|
|
msg.data |= MSI_DATA_VECTOR(cfg->vector);
|
|
|
|
msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
|
|
|
|
msg.address_lo |= MSI_ADDR_DEST_ID(dest);
|
|
|
|
|
|
|
|
dmar_msi_write(irq, &msg);
|
2009-04-28 00:59:21 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
2008-12-06 02:58:34 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2009-06-10 19:41:01 +00:00
|
|
|
static struct irq_chip dmar_msi_type = {
|
2008-08-20 07:07:45 +00:00
|
|
|
.name = "DMAR_MSI",
|
|
|
|
.unmask = dmar_msi_unmask,
|
|
|
|
.mask = dmar_msi_mask,
|
|
|
|
.ack = ack_apic_edge,
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
.set_affinity = dmar_msi_set_affinity,
|
|
|
|
#endif
|
|
|
|
.retrigger = ioapic_retrigger_irq,
|
|
|
|
};
|
|
|
|
|
|
|
|
int arch_setup_dmar_msi(unsigned int irq)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct msi_msg msg;
|
2006-10-04 09:16:43 +00:00
|
|
|
|
2009-08-04 19:07:09 +00:00
|
|
|
ret = msi_compose_msg(NULL, irq, &msg, -1);
|
2008-08-20 07:07:45 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
dmar_msi_write(irq, &msg);
|
|
|
|
set_irq_chip_and_handler_name(irq, &dmar_msi_type, handle_edge_irq,
|
|
|
|
"edge");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-09-06 01:02:17 +00:00
|
|
|
#ifdef CONFIG_HPET_TIMER
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2009-04-28 00:59:21 +00:00
|
|
|
static int hpet_msi_set_affinity(unsigned int irq, const struct cpumask *mask)
|
2008-09-06 01:02:17 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-09-06 01:02:17 +00:00
|
|
|
struct irq_cfg *cfg;
|
|
|
|
struct msi_msg msg;
|
|
|
|
unsigned int dest;
|
|
|
|
|
2009-12-18 02:29:46 +00:00
|
|
|
if (set_desc_affinity(desc, mask, &dest))
|
2009-04-28 00:59:21 +00:00
|
|
|
return -1;
|
2008-09-06 01:02:17 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
2008-09-06 01:02:17 +00:00
|
|
|
|
|
|
|
hpet_msi_read(irq, &msg);
|
|
|
|
|
|
|
|
msg.data &= ~MSI_DATA_VECTOR_MASK;
|
|
|
|
msg.data |= MSI_DATA_VECTOR(cfg->vector);
|
|
|
|
msg.address_lo &= ~MSI_ADDR_DEST_ID_MASK;
|
|
|
|
msg.address_lo |= MSI_ADDR_DEST_ID(dest);
|
|
|
|
|
|
|
|
hpet_msi_write(irq, &msg);
|
2009-04-28 00:59:21 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-09-06 01:02:17 +00:00
|
|
|
}
|
2008-12-06 02:58:34 +00:00
|
|
|
|
2008-09-06 01:02:17 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2009-08-04 19:07:09 +00:00
|
|
|
static struct irq_chip ir_hpet_msi_type = {
|
|
|
|
.name = "IR-HPET_MSI",
|
|
|
|
.unmask = hpet_msi_unmask,
|
|
|
|
.mask = hpet_msi_mask,
|
|
|
|
#ifdef CONFIG_INTR_REMAP
|
|
|
|
.ack = ir_ack_apic_edge,
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
.set_affinity = ir_set_msi_irq_affinity,
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
.retrigger = ioapic_retrigger_irq,
|
|
|
|
};
|
|
|
|
|
2009-03-22 17:11:09 +00:00
|
|
|
static struct irq_chip hpet_msi_type = {
|
2008-09-06 01:02:17 +00:00
|
|
|
.name = "HPET_MSI",
|
|
|
|
.unmask = hpet_msi_unmask,
|
|
|
|
.mask = hpet_msi_mask,
|
|
|
|
.ack = ack_apic_edge,
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
.set_affinity = hpet_msi_set_affinity,
|
|
|
|
#endif
|
|
|
|
.retrigger = ioapic_retrigger_irq,
|
|
|
|
};
|
|
|
|
|
2009-08-04 19:07:09 +00:00
|
|
|
int arch_setup_hpet_msi(unsigned int irq, unsigned int id)
|
2008-09-06 01:02:17 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct msi_msg msg;
|
2009-04-13 22:20:58 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-09-06 01:02:17 +00:00
|
|
|
|
2009-08-04 19:07:09 +00:00
|
|
|
if (intr_remapping_enabled) {
|
|
|
|
struct intel_iommu *iommu = map_hpet_to_ir(id);
|
|
|
|
int index;
|
|
|
|
|
|
|
|
if (!iommu)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
index = alloc_irte(iommu, irq, 1);
|
|
|
|
if (index < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = msi_compose_msg(NULL, irq, &msg, id);
|
2008-09-06 01:02:17 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
hpet_msi_write(irq, &msg);
|
2009-04-13 22:20:58 +00:00
|
|
|
desc->status |= IRQ_MOVE_PCNTXT;
|
2009-08-04 19:07:09 +00:00
|
|
|
if (irq_remapped(irq))
|
|
|
|
set_irq_chip_and_handler_name(irq, &ir_hpet_msi_type,
|
|
|
|
handle_edge_irq, "edge");
|
|
|
|
else
|
|
|
|
set_irq_chip_and_handler_name(irq, &hpet_msi_type,
|
|
|
|
handle_edge_irq, "edge");
|
2008-09-25 18:53:11 +00:00
|
|
|
|
2008-09-06 01:02:17 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif /* CONFIG_PCI_MSI */
|
2006-10-04 09:16:55 +00:00
|
|
|
/*
|
|
|
|
* Hypertransport interrupt support
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_HT_IRQ
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
static void target_ht_irq(unsigned int irq, unsigned int dest, u8 vector)
|
2006-10-04 09:16:55 +00:00
|
|
|
{
|
2006-11-09 01:44:57 +00:00
|
|
|
struct ht_irq_msg msg;
|
|
|
|
fetch_ht_irq_msg(irq, &msg);
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
msg.address_lo &= ~(HT_IRQ_LOW_VECTOR_MASK | HT_IRQ_LOW_DEST_ID_MASK);
|
2006-11-09 01:44:57 +00:00
|
|
|
msg.address_hi &= ~(HT_IRQ_HIGH_DEST_ID_MASK);
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
msg.address_lo |= HT_IRQ_LOW_VECTOR(vector) | HT_IRQ_LOW_DEST_ID(dest);
|
2006-11-09 01:44:57 +00:00
|
|
|
msg.address_hi |= HT_IRQ_HIGH_DEST_ID(dest);
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2006-11-09 01:44:57 +00:00
|
|
|
write_ht_irq_msg(irq, &msg);
|
2006-10-04 09:16:55 +00:00
|
|
|
}
|
|
|
|
|
2009-04-28 00:59:21 +00:00
|
|
|
static int set_ht_irq_affinity(unsigned int irq, const struct cpumask *mask)
|
2006-10-04 09:16:55 +00:00
|
|
|
{
|
2008-12-06 02:58:34 +00:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-08-20 03:50:28 +00:00
|
|
|
struct irq_cfg *cfg;
|
2006-10-04 09:16:55 +00:00
|
|
|
unsigned int dest;
|
|
|
|
|
2009-12-18 02:29:46 +00:00
|
|
|
if (set_desc_affinity(desc, mask, &dest))
|
2009-04-28 00:59:21 +00:00
|
|
|
return -1;
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = desc->chip_data;
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
target_ht_irq(irq, dest, cfg->vector);
|
2009-04-28 00:59:21 +00:00
|
|
|
|
|
|
|
return 0;
|
2006-10-04 09:16:55 +00:00
|
|
|
}
|
2008-12-06 02:58:34 +00:00
|
|
|
|
2006-10-04 09:16:55 +00:00
|
|
|
#endif
|
|
|
|
|
2006-10-11 08:20:43 +00:00
|
|
|
static struct irq_chip ht_irq_chip = {
|
2006-10-04 09:16:55 +00:00
|
|
|
.name = "PCI-HT",
|
|
|
|
.mask = mask_ht_irq,
|
|
|
|
.unmask = unmask_ht_irq,
|
2008-08-20 03:50:34 +00:00
|
|
|
.ack = ack_apic_edge,
|
2006-10-04 09:16:55 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
.set_affinity = set_ht_irq_affinity,
|
|
|
|
#endif
|
|
|
|
.retrigger = ioapic_retrigger_irq,
|
|
|
|
};
|
|
|
|
|
|
|
|
int arch_setup_ht_irq(unsigned int irq, struct pci_dev *dev)
|
|
|
|
{
|
2008-08-20 03:50:28 +00:00
|
|
|
struct irq_cfg *cfg;
|
|
|
|
int err;
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2009-01-14 12:27:35 +00:00
|
|
|
if (disable_apic)
|
|
|
|
return -ENXIO;
|
|
|
|
|
2008-12-06 02:58:34 +00:00
|
|
|
cfg = irq_cfg(irq);
|
2009-01-28 03:32:51 +00:00
|
|
|
err = assign_irq_vector(irq, cfg, apic->target_cpus());
|
2008-08-20 07:07:45 +00:00
|
|
|
if (!err) {
|
2006-11-09 01:44:57 +00:00
|
|
|
struct ht_irq_msg msg;
|
2006-10-04 09:16:55 +00:00
|
|
|
unsigned dest;
|
|
|
|
|
2009-01-28 14:20:18 +00:00
|
|
|
dest = apic->cpu_mask_to_apicid_and(cfg->domain,
|
|
|
|
apic->target_cpus());
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2006-11-09 01:44:57 +00:00
|
|
|
msg.address_hi = HT_IRQ_HIGH_DEST_ID(dest);
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2006-11-09 01:44:57 +00:00
|
|
|
msg.address_lo =
|
|
|
|
HT_IRQ_LOW_BASE |
|
2006-10-04 09:16:55 +00:00
|
|
|
HT_IRQ_LOW_DEST_ID(dest) |
|
2008-08-20 03:50:28 +00:00
|
|
|
HT_IRQ_LOW_VECTOR(cfg->vector) |
|
2009-01-28 03:09:58 +00:00
|
|
|
((apic->irq_dest_mode == 0) ?
|
2006-10-04 09:16:55 +00:00
|
|
|
HT_IRQ_LOW_DM_PHYSICAL :
|
|
|
|
HT_IRQ_LOW_DM_LOGICAL) |
|
|
|
|
HT_IRQ_LOW_RQEOI_EDGE |
|
2009-01-28 03:09:58 +00:00
|
|
|
((apic->irq_delivery_mode != dest_LowestPrio) ?
|
2006-10-04 09:16:55 +00:00
|
|
|
HT_IRQ_LOW_MT_FIXED :
|
|
|
|
HT_IRQ_LOW_MT_ARBITRATED) |
|
|
|
|
HT_IRQ_LOW_IRQ_MASKED;
|
|
|
|
|
2006-11-09 01:44:57 +00:00
|
|
|
write_ht_irq_msg(irq, &msg);
|
2006-10-04 09:16:55 +00:00
|
|
|
|
2006-10-17 07:10:03 +00:00
|
|
|
set_irq_chip_and_handler_name(irq, &ht_irq_chip,
|
|
|
|
handle_edge_irq, "edge");
|
2008-09-25 18:53:11 +00:00
|
|
|
|
|
|
|
dev_printk(KERN_DEBUG, &dev->dev, "irq %d for HT\n", irq);
|
2006-10-04 09:16:55 +00:00
|
|
|
}
|
2008-08-20 03:50:28 +00:00
|
|
|
return err;
|
2006-10-04 09:16:55 +00:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_HT_IRQ */
|
|
|
|
|
2008-08-20 03:50:52 +00:00
|
|
|
int __init io_apic_get_redir_entries (int ioapic)
|
|
|
|
{
|
|
|
|
union IO_APIC_reg_01 reg_01;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
reg_01.raw = io_apic_read(ioapic, 1);
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
|
|
|
|
return reg_01.bits.entries;
|
|
|
|
}
|
|
|
|
|
2008-12-06 02:58:33 +00:00
|
|
|
void __init probe_nr_irqs_gsi(void)
|
2008-08-20 03:50:52 +00:00
|
|
|
{
|
2008-12-06 02:58:33 +00:00
|
|
|
int nr = 0;
|
|
|
|
|
2009-02-09 00:18:03 +00:00
|
|
|
nr = acpi_probe_gsi();
|
|
|
|
if (nr > nr_irqs_gsi) {
|
2008-12-06 02:58:33 +00:00
|
|
|
nr_irqs_gsi = nr;
|
2009-02-09 00:18:03 +00:00
|
|
|
} else {
|
|
|
|
/* for acpi=off or acpi is not compiled in */
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
nr = 0;
|
|
|
|
for (idx = 0; idx < nr_ioapics; idx++)
|
|
|
|
nr += io_apic_get_redir_entries(idx) + 1;
|
|
|
|
|
|
|
|
if (nr > nr_irqs_gsi)
|
|
|
|
nr_irqs_gsi = nr;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "nr_irqs_gsi: %d\n", nr_irqs_gsi);
|
2008-08-20 03:50:52 +00:00
|
|
|
}
|
|
|
|
|
2009-01-13 01:39:24 +00:00
|
|
|
#ifdef CONFIG_SPARSE_IRQ
|
|
|
|
int __init arch_probe_nr_irqs(void)
|
|
|
|
{
|
|
|
|
int nr;
|
|
|
|
|
2009-02-09 00:18:03 +00:00
|
|
|
if (nr_irqs > (NR_VECTORS * nr_cpu_ids))
|
|
|
|
nr_irqs = NR_VECTORS * nr_cpu_ids;
|
2009-01-13 01:39:24 +00:00
|
|
|
|
2009-02-09 00:18:03 +00:00
|
|
|
nr = nr_irqs_gsi + 8 * nr_cpu_ids;
|
|
|
|
#if defined(CONFIG_PCI_MSI) || defined(CONFIG_HT_IRQ)
|
|
|
|
/*
|
|
|
|
* for MSI and HT dyn irq
|
|
|
|
*/
|
|
|
|
nr += nr_irqs_gsi * 16;
|
|
|
|
#endif
|
|
|
|
if (nr < nr_irqs)
|
2009-01-13 01:39:24 +00:00
|
|
|
nr_irqs = nr;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-05-15 20:05:16 +00:00
|
|
|
static int __io_apic_set_pci_routing(struct device *dev, int irq,
|
|
|
|
struct io_apic_irq_attr *irq_attr)
|
2009-05-06 17:08:50 +00:00
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
struct irq_cfg *cfg;
|
|
|
|
int node;
|
2009-05-15 20:05:16 +00:00
|
|
|
int ioapic, pin;
|
|
|
|
int trigger, polarity;
|
2009-05-06 17:08:50 +00:00
|
|
|
|
2009-05-15 20:05:16 +00:00
|
|
|
ioapic = irq_attr->ioapic;
|
2009-05-06 17:08:50 +00:00
|
|
|
if (!IO_APIC_IRQ(irq)) {
|
|
|
|
apic_printk(APIC_QUIET,KERN_ERR "IOAPIC[%d]: Invalid reference to IRQ 0\n",
|
|
|
|
ioapic);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev)
|
|
|
|
node = dev_to_node(dev);
|
|
|
|
else
|
|
|
|
node = cpu_to_node(boot_cpu_id);
|
|
|
|
|
|
|
|
desc = irq_to_desc_alloc_node(irq, node);
|
|
|
|
if (!desc) {
|
|
|
|
printk(KERN_INFO "can not get irq_desc %d\n", irq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-15 20:05:16 +00:00
|
|
|
pin = irq_attr->ioapic_pin;
|
|
|
|
trigger = irq_attr->trigger;
|
|
|
|
polarity = irq_attr->polarity;
|
|
|
|
|
2009-05-06 17:08:50 +00:00
|
|
|
/*
|
|
|
|
* IRQs < 16 are already in the irq_2_pin[] map
|
|
|
|
*/
|
2009-08-29 16:09:57 +00:00
|
|
|
if (irq >= nr_legacy_irqs) {
|
2009-05-06 17:08:50 +00:00
|
|
|
cfg = desc->chip_data;
|
2009-08-05 20:09:31 +00:00
|
|
|
if (add_pin_to_irq_node_nopanic(cfg, node, ioapic, pin)) {
|
|
|
|
printk(KERN_INFO "can not add pin %d for irq %d\n",
|
|
|
|
pin, irq);
|
|
|
|
return 0;
|
|
|
|
}
|
2009-05-06 17:08:50 +00:00
|
|
|
}
|
|
|
|
|
2009-05-15 20:05:16 +00:00
|
|
|
setup_IO_APIC_irq(ioapic, pin, irq, desc, trigger, polarity);
|
2009-05-06 17:08:50 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-15 20:05:16 +00:00
|
|
|
int io_apic_set_pci_routing(struct device *dev, int irq,
|
|
|
|
struct io_apic_irq_attr *irq_attr)
|
2009-05-06 17:08:50 +00:00
|
|
|
{
|
2009-05-15 20:05:16 +00:00
|
|
|
int ioapic, pin;
|
2009-05-06 17:08:50 +00:00
|
|
|
/*
|
|
|
|
* Avoid pin reprogramming. PRTs typically include entries
|
|
|
|
* with redundant pin->gsi mappings (but unique PCI devices);
|
|
|
|
* we only program the IOAPIC on the first.
|
|
|
|
*/
|
2009-05-15 20:05:16 +00:00
|
|
|
ioapic = irq_attr->ioapic;
|
|
|
|
pin = irq_attr->ioapic_pin;
|
2009-05-06 17:08:50 +00:00
|
|
|
if (test_bit(pin, mp_ioapic_routing[ioapic].pin_programmed)) {
|
|
|
|
pr_debug("Pin %d-%d already programmed\n",
|
|
|
|
mp_ioapics[ioapic].apicid, pin);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
set_bit(pin, mp_ioapic_routing[ioapic].pin_programmed);
|
|
|
|
|
2009-05-15 20:05:16 +00:00
|
|
|
return __io_apic_set_pci_routing(dev, irq, irq_attr);
|
2009-05-06 17:08:50 +00:00
|
|
|
}
|
|
|
|
|
2009-07-08 03:01:15 +00:00
|
|
|
u8 __init io_apic_unique_id(u8 id)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
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;
|
|
|
|
#else
|
|
|
|
int i;
|
|
|
|
DECLARE_BITMAP(used, 256);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-07-08 03:01:15 +00:00
|
|
|
bitmap_zero(used, 256);
|
|
|
|
for (i = 0; i < nr_ioapics; i++) {
|
|
|
|
struct mpc_ioapic *ia = &mp_ioapics[i];
|
|
|
|
__set_bit(ia->apicid, used);
|
|
|
|
}
|
|
|
|
if (!test_bit(id, used))
|
|
|
|
return id;
|
|
|
|
return find_first_zero_bit(used, 256);
|
|
|
|
#endif
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-08 11:07:18 +00:00
|
|
|
int __init io_apic_get_unique_id(int ioapic, int apic_id)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
union IO_APIC_reg_00 reg_00;
|
|
|
|
static physid_mask_t apic_id_map = PHYSID_MASK_NONE;
|
|
|
|
physid_mask_t tmp;
|
|
|
|
unsigned long flags;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
/*
|
2008-06-08 11:07:18 +00:00
|
|
|
* The P4 platform supports up to 256 APIC IDs on two separate APIC
|
|
|
|
* buses (one for LAPICs, one for IOAPICs), where predecessors only
|
2005-04-16 22:20:36 +00:00
|
|
|
* supports up to 16 on one shared APIC bus.
|
2008-06-08 11:07:18 +00:00
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* TBD: Expand LAPIC/IOAPIC support on P4-class systems to take full
|
|
|
|
* advantage of new APIC bus architecture.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (physids_empty(apic_id_map))
|
2009-11-09 22:06:59 +00:00
|
|
|
apic->ioapic_phys_id_map(&phys_cpu_present_map, &apic_id_map);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
reg_00.raw = io_apic_read(ioapic, 0);
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
|
|
|
|
if (apic_id >= get_physical_broadcast()) {
|
|
|
|
printk(KERN_WARNING "IOAPIC[%d]: Invalid apic_id %d, trying "
|
|
|
|
"%d\n", ioapic, apic_id, reg_00.bits.ID);
|
|
|
|
apic_id = reg_00.bits.ID;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2008-06-08 11:07:18 +00:00
|
|
|
* Every APIC in a system must have a unique ID or we get lots of nice
|
2005-04-16 22:20:36 +00:00
|
|
|
* 'stuck on smp_invalidate_needed IPI wait' messages.
|
|
|
|
*/
|
2009-11-09 22:06:59 +00:00
|
|
|
if (apic->check_apicid_used(&apic_id_map, apic_id)) {
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (i = 0; i < get_physical_broadcast(); i++) {
|
2009-11-09 22:06:59 +00:00
|
|
|
if (!apic->check_apicid_used(&apic_id_map, i))
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == get_physical_broadcast())
|
|
|
|
panic("Max apic_id exceeded!\n");
|
|
|
|
|
|
|
|
printk(KERN_WARNING "IOAPIC[%d]: apic_id %d already used, "
|
|
|
|
"trying %d\n", ioapic, apic_id, i);
|
|
|
|
|
|
|
|
apic_id = i;
|
2008-06-08 11:07:18 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-11-09 22:06:59 +00:00
|
|
|
apic->apicid_to_cpu_present(apic_id, &tmp);
|
2005-04-16 22:20:36 +00:00
|
|
|
physids_or(apic_id_map, apic_id_map, tmp);
|
|
|
|
|
|
|
|
if (reg_00.bits.ID != apic_id) {
|
|
|
|
reg_00.bits.ID = apic_id;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
io_apic_write(ioapic, 0, reg_00.raw);
|
|
|
|
reg_00.raw = io_apic_read(ioapic, 0);
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
|
|
|
|
/* Sanity check */
|
2006-02-26 03:18:34 +00:00
|
|
|
if (reg_00.bits.ID != apic_id) {
|
|
|
|
printk("IOAPIC[%d]: Unable to change apic_id!\n", ioapic);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
apic_printk(APIC_VERBOSE, KERN_INFO
|
|
|
|
"IOAPIC[%d]: Assigned apic_id %d\n", ioapic, apic_id);
|
|
|
|
|
|
|
|
return apic_id;
|
|
|
|
}
|
x86: Print real IOAPIC version for x86-64
Fix the fact that the IOAPIC version number in the x86_64 code path always
gets assigned to 0, instead of the correct value.
Before the patch: (from "dmesg" output):
ACPI: IOAPIC (id[0x08] address[0xfec00000] gsi_base[0])
IOAPIC[0]: apic_id 8, version 0, address 0xfec00000, GSI 0-23 <---
After the patch:
ACPI: IOAPIC (id[0x08] address[0xfec00000] gsi_base[0])
IOAPIC[0]: apic_id 8, version 32, address 0xfec00000, GSI 0-23 <---
History:
io_apic_get_version() was compiled out of the x86_64 code path in the commit
f2c2cca3acef8b253a36381d9b469ad4fb08563a:
Author: Andi Kleen <ak@suse.de>
Date: Tue Sep 26 10:52:37 2006 +0200
[PATCH] Remove APIC version/cpu capability mpparse checking/printing
ACPI went to great trouble to get the APIC version and CPU capabilities
of different CPUs before passing them to the mpparser. But all
that data was used was to print it out. Actually it even faked some data
based on the boot cpu, not on the actual CPU being booted.
Remove all this code because it's not needed.
Cc: len.brown@intel.com
At the time, the IOAPIC version number was deliberately not printed
in the x86_64 code path. However, after the x86 and x86_64 files were
merged, the net result is that the IOAPIC version is printed incorrectly
in the x86_64 code path.
The patch below provides a fix. I have tested it with acpi, and with
acpi=off, and did not see any problems.
Signed-off-by: Naga Chumbalkar <nagananda.chumbalkar@hp.com>
Acked-by: Yinghai Lu <yhlu.kernel@gmail.com>
LKML-Reference: <20090416014230.4885.94926.sendpatchset@localhost.localdomain>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
*************************
2009-05-26 21:48:07 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-08 11:07:18 +00:00
|
|
|
int __init io_apic_get_version(int ioapic)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
union IO_APIC_reg_01 reg_01;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&ioapic_lock, flags);
|
|
|
|
reg_01.raw = io_apic_read(ioapic, 1);
|
|
|
|
spin_unlock_irqrestore(&ioapic_lock, flags);
|
|
|
|
|
|
|
|
return reg_01.bits.version;
|
|
|
|
}
|
|
|
|
|
2007-11-17 06:05:28 +00:00
|
|
|
int acpi_get_override_irq(int bus_irq, int *trigger, int *polarity)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (skip_ioapic_setup)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (i = 0; i < mp_irq_entries; i++)
|
2009-01-12 12:17:22 +00:00
|
|
|
if (mp_irqs[i].irqtype == mp_INT &&
|
|
|
|
mp_irqs[i].srcbusirq == bus_irq)
|
2007-11-17 06:05:28 +00:00
|
|
|
break;
|
|
|
|
if (i >= mp_irq_entries)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
*trigger = irq_trigger(i);
|
|
|
|
*polarity = irq_polarity(i);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
/*
|
|
|
|
* This function currently is only a helper for the i386 smp boot process where
|
|
|
|
* we need to reprogram the ioredtbls to cater for the cpus which have come online
|
2009-01-28 03:32:51 +00:00
|
|
|
* so mask in all cases should simply be apic->target_cpus()
|
2008-08-20 03:50:28 +00:00
|
|
|
*/
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
void __init setup_ioapic_dest(void)
|
|
|
|
{
|
2009-05-06 17:10:06 +00:00
|
|
|
int pin, ioapic = 0, irq, irq_entry;
|
2008-11-07 11:33:49 +00:00
|
|
|
struct irq_desc *desc;
|
2008-12-17 01:33:56 +00:00
|
|
|
const struct cpumask *mask;
|
2008-08-20 03:50:28 +00:00
|
|
|
|
|
|
|
if (skip_ioapic_setup == 1)
|
|
|
|
return;
|
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
if (!acpi_disabled && acpi_ioapic) {
|
|
|
|
ioapic = mp_find_ioapic(0);
|
|
|
|
if (ioapic < 0)
|
|
|
|
ioapic = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2008-11-07 11:33:49 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
for (pin = 0; pin < nr_ioapic_registers[ioapic]; pin++) {
|
|
|
|
irq_entry = find_irq_entry(ioapic, pin, mp_INT);
|
|
|
|
if (irq_entry == -1)
|
|
|
|
continue;
|
|
|
|
irq = pin_2_irq(irq_entry, ioapic, pin);
|
2008-11-07 11:33:49 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
desc = irq_to_desc(irq);
|
2008-11-07 11:33:49 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
/*
|
|
|
|
* Honour affinities which have been set in early boot
|
|
|
|
*/
|
|
|
|
if (desc->status &
|
|
|
|
(IRQ_NO_BALANCING | IRQ_AFFINITY_SET))
|
|
|
|
mask = desc->affinity;
|
|
|
|
else
|
|
|
|
mask = apic->target_cpus();
|
2008-08-20 03:50:28 +00:00
|
|
|
|
2009-05-06 17:10:06 +00:00
|
|
|
if (intr_remapping_enabled)
|
|
|
|
set_ir_ioapic_affinity_irq_desc(desc, mask);
|
|
|
|
else
|
|
|
|
set_ioapic_affinity_irq_desc(desc, mask);
|
2008-08-20 03:50:28 +00:00
|
|
|
}
|
2009-05-06 17:10:06 +00:00
|
|
|
|
2008-08-20 03:50:28 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-08-20 07:07:45 +00:00
|
|
|
#define IOAPIC_RESOURCE_NAME_SIZE 11
|
|
|
|
|
|
|
|
static struct resource *ioapic_resources;
|
|
|
|
|
2009-08-24 17:53:39 +00:00
|
|
|
static struct resource * __init ioapic_setup_resources(int nr_ioapics)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
|
|
|
unsigned long n;
|
|
|
|
struct resource *res;
|
|
|
|
char *mem;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (nr_ioapics <= 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
n = IOAPIC_RESOURCE_NAME_SIZE + sizeof(struct resource);
|
|
|
|
n *= nr_ioapics;
|
|
|
|
|
|
|
|
mem = alloc_bootmem(n);
|
|
|
|
res = (void *)mem;
|
|
|
|
|
2009-08-24 17:53:39 +00:00
|
|
|
mem += sizeof(struct resource) * nr_ioapics;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-08-24 17:53:39 +00:00
|
|
|
for (i = 0; i < nr_ioapics; i++) {
|
|
|
|
res[i].name = mem;
|
|
|
|
res[i].flags = IORESOURCE_MEM | IORESOURCE_BUSY;
|
2009-11-08 15:54:31 +00:00
|
|
|
snprintf(mem, IOAPIC_RESOURCE_NAME_SIZE, "IOAPIC %u", i);
|
2009-08-24 17:53:39 +00:00
|
|
|
mem += IOAPIC_RESOURCE_NAME_SIZE;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ioapic_resources = res;
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-06-27 08:41:56 +00:00
|
|
|
void __init ioapic_init_mappings(void)
|
|
|
|
{
|
|
|
|
unsigned long ioapic_phys, idx = FIX_IO_APIC_BASE_0;
|
2008-08-20 07:07:45 +00:00
|
|
|
struct resource *ioapic_res;
|
2008-10-15 13:27:23 +00:00
|
|
|
int i;
|
2008-06-27 08:41:56 +00:00
|
|
|
|
2009-08-24 17:53:39 +00:00
|
|
|
ioapic_res = ioapic_setup_resources(nr_ioapics);
|
2008-06-27 08:41:56 +00:00
|
|
|
for (i = 0; i < nr_ioapics; i++) {
|
|
|
|
if (smp_found_config) {
|
2009-01-12 12:16:17 +00:00
|
|
|
ioapic_phys = mp_ioapics[i].apicaddr;
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-10-15 13:27:23 +00:00
|
|
|
if (!ioapic_phys) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"WARNING: bogus zero IO-APIC "
|
|
|
|
"address found in MPTABLE, "
|
|
|
|
"disabling IO/APIC support!\n");
|
|
|
|
smp_found_config = 0;
|
|
|
|
skip_ioapic_setup = 1;
|
|
|
|
goto fake_ioapic_page;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
2008-06-27 08:41:56 +00:00
|
|
|
} else {
|
2008-08-20 07:07:45 +00:00
|
|
|
#ifdef CONFIG_X86_32
|
2008-06-27 08:41:56 +00:00
|
|
|
fake_ioapic_page:
|
2008-08-20 07:07:45 +00:00
|
|
|
#endif
|
x86: io-apic: IO-APIC MMIO should not fail on resource insertion
If IO-APIC base address is 1K aligned we should not fail
on resourse insertion procedure. For this sake we define
IO_APIC_SLOT_SIZE constant which should cover all IO-APIC
direct accessible registers.
An example of a such configuration is there
http://marc.info/?l=linux-kernel&m=118114792006520
|
| Quoting the message
|
| IOAPIC[0]: apic_id 2, version 32, address 0xfec00000, GSI 0-23
| IOAPIC[1]: apic_id 3, version 32, address 0xfec80000, GSI 24-47
| IOAPIC[2]: apic_id 4, version 32, address 0xfec80400, GSI 48-71
| IOAPIC[3]: apic_id 5, version 32, address 0xfec84000, GSI 72-95
| IOAPIC[4]: apic_id 8, version 32, address 0xfec84400, GSI 96-119
|
Reported-by: "Maciej W. Rozycki" <macro@linux-mips.org>
Signed-off-by: Cyrill Gorcunov <gorcunov@openvz.org>
Acked-by: Yinghai Lu <yinghai@kernel.org>
LKML-Reference: <20091116151426.GC5653@lenovo>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-16 15:14:26 +00:00
|
|
|
ioapic_phys = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);
|
2008-06-27 08:41:56 +00:00
|
|
|
ioapic_phys = __pa(ioapic_phys);
|
|
|
|
}
|
|
|
|
set_fixmap_nocache(idx, ioapic_phys);
|
x86: io-apic: IO-APIC MMIO should not fail on resource insertion
If IO-APIC base address is 1K aligned we should not fail
on resourse insertion procedure. For this sake we define
IO_APIC_SLOT_SIZE constant which should cover all IO-APIC
direct accessible registers.
An example of a such configuration is there
http://marc.info/?l=linux-kernel&m=118114792006520
|
| Quoting the message
|
| IOAPIC[0]: apic_id 2, version 32, address 0xfec00000, GSI 0-23
| IOAPIC[1]: apic_id 3, version 32, address 0xfec80000, GSI 24-47
| IOAPIC[2]: apic_id 4, version 32, address 0xfec80400, GSI 48-71
| IOAPIC[3]: apic_id 5, version 32, address 0xfec84000, GSI 72-95
| IOAPIC[4]: apic_id 8, version 32, address 0xfec84400, GSI 96-119
|
Reported-by: "Maciej W. Rozycki" <macro@linux-mips.org>
Signed-off-by: Cyrill Gorcunov <gorcunov@openvz.org>
Acked-by: Yinghai Lu <yinghai@kernel.org>
LKML-Reference: <20091116151426.GC5653@lenovo>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-16 15:14:26 +00:00
|
|
|
apic_printk(APIC_VERBOSE, "mapped IOAPIC to %08lx (%08lx)\n",
|
|
|
|
__fix_to_virt(idx) + (ioapic_phys & ~PAGE_MASK),
|
|
|
|
ioapic_phys);
|
2008-06-27 08:41:56 +00:00
|
|
|
idx++;
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-08-24 17:53:39 +00:00
|
|
|
ioapic_res->start = ioapic_phys;
|
x86: io-apic: IO-APIC MMIO should not fail on resource insertion
If IO-APIC base address is 1K aligned we should not fail
on resourse insertion procedure. For this sake we define
IO_APIC_SLOT_SIZE constant which should cover all IO-APIC
direct accessible registers.
An example of a such configuration is there
http://marc.info/?l=linux-kernel&m=118114792006520
|
| Quoting the message
|
| IOAPIC[0]: apic_id 2, version 32, address 0xfec00000, GSI 0-23
| IOAPIC[1]: apic_id 3, version 32, address 0xfec80000, GSI 24-47
| IOAPIC[2]: apic_id 4, version 32, address 0xfec80400, GSI 48-71
| IOAPIC[3]: apic_id 5, version 32, address 0xfec84000, GSI 72-95
| IOAPIC[4]: apic_id 8, version 32, address 0xfec84400, GSI 96-119
|
Reported-by: "Maciej W. Rozycki" <macro@linux-mips.org>
Signed-off-by: Cyrill Gorcunov <gorcunov@openvz.org>
Acked-by: Yinghai Lu <yinghai@kernel.org>
LKML-Reference: <20091116151426.GC5653@lenovo>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-11-16 15:14:26 +00:00
|
|
|
ioapic_res->end = ioapic_phys + IO_APIC_SLOT_SIZE - 1;
|
2009-08-24 17:53:39 +00:00
|
|
|
ioapic_res++;
|
2008-06-27 08:41:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-10 16:36:20 +00:00
|
|
|
void __init ioapic_insert_resources(void)
|
2008-08-20 07:07:45 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct resource *r = ioapic_resources;
|
|
|
|
|
|
|
|
if (!r) {
|
2009-07-10 16:36:20 +00:00
|
|
|
if (nr_ioapics > 0)
|
2009-03-20 20:02:55 +00:00
|
|
|
printk(KERN_ERR
|
|
|
|
"IO APIC resources couldn't be allocated.\n");
|
2009-07-10 16:36:20 +00:00
|
|
|
return;
|
2008-08-20 07:07:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < nr_ioapics; i++) {
|
|
|
|
insert_resource(&iomem_resource, r);
|
|
|
|
r++;
|
|
|
|
}
|
|
|
|
}
|
2009-07-08 03:01:15 +00:00
|
|
|
|
|
|
|
int mp_find_ioapic(int gsi)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
/* Find the IOAPIC that manages this GSI. */
|
|
|
|
for (i = 0; i < nr_ioapics; i++) {
|
|
|
|
if ((gsi >= mp_gsi_routing[i].gsi_base)
|
|
|
|
&& (gsi <= mp_gsi_routing[i].gsi_end))
|
|
|
|
return i;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
|
2009-07-08 03:01:15 +00:00
|
|
|
printk(KERN_ERR "ERROR: Unable to locate IOAPIC for GSI %d\n", gsi);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int mp_find_ioapic_pin(int ioapic, int gsi)
|
|
|
|
{
|
|
|
|
if (WARN_ON(ioapic == -1))
|
|
|
|
return -1;
|
|
|
|
if (WARN_ON(gsi > mp_gsi_routing[ioapic].gsi_end))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return gsi - mp_gsi_routing[ioapic].gsi_base;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int bad_ioapic(unsigned long address)
|
|
|
|
{
|
|
|
|
if (nr_ioapics >= MAX_IO_APICS) {
|
|
|
|
printk(KERN_WARNING "WARING: Max # of I/O APICs (%d) exceeded "
|
|
|
|
"(found %d), skipping\n", MAX_IO_APICS, nr_ioapics);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (!address) {
|
|
|
|
printk(KERN_WARNING "WARNING: Bogus (zero) I/O APIC address"
|
|
|
|
" found in table, skipping!\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2008-08-20 07:07:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-08 03:01:15 +00:00
|
|
|
void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
|
|
|
|
{
|
|
|
|
int idx = 0;
|
|
|
|
|
|
|
|
if (bad_ioapic(address))
|
|
|
|
return;
|
|
|
|
|
|
|
|
idx = nr_ioapics;
|
|
|
|
|
|
|
|
mp_ioapics[idx].type = MP_IOAPIC;
|
|
|
|
mp_ioapics[idx].flags = MPC_APIC_USABLE;
|
|
|
|
mp_ioapics[idx].apicaddr = address;
|
|
|
|
|
|
|
|
set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
|
|
|
|
mp_ioapics[idx].apicid = io_apic_unique_id(id);
|
|
|
|
mp_ioapics[idx].apicver = io_apic_get_version(idx);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Build basic GSI lookup table to facilitate gsi->io_apic lookups
|
|
|
|
* and to prevent reprogramming of IOAPIC pins (PCI GSIs).
|
|
|
|
*/
|
|
|
|
mp_gsi_routing[idx].gsi_base = gsi_base;
|
|
|
|
mp_gsi_routing[idx].gsi_end = gsi_base +
|
|
|
|
io_apic_get_redir_entries(idx);
|
|
|
|
|
|
|
|
printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, "
|
|
|
|
"GSI %d-%d\n", idx, mp_ioapics[idx].apicid,
|
|
|
|
mp_ioapics[idx].apicver, mp_ioapics[idx].apicaddr,
|
|
|
|
mp_gsi_routing[idx].gsi_base, mp_gsi_routing[idx].gsi_end);
|
|
|
|
|
|
|
|
nr_ioapics++;
|
|
|
|
}
|