2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* I/O SAPIC support.
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 Intel Corp.
|
|
|
|
* Copyright (C) 1999 Asit Mallick <asit.k.mallick@intel.com>
|
|
|
|
* Copyright (C) 2000-2002 J.I. Lee <jung-ik.lee@intel.com>
|
|
|
|
* Copyright (C) 1999-2000, 2002-2003 Hewlett-Packard Co.
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
|
|
|
* Copyright (C) 1999 VA Linux Systems
|
|
|
|
* Copyright (C) 1999,2000 Walt Drummond <drummond@valinux.com>
|
|
|
|
*
|
2006-03-27 01:12:19 -07:00
|
|
|
* 00/04/19 D. Mosberger Rewritten to mirror more closely the x86 I/O
|
|
|
|
* APIC code. In particular, we now have separate
|
|
|
|
* handlers for edge and level triggered
|
|
|
|
* interrupts.
|
|
|
|
* 00/10/27 Asit Mallick, Goutham Rao <goutham.rao@intel.com> IRQ vector
|
|
|
|
* allocation PCI to vector mapping, shared PCI
|
|
|
|
* interrupts.
|
|
|
|
* 00/10/27 D. Mosberger Document things a bit more to make them more
|
|
|
|
* understandable. Clean up much of the old
|
|
|
|
* IOSAPIC cruft.
|
|
|
|
* 01/07/27 J.I. Lee PCI irq routing, Platform/Legacy interrupts
|
|
|
|
* and fixes for ACPI S5(SoftOff) support.
|
2005-04-16 16:20:36 -06:00
|
|
|
* 02/01/23 J.I. Lee iosapic pgm fixes for PCI irq routing from _PRT
|
2006-03-27 01:12:19 -07:00
|
|
|
* 02/01/07 E. Focht <efocht@ess.nec.de> Redirectable interrupt
|
|
|
|
* vectors in iosapic_set_affinity(),
|
|
|
|
* initializations for /proc/irq/#/smp_affinity
|
2005-04-16 16:20:36 -06:00
|
|
|
* 02/04/02 P. Diefenbaugh Cleaned up ACPI PCI IRQ routing.
|
|
|
|
* 02/04/18 J.I. Lee bug fix in iosapic_init_pci_irq
|
2006-03-27 01:12:19 -07:00
|
|
|
* 02/04/30 J.I. Lee bug fix in find_iosapic to fix ACPI PCI IRQ to
|
|
|
|
* IOSAPIC mapping error
|
2005-04-16 16:20:36 -06:00
|
|
|
* 02/07/29 T. Kochi Allocate interrupt vectors dynamically
|
2006-03-27 01:12:19 -07:00
|
|
|
* 02/08/04 T. Kochi Cleaned up terminology (irq, global system
|
|
|
|
* interrupt, vector, etc.)
|
|
|
|
* 02/09/20 D. Mosberger Simplified by taking advantage of ACPI's
|
|
|
|
* pci_irq code.
|
2005-04-16 16:20:36 -06:00
|
|
|
* 03/02/19 B. Helgaas Make pcat_compat system-wide, not per-IOSAPIC.
|
2006-03-27 01:12:19 -07:00
|
|
|
* Remove iosapic_address & gsi_base from
|
|
|
|
* external interfaces. Rationalize
|
|
|
|
* __init/__devinit attributes.
|
2005-04-16 16:20:36 -06:00
|
|
|
* 04/12/04 Ashok Raj <ashok.raj@intel.com> Intel Corporation 2004
|
2006-03-27 01:12:19 -07:00
|
|
|
* Updated to work with irq migration necessary
|
|
|
|
* for CPU Hotplug
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
/*
|
2006-03-27 01:12:19 -07:00
|
|
|
* Here is what the interrupt logic between a PCI device and the kernel looks
|
|
|
|
* like:
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-03-27 01:12:19 -07:00
|
|
|
* (1) A PCI device raises one of the four interrupt pins (INTA, INTB, INTC,
|
|
|
|
* INTD). The device is uniquely identified by its bus-, and slot-number
|
|
|
|
* (the function number does not matter here because all functions share
|
|
|
|
* the same interrupt lines).
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-03-27 01:12:19 -07:00
|
|
|
* (2) The motherboard routes the interrupt line to a pin on a IOSAPIC
|
|
|
|
* controller. Multiple interrupt lines may have to share the same
|
|
|
|
* IOSAPIC pin (if they're level triggered and use the same polarity).
|
|
|
|
* Each interrupt line has a unique Global System Interrupt (GSI) number
|
|
|
|
* which can be calculated as the sum of the controller's base GSI number
|
|
|
|
* and the IOSAPIC pin number to which the line connects.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-03-27 01:12:19 -07:00
|
|
|
* (3) The IOSAPIC uses an internal routing table entries (RTEs) to map the
|
|
|
|
* IOSAPIC pin into the IA-64 interrupt vector. This interrupt vector is then
|
|
|
|
* sent to the CPU.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2006-03-27 01:12:19 -07:00
|
|
|
* (4) The kernel recognizes an interrupt as an IRQ. The IRQ interface is
|
|
|
|
* used as architecture-independent interrupt handling mechanism in Linux.
|
|
|
|
* As an IRQ is a number, we have to have
|
|
|
|
* IA-64 interrupt vector number <-> IRQ number mapping. On smaller
|
|
|
|
* systems, we use one-to-one mapping between IA-64 vector and IRQ. A
|
|
|
|
* platform can implement platform_irq_to_vector(irq) and
|
2005-04-16 16:20:36 -06:00
|
|
|
* platform_local_vector_to_irq(vector) APIs to differentiate the mapping.
|
2008-08-01 11:13:32 -06:00
|
|
|
* Please see also arch/ia64/include/asm/hw_irq.h for those APIs.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* To sum up, there are three levels of mappings involved:
|
|
|
|
*
|
|
|
|
* PCI pin -> global system interrupt (GSI) -> IA-64 vector <-> IRQ
|
|
|
|
*
|
2006-03-27 01:12:19 -07:00
|
|
|
* Note: The term "IRQ" is loosely used everywhere in Linux kernel to
|
|
|
|
* describeinterrupts. Now we use "IRQ" only for Linux IRQ's. ISA IRQ
|
|
|
|
* (isa_irq) is the only exception in this source code.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/acpi.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/pci.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/string.h>
|
2005-04-25 14:26:23 -06:00
|
|
|
#include <linux/bootmem.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/delay.h>
|
|
|
|
#include <asm/hw_irq.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/iosapic.h>
|
|
|
|
#include <asm/machvec.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/ptrace.h>
|
|
|
|
|
|
|
|
#undef DEBUG_INTERRUPT_ROUTING
|
|
|
|
|
|
|
|
#ifdef DEBUG_INTERRUPT_ROUTING
|
|
|
|
#define DBG(fmt...) printk(fmt)
|
|
|
|
#else
|
|
|
|
#define DBG(fmt...)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static DEFINE_SPINLOCK(iosapic_lock);
|
|
|
|
|
2006-03-27 01:12:19 -07:00
|
|
|
/*
|
|
|
|
* These tables map IA-64 vectors to the IOSAPIC pin that generates this
|
|
|
|
* vector.
|
|
|
|
*/
|
2007-07-17 06:22:23 -06:00
|
|
|
|
|
|
|
#define NO_REF_RTE 0
|
|
|
|
|
2007-07-17 06:20:42 -06:00
|
|
|
static struct iosapic {
|
|
|
|
char __iomem *addr; /* base address of IOSAPIC */
|
|
|
|
unsigned int gsi_base; /* GSI base */
|
|
|
|
unsigned short num_rte; /* # of RTEs on this IOSAPIC */
|
|
|
|
int rtes_inuse; /* # of RTEs in use on this IOSAPIC */
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
unsigned short node; /* numa node association via pxm */
|
|
|
|
#endif
|
2007-07-17 06:21:26 -06:00
|
|
|
spinlock_t lock; /* lock for indirect reg access */
|
2007-07-17 06:20:42 -06:00
|
|
|
} iosapic_lists[NR_IOSAPICS];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info {
|
2007-07-17 06:20:42 -06:00
|
|
|
struct list_head rte_list; /* RTEs sharing the same vector */
|
2005-04-25 14:26:23 -06:00
|
|
|
char rte_index; /* IOSAPIC RTE index */
|
|
|
|
int refcnt; /* reference counter */
|
2007-07-17 06:20:42 -06:00
|
|
|
struct iosapic *iosapic;
|
2005-04-25 14:26:23 -06:00
|
|
|
} ____cacheline_aligned;
|
|
|
|
|
|
|
|
static struct iosapic_intr_info {
|
2006-03-27 01:12:19 -07:00
|
|
|
struct list_head rtes; /* RTEs using this vector (empty =>
|
|
|
|
* not an IOSAPIC interrupt) */
|
2007-07-29 20:54:41 -06:00
|
|
|
int count; /* # of registered RTEs */
|
2006-03-27 01:12:19 -07:00
|
|
|
u32 low32; /* current value of low word of
|
|
|
|
* Redirection table entry */
|
2005-04-25 14:26:23 -06:00
|
|
|
unsigned int dest; /* destination CPU physical ID */
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char dmode : 3; /* delivery mode (see iosapic.h) */
|
2006-03-27 01:12:19 -07:00
|
|
|
unsigned char polarity: 1; /* interrupt polarity
|
|
|
|
* (see iosapic.h) */
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char trigger : 1; /* trigger mode (see iosapic.h) */
|
2007-07-17 06:22:03 -06:00
|
|
|
} iosapic_intr_info[NR_IRQS];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-28 01:25:58 -06:00
|
|
|
static unsigned char pcat_compat __devinitdata; /* 8259 compatibility flag */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:21:26 -06:00
|
|
|
static inline void
|
|
|
|
iosapic_write(struct iosapic *iosapic, unsigned int reg, u32 val)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&iosapic->lock, flags);
|
|
|
|
__iosapic_write(iosapic->addr, reg, val);
|
|
|
|
spin_unlock_irqrestore(&iosapic->lock, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Find an IOSAPIC associated with a GSI
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
find_iosapic (unsigned int gsi)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2005-04-28 01:25:58 -06:00
|
|
|
for (i = 0; i < NR_IOSAPICS; i++) {
|
2006-03-27 01:12:19 -07:00
|
|
|
if ((unsigned) (gsi - iosapic_lists[i].gsi_base) <
|
|
|
|
iosapic_lists[i].num_rte)
|
2005-04-16 16:20:36 -06:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
static inline int __gsi_to_irq(unsigned int gsi)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-17 06:22:03 -06:00
|
|
|
int irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct iosapic_intr_info *info;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
for (irq = 0; irq < NR_IRQS; irq++) {
|
|
|
|
info = &iosapic_intr_info[irq];
|
2005-04-25 14:26:23 -06:00
|
|
|
list_for_each_entry(rte, &info->rtes, rte_list)
|
2007-07-17 06:20:42 -06:00
|
|
|
if (rte->iosapic->gsi_base + rte->rte_index == gsi)
|
2007-07-17 06:22:03 -06:00
|
|
|
return irq;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
gsi_to_irq (unsigned int gsi)
|
|
|
|
{
|
2005-04-25 14:26:23 -06:00
|
|
|
unsigned long flags;
|
|
|
|
int irq;
|
2007-07-17 06:22:03 -06:00
|
|
|
|
2005-04-25 14:26:23 -06:00
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 06:22:03 -06:00
|
|
|
irq = __gsi_to_irq(gsi);
|
2005-04-25 14:26:23 -06:00
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
static struct iosapic_rte_info *find_rte(unsigned int irq, unsigned int gsi)
|
2005-04-25 14:26:23 -06:00
|
|
|
{
|
|
|
|
struct iosapic_rte_info *rte;
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list)
|
2007-07-17 06:20:42 -06:00
|
|
|
if (rte->iosapic->gsi_base + rte->rte_index == gsi)
|
2005-04-25 14:26:23 -06:00
|
|
|
return rte;
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-07-17 06:22:03 -06:00
|
|
|
set_rte (unsigned int gsi, unsigned int irq, unsigned int dest, int mask)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long pol, trigger, dmode;
|
|
|
|
u32 low32, high32;
|
|
|
|
int rte_index;
|
|
|
|
char redir;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 06:22:03 -06:00
|
|
|
ia64_vector vector = irq_to_vector(irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
DBG(KERN_DEBUG"IOSAPIC: routing vector %d to 0x%x\n", vector, dest);
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
rte = find_rte(irq, gsi);
|
2005-04-25 14:26:23 -06:00
|
|
|
if (!rte)
|
2005-04-16 16:20:36 -06:00
|
|
|
return; /* not an IOSAPIC interrupt */
|
|
|
|
|
2005-04-25 14:26:23 -06:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 06:22:03 -06:00
|
|
|
pol = iosapic_intr_info[irq].polarity;
|
|
|
|
trigger = iosapic_intr_info[irq].trigger;
|
|
|
|
dmode = iosapic_intr_info[irq].dmode;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
redir = (dmode == IOSAPIC_LOWEST_PRIORITY) ? 1 : 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2007-07-17 06:22:03 -06:00
|
|
|
set_irq_affinity_info(irq, (int)(dest & 0xffff), redir);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
low32 = ((pol << IOSAPIC_POLARITY_SHIFT) |
|
|
|
|
(trigger << IOSAPIC_TRIGGER_SHIFT) |
|
|
|
|
(dmode << IOSAPIC_DELIVERY_SHIFT) |
|
|
|
|
((mask ? 1 : 0) << IOSAPIC_MASK_SHIFT) |
|
|
|
|
vector);
|
|
|
|
|
|
|
|
/* dest contains both id and eid */
|
|
|
|
high32 = (dest << IOSAPIC_DEST_SHIFT);
|
|
|
|
|
2007-07-17 06:21:26 -06:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_HIGH(rte_index), high32);
|
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_intr_info[irq].low32 = low32;
|
|
|
|
iosapic_intr_info[irq].dest = dest;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-04 12:31:21 -07:00
|
|
|
nop (struct irq_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
/* do nothing... */
|
|
|
|
}
|
|
|
|
|
2006-12-07 10:51:35 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_KEXEC
|
|
|
|
void
|
|
|
|
kexec_disable_iosapic(void)
|
|
|
|
{
|
|
|
|
struct iosapic_intr_info *info;
|
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 06:22:03 -06:00
|
|
|
ia64_vector vec;
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
for (irq = 0; irq < NR_IRQS; irq++) {
|
|
|
|
info = &iosapic_intr_info[irq];
|
|
|
|
vec = irq_to_vector(irq);
|
2006-12-07 10:51:35 -07:00
|
|
|
list_for_each_entry(rte, &info->rtes,
|
|
|
|
rte_list) {
|
2007-07-17 06:21:26 -06:00
|
|
|
iosapic_write(rte->iosapic,
|
2006-12-07 10:51:35 -07:00
|
|
|
IOSAPIC_RTE_LOW(rte->rte_index),
|
|
|
|
IOSAPIC_MASK|vec);
|
2007-07-17 06:20:42 -06:00
|
|
|
iosapic_eoi(rte->iosapic->addr, vec);
|
2006-12-07 10:51:35 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void
|
2011-02-04 12:31:21 -07:00
|
|
|
mask_irq (struct irq_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-02-04 12:31:21 -07:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 low32;
|
|
|
|
int rte_index;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-29 20:54:41 -06:00
|
|
|
if (!iosapic_intr_info[irq].count)
|
2005-04-16 16:20:36 -06:00
|
|
|
return; /* not an IOSAPIC interrupt! */
|
|
|
|
|
2007-07-17 06:20:29 -06:00
|
|
|
/* set only the mask bit */
|
2007-07-17 06:22:03 -06:00
|
|
|
low32 = iosapic_intr_info[irq].low32 |= IOSAPIC_MASK;
|
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list) {
|
2007-07-17 06:20:29 -06:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 06:21:26 -06:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-04 12:31:21 -07:00
|
|
|
unmask_irq (struct irq_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-02-04 12:31:21 -07:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 low32;
|
|
|
|
int rte_index;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-29 20:54:41 -06:00
|
|
|
if (!iosapic_intr_info[irq].count)
|
2005-04-16 16:20:36 -06:00
|
|
|
return; /* not an IOSAPIC interrupt! */
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
low32 = iosapic_intr_info[irq].low32 &= ~IOSAPIC_MASK;
|
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list) {
|
2007-07-17 06:20:29 -06:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 06:21:26 -06:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-04-27 18:59:21 -06:00
|
|
|
static int
|
2011-02-04 12:31:21 -07:00
|
|
|
iosapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
|
|
|
|
bool force)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
2011-02-04 12:31:21 -07:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
u32 high32, low32;
|
2008-12-13 03:50:26 -07:00
|
|
|
int cpu, dest, rte_index;
|
2005-04-16 16:20:36 -06:00
|
|
|
int redir = (irq & IA64_IRQ_REDIRECTED) ? 1 : 0;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 06:21:26 -06:00
|
|
|
struct iosapic *iosapic;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
irq &= (~IA64_IRQ_REDIRECTED);
|
|
|
|
|
2008-12-13 03:50:26 -07:00
|
|
|
cpu = cpumask_first_and(cpu_online_mask, mask);
|
|
|
|
if (cpu >= nr_cpu_ids)
|
2009-04-27 18:59:21 -06:00
|
|
|
return -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-12-13 03:50:26 -07:00
|
|
|
if (irq_prepare_move(irq, cpu))
|
2009-04-27 18:59:21 -06:00
|
|
|
return -1;
|
2007-07-17 06:22:48 -06:00
|
|
|
|
2008-12-13 03:50:26 -07:00
|
|
|
dest = cpu_physical_id(cpu);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-29 20:54:41 -06:00
|
|
|
if (!iosapic_intr_info[irq].count)
|
2009-04-27 18:59:21 -06:00
|
|
|
return -1; /* not an IOSAPIC interrupt */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
set_irq_affinity_info(irq, dest, redir);
|
|
|
|
|
|
|
|
/* dest contains both id and eid */
|
|
|
|
high32 = dest << IOSAPIC_DEST_SHIFT;
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
low32 = iosapic_intr_info[irq].low32 & ~(7 << IOSAPIC_DELIVERY_SHIFT);
|
2007-07-17 06:20:29 -06:00
|
|
|
if (redir)
|
|
|
|
/* change delivery mode to lowest priority */
|
|
|
|
low32 |= (IOSAPIC_LOWEST_PRIORITY << IOSAPIC_DELIVERY_SHIFT);
|
|
|
|
else
|
|
|
|
/* change delivery mode to fixed */
|
|
|
|
low32 |= (IOSAPIC_FIXED << IOSAPIC_DELIVERY_SHIFT);
|
2007-07-17 06:22:48 -06:00
|
|
|
low32 &= IOSAPIC_VECTOR_MASK;
|
|
|
|
low32 |= irq_to_vector(irq);
|
2007-07-17 06:20:29 -06:00
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_intr_info[irq].low32 = low32;
|
|
|
|
iosapic_intr_info[irq].dest = dest;
|
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list) {
|
2007-07-17 06:21:26 -06:00
|
|
|
iosapic = rte->iosapic;
|
2007-07-17 06:20:29 -06:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 06:21:26 -06:00
|
|
|
iosapic_write(iosapic, IOSAPIC_RTE_HIGH(rte_index), high32);
|
|
|
|
iosapic_write(iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-04-27 18:59:21 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2009-04-27 18:59:21 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handlers for level-triggered interrupts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int
|
2011-02-04 12:31:21 -07:00
|
|
|
iosapic_startup_level_irq (struct irq_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-02-04 12:31:21 -07:00
|
|
|
unmask_irq(data);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-04 12:31:21 -07:00
|
|
|
iosapic_unmask_level_irq (struct irq_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-02-04 12:31:21 -07:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
ia64_vector vec = irq_to_vector(irq);
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 06:22:48 -06:00
|
|
|
int do_unmask_irq = 0;
|
|
|
|
|
2008-02-24 22:32:22 -07:00
|
|
|
irq_complete_move(irq);
|
2011-03-25 13:30:53 -06:00
|
|
|
if (unlikely(irqd_is_setaffinity_pending(data))) {
|
2007-07-17 06:22:48 -06:00
|
|
|
do_unmask_irq = 1;
|
2011-02-04 12:31:21 -07:00
|
|
|
mask_irq(data);
|
2010-09-27 14:58:14 -06:00
|
|
|
} else
|
2011-02-04 12:31:21 -07:00
|
|
|
unmask_irq(data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list)
|
2007-07-17 06:20:42 -06:00
|
|
|
iosapic_eoi(rte->iosapic->addr, vec);
|
2007-07-17 06:22:48 -06:00
|
|
|
|
|
|
|
if (unlikely(do_unmask_irq)) {
|
2011-03-25 13:30:53 -06:00
|
|
|
irq_move_masked_irq(data);
|
2011-02-04 12:31:21 -07:00
|
|
|
unmask_irq(data);
|
2007-07-17 06:22:48 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#define iosapic_shutdown_level_irq mask_irq
|
|
|
|
#define iosapic_enable_level_irq unmask_irq
|
|
|
|
#define iosapic_disable_level_irq mask_irq
|
|
|
|
#define iosapic_ack_level_irq nop
|
|
|
|
|
2007-12-07 15:44:05 -07:00
|
|
|
static struct irq_chip irq_type_iosapic_level = {
|
2011-02-04 12:31:21 -07:00
|
|
|
.name = "IO-SAPIC-level",
|
|
|
|
.irq_startup = iosapic_startup_level_irq,
|
|
|
|
.irq_shutdown = iosapic_shutdown_level_irq,
|
|
|
|
.irq_enable = iosapic_enable_level_irq,
|
|
|
|
.irq_disable = iosapic_disable_level_irq,
|
|
|
|
.irq_ack = iosapic_ack_level_irq,
|
|
|
|
.irq_mask = mask_irq,
|
|
|
|
.irq_unmask = iosapic_unmask_level_irq,
|
|
|
|
.irq_set_affinity = iosapic_set_affinity
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handlers for edge-triggered interrupts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int
|
2011-02-04 12:31:21 -07:00
|
|
|
iosapic_startup_edge_irq (struct irq_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-02-04 12:31:21 -07:00
|
|
|
unmask_irq(data);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* IOSAPIC simply drops interrupts pended while the
|
|
|
|
* corresponding pin was masked, so we can't know if an
|
|
|
|
* interrupt is pending already. Let's hope not...
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-04 12:31:21 -07:00
|
|
|
iosapic_ack_edge_irq (struct irq_data *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-03-25 13:30:53 -06:00
|
|
|
irq_complete_move(data->irq);
|
|
|
|
irq_move_irq(data);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#define iosapic_enable_edge_irq unmask_irq
|
|
|
|
#define iosapic_disable_edge_irq nop
|
|
|
|
|
2007-12-07 15:44:05 -07:00
|
|
|
static struct irq_chip irq_type_iosapic_edge = {
|
2011-02-04 12:31:21 -07:00
|
|
|
.name = "IO-SAPIC-edge",
|
|
|
|
.irq_startup = iosapic_startup_edge_irq,
|
|
|
|
.irq_shutdown = iosapic_disable_edge_irq,
|
|
|
|
.irq_enable = iosapic_enable_edge_irq,
|
|
|
|
.irq_disable = iosapic_disable_edge_irq,
|
|
|
|
.irq_ack = iosapic_ack_edge_irq,
|
|
|
|
.irq_mask = mask_irq,
|
|
|
|
.irq_unmask = unmask_irq,
|
|
|
|
.irq_set_affinity = iosapic_set_affinity
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-12-07 15:44:05 -07:00
|
|
|
static unsigned int
|
2005-04-16 16:20:36 -06:00
|
|
|
iosapic_version (char __iomem *addr)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* IOSAPIC Version Register return 32 bit structure like:
|
|
|
|
* {
|
|
|
|
* unsigned int version : 8;
|
|
|
|
* unsigned int reserved1 : 8;
|
|
|
|
* unsigned int max_redir : 8;
|
|
|
|
* unsigned int reserved2 : 8;
|
|
|
|
* }
|
|
|
|
*/
|
2007-07-17 06:21:26 -06:00
|
|
|
return __iosapic_read(addr, IOSAPIC_VERSION);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
static int iosapic_find_sharable_irq(unsigned long trigger, unsigned long pol)
|
2005-04-25 14:26:23 -06:00
|
|
|
{
|
2007-07-17 06:22:03 -06:00
|
|
|
int i, irq = -ENOSPC, min_count = -1;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_intr_info *info;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* shared vectors for edge-triggered interrupts are not
|
|
|
|
* supported yet
|
|
|
|
*/
|
|
|
|
if (trigger == IOSAPIC_EDGE)
|
2007-07-17 06:20:54 -06:00
|
|
|
return -EINVAL;
|
2005-04-25 14:26:23 -06:00
|
|
|
|
2009-02-21 15:40:27 -07:00
|
|
|
for (i = 0; i < NR_IRQS; i++) {
|
2005-04-25 14:26:23 -06:00
|
|
|
info = &iosapic_intr_info[i];
|
|
|
|
if (info->trigger == trigger && info->polarity == pol &&
|
2007-07-17 06:22:14 -06:00
|
|
|
(info->dmode == IOSAPIC_FIXED ||
|
|
|
|
info->dmode == IOSAPIC_LOWEST_PRIORITY) &&
|
|
|
|
can_request_irq(i, IRQF_SHARED)) {
|
2005-04-25 14:26:23 -06:00
|
|
|
if (min_count == -1 || info->count < min_count) {
|
2007-07-17 06:22:03 -06:00
|
|
|
irq = i;
|
2005-04-25 14:26:23 -06:00
|
|
|
min_count = info->count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-07-17 06:22:03 -06:00
|
|
|
return irq;
|
2005-04-25 14:26:23 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* if the given vector is already owned by other,
|
|
|
|
* assign a new vector for the other and make the vector available
|
|
|
|
*/
|
|
|
|
static void __init
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_reassign_vector (int irq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-17 06:22:03 -06:00
|
|
|
int new_irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-29 20:54:41 -06:00
|
|
|
if (iosapic_intr_info[irq].count) {
|
2007-07-17 06:22:03 -06:00
|
|
|
new_irq = create_irq();
|
|
|
|
if (new_irq < 0)
|
2008-03-04 16:15:00 -07:00
|
|
|
panic("%s: out of interrupt vectors!\n", __func__);
|
2006-03-27 01:12:19 -07:00
|
|
|
printk(KERN_INFO "Reassigning vector %d to %d\n",
|
2007-07-17 06:22:03 -06:00
|
|
|
irq_to_vector(irq), irq_to_vector(new_irq));
|
|
|
|
memcpy(&iosapic_intr_info[new_irq], &iosapic_intr_info[irq],
|
2005-04-16 16:20:36 -06:00
|
|
|
sizeof(struct iosapic_intr_info));
|
2007-07-17 06:22:03 -06:00
|
|
|
INIT_LIST_HEAD(&iosapic_intr_info[new_irq].rtes);
|
|
|
|
list_move(iosapic_intr_info[irq].rtes.next,
|
|
|
|
&iosapic_intr_info[new_irq].rtes);
|
|
|
|
memset(&iosapic_intr_info[irq], 0,
|
2006-03-27 01:12:19 -07:00
|
|
|
sizeof(struct iosapic_intr_info));
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_intr_info[irq].low32 = IOSAPIC_MASK;
|
|
|
|
INIT_LIST_HEAD(&iosapic_intr_info[irq].rtes);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
static inline int irq_is_shared (int irq)
|
2005-04-25 14:26:23 -06:00
|
|
|
{
|
2007-07-17 06:22:03 -06:00
|
|
|
return (iosapic_intr_info[irq].count > 1);
|
2005-04-25 14:26:23 -06:00
|
|
|
}
|
|
|
|
|
2008-05-19 07:13:42 -06:00
|
|
|
struct irq_chip*
|
|
|
|
ia64_native_iosapic_get_irq_chip(unsigned long trigger)
|
|
|
|
{
|
|
|
|
if (trigger == IOSAPIC_EDGE)
|
|
|
|
return &irq_type_iosapic_edge;
|
|
|
|
else
|
|
|
|
return &irq_type_iosapic_level;
|
|
|
|
}
|
|
|
|
|
2005-07-28 12:42:00 -06:00
|
|
|
static int
|
2007-07-17 06:22:03 -06:00
|
|
|
register_intr (unsigned int gsi, int irq, unsigned char delivery,
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long polarity, unsigned long trigger)
|
|
|
|
{
|
2011-03-25 13:16:05 -06:00
|
|
|
struct irq_chip *chip, *irq_type;
|
2005-04-16 16:20:36 -06:00
|
|
|
int index;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
index = find_iosapic(gsi);
|
|
|
|
if (index < 0) {
|
2006-03-27 01:12:19 -07:00
|
|
|
printk(KERN_WARNING "%s: No IOSAPIC for GSI %u\n",
|
2008-03-04 16:15:00 -07:00
|
|
|
__func__, gsi);
|
2005-07-28 12:42:00 -06:00
|
|
|
return -ENODEV;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
rte = find_rte(irq, gsi);
|
2005-04-25 14:26:23 -06:00
|
|
|
if (!rte) {
|
2010-10-05 16:41:25 -06:00
|
|
|
rte = kzalloc(sizeof (*rte), GFP_ATOMIC);
|
2005-04-25 14:26:23 -06:00
|
|
|
if (!rte) {
|
2006-03-27 01:12:19 -07:00
|
|
|
printk(KERN_WARNING "%s: cannot allocate memory\n",
|
2008-03-04 16:15:00 -07:00
|
|
|
__func__);
|
2005-07-28 12:42:00 -06:00
|
|
|
return -ENOMEM;
|
2005-04-25 14:26:23 -06:00
|
|
|
}
|
|
|
|
|
2007-07-17 06:20:42 -06:00
|
|
|
rte->iosapic = &iosapic_lists[index];
|
|
|
|
rte->rte_index = gsi - rte->iosapic->gsi_base;
|
2005-04-25 14:26:23 -06:00
|
|
|
rte->refcnt++;
|
2007-07-17 06:22:03 -06:00
|
|
|
list_add_tail(&rte->rte_list, &iosapic_intr_info[irq].rtes);
|
|
|
|
iosapic_intr_info[irq].count++;
|
2005-04-28 01:25:58 -06:00
|
|
|
iosapic_lists[index].rtes_inuse++;
|
2005-04-25 14:26:23 -06:00
|
|
|
}
|
2007-07-17 06:22:23 -06:00
|
|
|
else if (rte->refcnt == NO_REF_RTE) {
|
2007-07-17 06:22:03 -06:00
|
|
|
struct iosapic_intr_info *info = &iosapic_intr_info[irq];
|
2007-07-17 06:22:23 -06:00
|
|
|
if (info->count > 0 &&
|
|
|
|
(info->trigger != trigger || info->polarity != polarity)){
|
2006-03-27 01:12:19 -07:00
|
|
|
printk (KERN_WARNING
|
|
|
|
"%s: cannot override the interrupt\n",
|
2008-03-04 16:15:00 -07:00
|
|
|
__func__);
|
2005-07-28 12:42:00 -06:00
|
|
|
return -EINVAL;
|
2005-04-25 14:26:23 -06:00
|
|
|
}
|
2007-07-17 06:22:23 -06:00
|
|
|
rte->refcnt++;
|
|
|
|
iosapic_intr_info[irq].count++;
|
|
|
|
iosapic_lists[index].rtes_inuse++;
|
2005-04-25 14:26:23 -06:00
|
|
|
}
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_intr_info[irq].polarity = polarity;
|
|
|
|
iosapic_intr_info[irq].dmode = delivery;
|
|
|
|
iosapic_intr_info[irq].trigger = trigger;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-05-19 07:13:42 -06:00
|
|
|
irq_type = iosapic_get_irq_chip(trigger);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-25 13:16:05 -06:00
|
|
|
chip = irq_get_chip(irq);
|
|
|
|
if (irq_type != NULL && chip != irq_type) {
|
|
|
|
if (chip != &no_irq_chip)
|
2006-03-27 01:12:19 -07:00
|
|
|
printk(KERN_WARNING
|
|
|
|
"%s: changing vector %d from %s to %s\n",
|
2008-03-04 16:15:00 -07:00
|
|
|
__func__, irq_to_vector(irq),
|
2011-03-25 13:16:05 -06:00
|
|
|
chip->name, irq_type->name);
|
|
|
|
chip = irq_type;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-03-25 13:16:05 -06:00
|
|
|
__irq_set_chip_handler_name_locked(irq, chip, trigger == IOSAPIC_EDGE ?
|
|
|
|
handle_edge_irq : handle_level_irq,
|
|
|
|
NULL);
|
2005-07-28 12:42:00 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int
|
2007-07-17 06:22:03 -06:00
|
|
|
get_target_cpu (unsigned int gsi, int irq)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static int cpu = -1;
|
2005-11-11 15:32:40 -07:00
|
|
|
extern int cpe_vector;
|
2007-07-17 06:22:33 -06:00
|
|
|
cpumask_t domain = irq_to_domain(irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-04-25 14:26:23 -06:00
|
|
|
/*
|
|
|
|
* In case of vector shared by multiple RTEs, all RTEs that
|
|
|
|
* share the vector need to use the same destination CPU.
|
|
|
|
*/
|
2007-07-29 20:54:41 -06:00
|
|
|
if (iosapic_intr_info[irq].count)
|
2007-07-17 06:22:03 -06:00
|
|
|
return iosapic_intr_info[irq].dest;
|
2005-04-25 14:26:23 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* If the platform supports redirection via XTP, let it
|
|
|
|
* distribute interrupts.
|
|
|
|
*/
|
|
|
|
if (smp_int_redirect & SMP_IRQ_REDIRECTION)
|
|
|
|
return cpu_physical_id(smp_processor_id());
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some interrupts (ACPI SCI, for instance) are registered
|
|
|
|
* before the BSP is marked as online.
|
|
|
|
*/
|
|
|
|
if (!cpu_online(smp_processor_id()))
|
|
|
|
return cpu_physical_id(smp_processor_id());
|
|
|
|
|
2005-11-11 15:32:40 -07:00
|
|
|
#ifdef CONFIG_ACPI
|
2007-07-17 06:22:03 -06:00
|
|
|
if (cpe_vector > 0 && irq_to_vector(irq) == IA64_CPEP_VECTOR)
|
2006-01-19 17:18:47 -07:00
|
|
|
return get_cpei_target_cpu();
|
2005-11-11 15:32:40 -07:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
{
|
|
|
|
int num_cpus, cpu_index, iosapic_index, numa_cpu, i = 0;
|
2008-12-26 04:53:40 -07:00
|
|
|
const struct cpumask *cpu_mask;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iosapic_index = find_iosapic(gsi);
|
|
|
|
if (iosapic_index < 0 ||
|
|
|
|
iosapic_lists[iosapic_index].node == MAX_NUMNODES)
|
|
|
|
goto skip_numa_setup;
|
|
|
|
|
2008-12-26 04:53:40 -07:00
|
|
|
cpu_mask = cpumask_of_node(iosapic_lists[iosapic_index].node);
|
|
|
|
num_cpus = 0;
|
|
|
|
for_each_cpu_and(numa_cpu, cpu_mask, &domain) {
|
|
|
|
if (cpu_online(numa_cpu))
|
|
|
|
num_cpus++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!num_cpus)
|
|
|
|
goto skip_numa_setup;
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
/* Use irq assignment to distribute across cpus in node */
|
|
|
|
cpu_index = irq % num_cpus;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-12-26 04:53:40 -07:00
|
|
|
for_each_cpu_and(numa_cpu, cpu_mask, &domain)
|
|
|
|
if (cpu_online(numa_cpu) && i++ >= cpu_index)
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-12-26 04:53:40 -07:00
|
|
|
if (numa_cpu < nr_cpu_ids)
|
2005-04-16 16:20:36 -06:00
|
|
|
return cpu_physical_id(numa_cpu);
|
|
|
|
}
|
|
|
|
skip_numa_setup:
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Otherwise, round-robin interrupt vectors across all the
|
|
|
|
* processors. (It'd be nice if we could be smarter in the
|
|
|
|
* case of NUMA.)
|
|
|
|
*/
|
|
|
|
do {
|
2008-12-26 04:53:40 -07:00
|
|
|
if (++cpu >= nr_cpu_ids)
|
2005-04-16 16:20:36 -06:00
|
|
|
cpu = 0;
|
2007-07-17 06:22:33 -06:00
|
|
|
} while (!cpu_online(cpu) || !cpu_isset(cpu, domain));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return cpu_physical_id(cpu);
|
2006-03-27 01:12:19 -07:00
|
|
|
#else /* CONFIG_SMP */
|
2005-04-16 16:20:36 -06:00
|
|
|
return cpu_physical_id(smp_processor_id());
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-11-06 23:38:30 -07:00
|
|
|
static inline unsigned char choose_dmode(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
if (smp_int_redirect & SMP_IRQ_REDIRECTION)
|
|
|
|
return IOSAPIC_LOWEST_PRIORITY;
|
|
|
|
#endif
|
|
|
|
return IOSAPIC_FIXED;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* ACPI can describe IOSAPIC interrupts via static tables and namespace
|
|
|
|
* methods. This provides an interface to register those interrupts and
|
|
|
|
* program the IOSAPIC RTE.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
iosapic_register_intr (unsigned int gsi,
|
|
|
|
unsigned long polarity, unsigned long trigger)
|
|
|
|
{
|
2007-07-17 06:22:03 -06:00
|
|
|
int irq, mask = 1, err;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int dest;
|
|
|
|
unsigned long flags;
|
2005-04-25 14:26:23 -06:00
|
|
|
struct iosapic_rte_info *rte;
|
|
|
|
u32 low32;
|
2007-11-06 23:38:30 -07:00
|
|
|
unsigned char dmode;
|
2011-03-25 13:16:05 -06:00
|
|
|
struct irq_desc *desc;
|
2007-07-17 06:20:54 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* If this GSI has already been registered (i.e., it's a
|
|
|
|
* shared interrupt, or we lost a race to register it),
|
|
|
|
* don't touch the RTE.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 06:22:03 -06:00
|
|
|
irq = __gsi_to_irq(gsi);
|
|
|
|
if (irq > 0) {
|
|
|
|
rte = find_rte(irq, gsi);
|
2007-07-17 06:22:23 -06:00
|
|
|
if(iosapic_intr_info[irq].count == 0) {
|
|
|
|
assign_irq_vector(irq);
|
|
|
|
dynamic_irq_init(irq);
|
|
|
|
} else if (rte->refcnt != NO_REF_RTE) {
|
|
|
|
rte->refcnt++;
|
|
|
|
goto unlock_iosapic_lock;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
irq = create_irq();
|
2005-04-25 14:26:23 -06:00
|
|
|
|
|
|
|
/* If vector is running out, we try to find a sharable vector */
|
2007-07-17 06:21:48 -06:00
|
|
|
if (irq < 0) {
|
2007-07-17 06:22:03 -06:00
|
|
|
irq = iosapic_find_sharable_irq(trigger, polarity);
|
|
|
|
if (irq < 0)
|
2007-07-17 06:20:54 -06:00
|
|
|
goto unlock_iosapic_lock;
|
2007-07-17 06:22:03 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-25 13:16:05 -06:00
|
|
|
desc = irq_to_desc(irq);
|
|
|
|
raw_spin_lock(&desc->lock);
|
2007-07-17 06:22:03 -06:00
|
|
|
dest = get_target_cpu(gsi, irq);
|
2007-11-06 23:38:30 -07:00
|
|
|
dmode = choose_dmode();
|
|
|
|
err = register_intr(gsi, irq, dmode, polarity, trigger);
|
2007-07-17 06:20:29 -06:00
|
|
|
if (err < 0) {
|
2011-03-25 13:16:05 -06:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2007-07-17 06:22:03 -06:00
|
|
|
irq = err;
|
2007-08-01 06:18:44 -06:00
|
|
|
goto unlock_iosapic_lock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-07-17 06:20:29 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the vector is shared and already unmasked for other
|
|
|
|
* interrupt sources, don't mask it.
|
|
|
|
*/
|
2007-07-17 06:22:03 -06:00
|
|
|
low32 = iosapic_intr_info[irq].low32;
|
|
|
|
if (irq_is_shared(irq) && !(low32 & IOSAPIC_MASK))
|
2007-07-17 06:20:29 -06:00
|
|
|
mask = 0;
|
2007-07-17 06:22:03 -06:00
|
|
|
set_rte(gsi, irq, dest, mask);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
printk(KERN_INFO "GSI %u (%s, %s) -> CPU %d (0x%04x) vector %d\n",
|
|
|
|
gsi, (trigger == IOSAPIC_EDGE ? "edge" : "level"),
|
|
|
|
(polarity == IOSAPIC_POL_HIGH ? "high" : "low"),
|
2007-07-17 06:22:03 -06:00
|
|
|
cpu_logical_id(dest), dest, irq_to_vector(irq));
|
2007-08-01 06:18:44 -06:00
|
|
|
|
2011-03-25 13:16:05 -06:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2007-07-17 06:20:54 -06:00
|
|
|
unlock_iosapic_lock:
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
2007-07-17 06:22:03 -06:00
|
|
|
return irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
iosapic_unregister_intr (unsigned int gsi)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-07-17 06:22:03 -06:00
|
|
|
int irq, index;
|
2005-04-25 14:26:23 -06:00
|
|
|
u32 low32;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long trigger, polarity;
|
2005-04-25 14:26:23 -06:00
|
|
|
unsigned int dest;
|
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the irq associated with the gsi is not found,
|
|
|
|
* iosapic_unregister_intr() is unbalanced. We need to check
|
|
|
|
* this again after getting locks.
|
|
|
|
*/
|
|
|
|
irq = gsi_to_irq(gsi);
|
|
|
|
if (irq < 0) {
|
2006-03-27 01:12:19 -07:00
|
|
|
printk(KERN_ERR "iosapic_unregister_intr(%u) unbalanced\n",
|
|
|
|
gsi);
|
2005-04-16 16:20:36 -06:00
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-07-17 06:20:54 -06:00
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 06:22:03 -06:00
|
|
|
if ((rte = find_rte(irq, gsi)) == NULL) {
|
2007-07-17 06:20:29 -06:00
|
|
|
printk(KERN_ERR "iosapic_unregister_intr(%u) unbalanced\n",
|
|
|
|
gsi);
|
|
|
|
WARN_ON(1);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:20:29 -06:00
|
|
|
if (--rte->refcnt > 0)
|
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:22:23 -06:00
|
|
|
rte->refcnt = NO_REF_RTE;
|
2007-07-17 06:20:54 -06:00
|
|
|
|
2007-07-17 06:20:29 -06:00
|
|
|
/* Mask the interrupt */
|
2007-07-17 06:22:03 -06:00
|
|
|
low32 = iosapic_intr_info[irq].low32 | IOSAPIC_MASK;
|
2007-07-17 06:21:26 -06:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte->rte_index), low32);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_intr_info[irq].count--;
|
2007-07-17 06:20:29 -06:00
|
|
|
index = find_iosapic(gsi);
|
|
|
|
iosapic_lists[index].rtes_inuse--;
|
|
|
|
WARN_ON(iosapic_lists[index].rtes_inuse < 0);
|
2005-04-25 14:26:23 -06:00
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
trigger = iosapic_intr_info[irq].trigger;
|
|
|
|
polarity = iosapic_intr_info[irq].polarity;
|
|
|
|
dest = iosapic_intr_info[irq].dest;
|
2007-07-17 06:20:29 -06:00
|
|
|
printk(KERN_INFO
|
|
|
|
"GSI %u (%s, %s) -> CPU %d (0x%04x) vector %d unregistered\n",
|
|
|
|
gsi, (trigger == IOSAPIC_EDGE ? "edge" : "level"),
|
|
|
|
(polarity == IOSAPIC_POL_HIGH ? "high" : "low"),
|
2007-07-17 06:22:03 -06:00
|
|
|
cpu_logical_id(dest), dest, irq_to_vector(irq));
|
2005-04-25 14:26:23 -06:00
|
|
|
|
2007-07-17 06:22:23 -06:00
|
|
|
if (iosapic_intr_info[irq].count == 0) {
|
2007-01-24 22:48:04 -07:00
|
|
|
#ifdef CONFIG_SMP
|
2007-07-17 06:20:29 -06:00
|
|
|
/* Clear affinity */
|
2011-03-25 13:16:05 -06:00
|
|
|
cpumask_setall(irq_get_irq_data(irq)->affinity);
|
2007-01-24 22:48:04 -07:00
|
|
|
#endif
|
2007-07-17 06:20:29 -06:00
|
|
|
/* Clear the interrupt information */
|
2007-07-17 06:22:23 -06:00
|
|
|
iosapic_intr_info[irq].dest = 0;
|
|
|
|
iosapic_intr_info[irq].dmode = 0;
|
|
|
|
iosapic_intr_info[irq].polarity = 0;
|
|
|
|
iosapic_intr_info[irq].trigger = 0;
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_intr_info[irq].low32 |= IOSAPIC_MASK;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:22:23 -06:00
|
|
|
/* Destroy and reserve IRQ */
|
|
|
|
destroy_and_reserve_irq(irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-04-25 14:26:23 -06:00
|
|
|
out:
|
2007-07-17 06:20:54 -06:00
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ACPI calls this when it finds an entry for a platform interrupt.
|
|
|
|
*/
|
|
|
|
int __init
|
|
|
|
iosapic_register_platform_intr (u32 int_type, unsigned int gsi,
|
|
|
|
int iosapic_vector, u16 eid, u16 id,
|
|
|
|
unsigned long polarity, unsigned long trigger)
|
|
|
|
{
|
|
|
|
static const char * const name[] = {"unknown", "PMI", "INIT", "CPEI"};
|
|
|
|
unsigned char delivery;
|
2007-07-17 06:21:48 -06:00
|
|
|
int irq, vector, mask = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int dest = ((id << 8) | eid) & 0xffff;
|
|
|
|
|
|
|
|
switch (int_type) {
|
|
|
|
case ACPI_INTERRUPT_PMI:
|
2007-07-17 06:22:23 -06:00
|
|
|
irq = vector = iosapic_vector;
|
2007-07-17 06:22:33 -06:00
|
|
|
bind_irq_vector(irq, vector, CPU_MASK_ALL);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* since PMI vector is alloc'd by FW(ACPI) not by kernel,
|
|
|
|
* we need to make sure the vector is available
|
|
|
|
*/
|
2007-07-17 06:22:03 -06:00
|
|
|
iosapic_reassign_vector(irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
delivery = IOSAPIC_PMI;
|
|
|
|
break;
|
|
|
|
case ACPI_INTERRUPT_INIT:
|
2007-07-17 06:21:48 -06:00
|
|
|
irq = create_irq();
|
|
|
|
if (irq < 0)
|
2008-03-04 16:15:00 -07:00
|
|
|
panic("%s: out of interrupt vectors!\n", __func__);
|
2007-07-17 06:21:48 -06:00
|
|
|
vector = irq_to_vector(irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
delivery = IOSAPIC_INIT;
|
|
|
|
break;
|
|
|
|
case ACPI_INTERRUPT_CPEI:
|
2007-07-17 06:22:23 -06:00
|
|
|
irq = vector = IA64_CPE_VECTOR;
|
2007-07-17 06:22:33 -06:00
|
|
|
BUG_ON(bind_irq_vector(irq, vector, CPU_MASK_ALL));
|
2007-11-08 18:51:01 -07:00
|
|
|
delivery = IOSAPIC_FIXED;
|
2005-04-16 16:20:36 -06:00
|
|
|
mask = 1;
|
|
|
|
break;
|
|
|
|
default:
|
2008-03-04 16:15:00 -07:00
|
|
|
printk(KERN_ERR "%s: invalid int type 0x%x\n", __func__,
|
2006-03-27 01:12:19 -07:00
|
|
|
int_type);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
register_intr(gsi, irq, delivery, polarity, trigger);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-03-27 01:12:19 -07:00
|
|
|
printk(KERN_INFO
|
|
|
|
"PLATFORM int %s (0x%x): GSI %u (%s, %s) -> CPU %d (0x%04x)"
|
|
|
|
" vector %d\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
int_type < ARRAY_SIZE(name) ? name[int_type] : "unknown",
|
|
|
|
int_type, gsi, (trigger == IOSAPIC_EDGE ? "edge" : "level"),
|
|
|
|
(polarity == IOSAPIC_POL_HIGH ? "high" : "low"),
|
|
|
|
cpu_logical_id(dest), dest, vector);
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
set_rte(gsi, irq, dest, mask);
|
2005-04-16 16:20:36 -06:00
|
|
|
return vector;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ACPI calls this when it finds an entry for a legacy ISA IRQ override.
|
|
|
|
*/
|
2007-05-07 14:17:00 -06:00
|
|
|
void __devinit
|
2005-04-16 16:20:36 -06:00
|
|
|
iosapic_override_isa_irq (unsigned int isa_irq, unsigned int gsi,
|
|
|
|
unsigned long polarity,
|
|
|
|
unsigned long trigger)
|
|
|
|
{
|
2007-07-17 06:22:03 -06:00
|
|
|
int vector, irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int dest = cpu_physical_id(smp_processor_id());
|
2007-11-06 23:38:30 -07:00
|
|
|
unsigned char dmode;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:22:23 -06:00
|
|
|
irq = vector = isa_irq_to_vector(isa_irq);
|
2007-07-17 06:22:33 -06:00
|
|
|
BUG_ON(bind_irq_vector(irq, vector, CPU_MASK_ALL));
|
2007-11-06 23:38:30 -07:00
|
|
|
dmode = choose_dmode();
|
|
|
|
register_intr(gsi, irq, dmode, polarity, trigger);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
DBG("ISA: IRQ %u -> GSI %u (%s,%s) -> CPU %d (0x%04x) vector %d\n",
|
|
|
|
isa_irq, gsi, trigger == IOSAPIC_EDGE ? "edge" : "level",
|
|
|
|
polarity == IOSAPIC_POL_HIGH ? "high" : "low",
|
|
|
|
cpu_logical_id(dest), dest, vector);
|
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
set_rte(gsi, irq, dest, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-05-19 07:13:42 -06:00
|
|
|
void __init
|
|
|
|
ia64_native_iosapic_pcat_compat_init(void)
|
|
|
|
{
|
|
|
|
if (pcat_compat) {
|
|
|
|
/*
|
|
|
|
* Disable the compatibility mode interrupts (8259 style),
|
|
|
|
* needs IN/OUT support enabled.
|
|
|
|
*/
|
|
|
|
printk(KERN_INFO
|
|
|
|
"%s: Disabling PC-AT compatible 8259 interrupts\n",
|
|
|
|
__func__);
|
|
|
|
outb(0xff, 0xA1);
|
|
|
|
outb(0xff, 0x21);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void __init
|
|
|
|
iosapic_system_init (int system_pcat_compat)
|
|
|
|
{
|
2007-07-17 06:22:03 -06:00
|
|
|
int irq;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:22:03 -06:00
|
|
|
for (irq = 0; irq < NR_IRQS; ++irq) {
|
|
|
|
iosapic_intr_info[irq].low32 = IOSAPIC_MASK;
|
2006-03-27 01:12:19 -07:00
|
|
|
/* mark as unused */
|
2007-07-17 06:22:03 -06:00
|
|
|
INIT_LIST_HEAD(&iosapic_intr_info[irq].rtes);
|
2007-07-17 06:22:23 -06:00
|
|
|
|
|
|
|
iosapic_intr_info[irq].count = 0;
|
2005-04-25 14:26:23 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
pcat_compat = system_pcat_compat;
|
2008-05-19 07:13:42 -06:00
|
|
|
if (pcat_compat)
|
|
|
|
iosapic_pcat_compat_init();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-04-28 01:25:58 -06:00
|
|
|
static inline int
|
|
|
|
iosapic_alloc (void)
|
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
|
|
|
for (index = 0; index < NR_IOSAPICS; index++)
|
|
|
|
if (!iosapic_lists[index].addr)
|
|
|
|
return index;
|
|
|
|
|
2008-03-04 16:15:00 -07:00
|
|
|
printk(KERN_WARNING "%s: failed to allocate iosapic\n", __func__);
|
2005-04-28 01:25:58 -06:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
iosapic_free (int index)
|
|
|
|
{
|
|
|
|
memset(&iosapic_lists[index], 0, sizeof(iosapic_lists[0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
iosapic_check_gsi_range (unsigned int gsi_base, unsigned int ver)
|
|
|
|
{
|
|
|
|
int index;
|
|
|
|
unsigned int gsi_end, base, end;
|
|
|
|
|
|
|
|
/* check gsi range */
|
|
|
|
gsi_end = gsi_base + ((ver >> 16) & 0xff);
|
|
|
|
for (index = 0; index < NR_IOSAPICS; index++) {
|
|
|
|
if (!iosapic_lists[index].addr)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
base = iosapic_lists[index].gsi_base;
|
|
|
|
end = base + iosapic_lists[index].num_rte - 1;
|
|
|
|
|
2006-03-27 01:13:46 -07:00
|
|
|
if (gsi_end < base || end < gsi_base)
|
2005-04-28 01:25:58 -06:00
|
|
|
continue; /* OK */
|
|
|
|
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int __devinit
|
2005-04-16 16:20:36 -06:00
|
|
|
iosapic_init (unsigned long phys_addr, unsigned int gsi_base)
|
|
|
|
{
|
2005-04-28 01:25:58 -06:00
|
|
|
int num_rte, err, index;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int isa_irq, ver;
|
|
|
|
char __iomem *addr;
|
2005-04-28 01:25:58 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 06:21:26 -06:00
|
|
|
index = find_iosapic(gsi_base);
|
|
|
|
if (index >= 0) {
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2007-07-17 06:20:29 -06:00
|
|
|
addr = ioremap(phys_addr, 0);
|
2009-08-11 15:52:11 -06:00
|
|
|
if (addr == NULL) {
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2007-07-17 06:20:29 -06:00
|
|
|
ver = iosapic_version(addr);
|
|
|
|
if ((err = iosapic_check_gsi_range(gsi_base, ver))) {
|
|
|
|
iounmap(addr);
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return err;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:20:29 -06:00
|
|
|
/*
|
|
|
|
* The MAX_REDIR register holds the highest input pin number
|
|
|
|
* (starting from 0). We add 1 so that we can use it for
|
|
|
|
* number of pins (= RTEs)
|
|
|
|
*/
|
|
|
|
num_rte = ((ver >> 16) & 0xff) + 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 06:20:29 -06:00
|
|
|
index = iosapic_alloc();
|
|
|
|
iosapic_lists[index].addr = addr;
|
|
|
|
iosapic_lists[index].gsi_base = gsi_base;
|
|
|
|
iosapic_lists[index].num_rte = num_rte;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_NUMA
|
2007-07-17 06:20:29 -06:00
|
|
|
iosapic_lists[index].node = MAX_NUMNODES;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-07-17 06:21:26 -06:00
|
|
|
spin_lock_init(&iosapic_lists[index].lock);
|
2005-04-28 01:25:58 -06:00
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if ((gsi_base == 0) && pcat_compat) {
|
|
|
|
/*
|
2006-03-27 01:12:19 -07:00
|
|
|
* Map the legacy ISA devices into the IOSAPIC data. Some of
|
|
|
|
* these may get reprogrammed later on with data from the ACPI
|
|
|
|
* Interrupt Source Override table.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
for (isa_irq = 0; isa_irq < 16; ++isa_irq)
|
2006-03-27 01:12:19 -07:00
|
|
|
iosapic_override_isa_irq(isa_irq, isa_irq,
|
|
|
|
IOSAPIC_POL_HIGH,
|
|
|
|
IOSAPIC_EDGE);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-04-28 01:25:58 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG
|
|
|
|
int
|
|
|
|
iosapic_remove (unsigned int gsi_base)
|
|
|
|
{
|
|
|
|
int index, err = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 06:20:29 -06:00
|
|
|
index = find_iosapic(gsi_base);
|
|
|
|
if (index < 0) {
|
|
|
|
printk(KERN_WARNING "%s: No IOSAPIC for GSI base %u\n",
|
2008-03-04 16:15:00 -07:00
|
|
|
__func__, gsi_base);
|
2007-07-17 06:20:29 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-28 01:25:58 -06:00
|
|
|
|
2007-07-17 06:20:29 -06:00
|
|
|
if (iosapic_lists[index].rtes_inuse) {
|
|
|
|
err = -EBUSY;
|
|
|
|
printk(KERN_WARNING "%s: IOSAPIC for GSI base %u is busy\n",
|
2008-03-04 16:15:00 -07:00
|
|
|
__func__, gsi_base);
|
2007-07-17 06:20:29 -06:00
|
|
|
goto out;
|
2005-04-28 01:25:58 -06:00
|
|
|
}
|
2007-07-17 06:20:29 -06:00
|
|
|
|
|
|
|
iounmap(iosapic_lists[index].addr);
|
|
|
|
iosapic_free(index);
|
2005-04-28 01:25:58 -06:00
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2005-04-28 01:25:58 -06:00
|
|
|
#endif /* CONFIG_HOTPLUG */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_NUMA
|
2005-04-28 01:25:58 -06:00
|
|
|
void __devinit
|
2005-04-16 16:20:36 -06:00
|
|
|
map_iosapic_to_node(unsigned int gsi_base, int node)
|
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
|
|
|
index = find_iosapic(gsi_base);
|
|
|
|
if (index < 0) {
|
|
|
|
printk(KERN_WARNING "%s: No IOSAPIC for GSI %u\n",
|
2008-03-04 16:15:00 -07:00
|
|
|
__func__, gsi_base);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
iosapic_lists[index].node = node;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|