License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 17:07:57 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-17 02:20:36 +04: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 12:12:19 +04: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-17 02:20:36 +04:00
|
|
|
* 02/01/23 J.I. Lee iosapic pgm fixes for PCI irq routing from _PRT
|
2006-03-27 12:12:19 +04: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-17 02:20:36 +04: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 12:12:19 +04:00
|
|
|
* 02/04/30 J.I. Lee bug fix in find_iosapic to fix ACPI PCI IRQ to
|
|
|
|
* IOSAPIC mapping error
|
2005-04-17 02:20:36 +04:00
|
|
|
* 02/07/29 T. Kochi Allocate interrupt vectors dynamically
|
2006-03-27 12:12:19 +04: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-17 02:20:36 +04:00
|
|
|
* 03/02/19 B. Helgaas Make pcat_compat system-wide, not per-IOSAPIC.
|
2006-03-27 12:12:19 +04:00
|
|
|
* Remove iosapic_address & gsi_base from
|
|
|
|
* external interfaces. Rationalize
|
|
|
|
* __init/__devinit attributes.
|
2005-04-17 02:20:36 +04:00
|
|
|
* 04/12/04 Ashok Raj <ashok.raj@intel.com> Intel Corporation 2004
|
2006-03-27 12:12:19 +04:00
|
|
|
* Updated to work with irq migration necessary
|
|
|
|
* for CPU Hotplug
|
2005-04-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
/*
|
2006-03-27 12:12:19 +04:00
|
|
|
* Here is what the interrupt logic between a PCI device and the kernel looks
|
|
|
|
* like:
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
2006-03-27 12:12:19 +04: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-17 02:20:36 +04:00
|
|
|
*
|
2006-03-27 12:12:19 +04: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-17 02:20:36 +04:00
|
|
|
*
|
2006-03-27 12:12:19 +04: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-17 02:20:36 +04:00
|
|
|
*
|
2006-03-27 12:12:19 +04: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-17 02:20:36 +04:00
|
|
|
* platform_local_vector_to_irq(vector) APIs to differentiate the mapping.
|
2008-08-01 21:13:32 +04:00
|
|
|
* Please see also arch/ia64/include/asm/hw_irq.h for those APIs.
|
2005-04-17 02:20:36 +04:00
|
|
|
*
|
|
|
|
* To sum up, there are three levels of mappings involved:
|
|
|
|
*
|
|
|
|
* PCI pin -> global system interrupt (GSI) -> IA-64 vector <-> IRQ
|
|
|
|
*
|
2006-03-27 12:12:19 +04:00
|
|
|
* Note: The term "IRQ" is loosely used everywhere in Linux kernel to
|
2013-03-08 08:32:52 +04:00
|
|
|
* describe interrupts. Now we use "IRQ" only for Linux IRQ's. ISA IRQ
|
2006-03-27 12:12:19 +04:00
|
|
|
* (isa_irq) is the only exception in this source code.
|
2005-04-17 02:20:36 +04: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 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 02:20:36 +04:00
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/string.h>
|
2018-10-31 01:09:49 +03:00
|
|
|
#include <linux/memblock.h>
|
2005-04-17 02:20:36 +04: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 12:12:19 +04:00
|
|
|
/*
|
|
|
|
* These tables map IA-64 vectors to the IOSAPIC pin that generates this
|
|
|
|
* vector.
|
|
|
|
*/
|
2007-07-17 16:22:23 +04:00
|
|
|
|
|
|
|
#define NO_REF_RTE 0
|
|
|
|
|
2007-07-17 16:20:42 +04: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 16:21:26 +04:00
|
|
|
spinlock_t lock; /* lock for indirect reg access */
|
2007-07-17 16:20:42 +04:00
|
|
|
} iosapic_lists[NR_IOSAPICS];
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info {
|
2007-07-17 16:20:42 +04:00
|
|
|
struct list_head rte_list; /* RTEs sharing the same vector */
|
2005-04-26 00:26:23 +04:00
|
|
|
char rte_index; /* IOSAPIC RTE index */
|
|
|
|
int refcnt; /* reference counter */
|
2007-07-17 16:20:42 +04:00
|
|
|
struct iosapic *iosapic;
|
2005-04-26 00:26:23 +04:00
|
|
|
} ____cacheline_aligned;
|
|
|
|
|
|
|
|
static struct iosapic_intr_info {
|
2006-03-27 12:12:19 +04:00
|
|
|
struct list_head rtes; /* RTEs using this vector (empty =>
|
|
|
|
* not an IOSAPIC interrupt) */
|
2007-07-30 06:54:41 +04:00
|
|
|
int count; /* # of registered RTEs */
|
2006-03-27 12:12:19 +04:00
|
|
|
u32 low32; /* current value of low word of
|
|
|
|
* Redirection table entry */
|
2005-04-26 00:26:23 +04:00
|
|
|
unsigned int dest; /* destination CPU physical ID */
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned char dmode : 3; /* delivery mode (see iosapic.h) */
|
2006-03-27 12:12:19 +04:00
|
|
|
unsigned char polarity: 1; /* interrupt polarity
|
|
|
|
* (see iosapic.h) */
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned char trigger : 1; /* trigger mode (see iosapic.h) */
|
2007-07-17 16:22:03 +04:00
|
|
|
} iosapic_intr_info[NR_IRQS];
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2012-12-22 02:05:13 +04:00
|
|
|
static unsigned char pcat_compat; /* 8259 compatibility flag */
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:21:26 +04: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-17 02:20:36 +04:00
|
|
|
/*
|
|
|
|
* Find an IOSAPIC associated with a GSI
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
find_iosapic (unsigned int gsi)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2005-04-28 11:25:58 +04:00
|
|
|
for (i = 0; i < NR_IOSAPICS; i++) {
|
2006-03-27 12:12:19 +04:00
|
|
|
if ((unsigned) (gsi - iosapic_lists[i].gsi_base) <
|
|
|
|
iosapic_lists[i].num_rte)
|
2005-04-17 02:20:36 +04:00
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
static inline int __gsi_to_irq(unsigned int gsi)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2007-07-17 16:22:03 +04:00
|
|
|
int irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
struct iosapic_intr_info *info;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
for (irq = 0; irq < NR_IRQS; irq++) {
|
|
|
|
info = &iosapic_intr_info[irq];
|
2005-04-26 00:26:23 +04:00
|
|
|
list_for_each_entry(rte, &info->rtes, rte_list)
|
2007-07-17 16:20:42 +04:00
|
|
|
if (rte->iosapic->gsi_base + rte->rte_index == gsi)
|
2007-07-17 16:22:03 +04:00
|
|
|
return irq;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
gsi_to_irq (unsigned int gsi)
|
|
|
|
{
|
2005-04-26 00:26:23 +04:00
|
|
|
unsigned long flags;
|
|
|
|
int irq;
|
2007-07-17 16:22:03 +04:00
|
|
|
|
2005-04-26 00:26:23 +04:00
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 16:22:03 +04:00
|
|
|
irq = __gsi_to_irq(gsi);
|
2005-04-26 00:26:23 +04:00
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return irq;
|
|
|
|
}
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
static struct iosapic_rte_info *find_rte(unsigned int irq, unsigned int gsi)
|
2005-04-26 00:26:23 +04:00
|
|
|
{
|
|
|
|
struct iosapic_rte_info *rte;
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list)
|
2007-07-17 16:20:42 +04:00
|
|
|
if (rte->iosapic->gsi_base + rte->rte_index == gsi)
|
2005-04-26 00:26:23 +04:00
|
|
|
return rte;
|
|
|
|
return NULL;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-07-17 16:22:03 +04:00
|
|
|
set_rte (unsigned int gsi, unsigned int irq, unsigned int dest, int mask)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
unsigned long pol, trigger, dmode;
|
|
|
|
u32 low32, high32;
|
|
|
|
int rte_index;
|
|
|
|
char redir;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 16:22:03 +04:00
|
|
|
ia64_vector vector = irq_to_vector(irq);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
DBG(KERN_DEBUG"IOSAPIC: routing vector %d to 0x%x\n", vector, dest);
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
rte = find_rte(irq, gsi);
|
2005-04-26 00:26:23 +04:00
|
|
|
if (!rte)
|
2005-04-17 02:20:36 +04:00
|
|
|
return; /* not an IOSAPIC interrupt */
|
|
|
|
|
2005-04-26 00:26:23 +04:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 16:22:03 +04:00
|
|
|
pol = iosapic_intr_info[irq].polarity;
|
|
|
|
trigger = iosapic_intr_info[irq].trigger;
|
|
|
|
dmode = iosapic_intr_info[irq].dmode;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
redir = (dmode == IOSAPIC_LOWEST_PRIORITY) ? 1 : 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2007-07-17 16:22:03 +04:00
|
|
|
set_irq_affinity_info(irq, (int)(dest & 0xffff), redir);
|
2005-04-17 02:20:36 +04: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 16:21:26 +04:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_HIGH(rte_index), high32);
|
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2007-07-17 16:22:03 +04:00
|
|
|
iosapic_intr_info[irq].low32 = low32;
|
|
|
|
iosapic_intr_info[irq].dest = dest;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2015-12-28 14:58:06 +03:00
|
|
|
iosapic_nop (struct irq_data *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
/* do nothing... */
|
|
|
|
}
|
|
|
|
|
2006-12-07 20:51:35 +03:00
|
|
|
|
|
|
|
#ifdef CONFIG_KEXEC
|
|
|
|
void
|
|
|
|
kexec_disable_iosapic(void)
|
|
|
|
{
|
|
|
|
struct iosapic_intr_info *info;
|
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 16:22:03 +04: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 20:51:35 +03:00
|
|
|
list_for_each_entry(rte, &info->rtes,
|
|
|
|
rte_list) {
|
2007-07-17 16:21:26 +04:00
|
|
|
iosapic_write(rte->iosapic,
|
2006-12-07 20:51:35 +03:00
|
|
|
IOSAPIC_RTE_LOW(rte->rte_index),
|
|
|
|
IOSAPIC_MASK|vec);
|
2007-07-17 16:20:42 +04:00
|
|
|
iosapic_eoi(rte->iosapic->addr, vec);
|
2006-12-07 20:51:35 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
static void
|
2011-02-04 22:31:21 +03:00
|
|
|
mask_irq (struct irq_data *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-02-04 22:31:21 +03:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
u32 low32;
|
|
|
|
int rte_index;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-30 06:54:41 +04:00
|
|
|
if (!iosapic_intr_info[irq].count)
|
2005-04-17 02:20:36 +04:00
|
|
|
return; /* not an IOSAPIC interrupt! */
|
|
|
|
|
2007-07-17 16:20:29 +04:00
|
|
|
/* set only the mask bit */
|
2007-07-17 16:22:03 +04:00
|
|
|
low32 = iosapic_intr_info[irq].low32 |= IOSAPIC_MASK;
|
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list) {
|
2007-07-17 16:20:29 +04:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 16:21:26 +04:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-04 22:31:21 +03:00
|
|
|
unmask_irq (struct irq_data *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-02-04 22:31:21 +03:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
u32 low32;
|
|
|
|
int rte_index;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-30 06:54:41 +04:00
|
|
|
if (!iosapic_intr_info[irq].count)
|
2005-04-17 02:20:36 +04:00
|
|
|
return; /* not an IOSAPIC interrupt! */
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
low32 = iosapic_intr_info[irq].low32 &= ~IOSAPIC_MASK;
|
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list) {
|
2007-07-17 16:20:29 +04:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 16:21:26 +04:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-04-28 04:59:21 +04:00
|
|
|
static int
|
2011-02-04 22:31:21 +03:00
|
|
|
iosapic_set_affinity(struct irq_data *data, const struct cpumask *mask,
|
|
|
|
bool force)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
2011-02-04 22:31:21 +03:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
u32 high32, low32;
|
2008-12-13 13:50:26 +03:00
|
|
|
int cpu, dest, rte_index;
|
2005-04-17 02:20:36 +04:00
|
|
|
int redir = (irq & IA64_IRQ_REDIRECTED) ? 1 : 0;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 16:21:26 +04:00
|
|
|
struct iosapic *iosapic;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
irq &= (~IA64_IRQ_REDIRECTED);
|
|
|
|
|
2008-12-13 13:50:26 +03:00
|
|
|
cpu = cpumask_first_and(cpu_online_mask, mask);
|
|
|
|
if (cpu >= nr_cpu_ids)
|
2009-04-28 04:59:21 +04:00
|
|
|
return -1;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-12-13 13:50:26 +03:00
|
|
|
if (irq_prepare_move(irq, cpu))
|
2009-04-28 04:59:21 +04:00
|
|
|
return -1;
|
2007-07-17 16:22:48 +04:00
|
|
|
|
2008-12-13 13:50:26 +03:00
|
|
|
dest = cpu_physical_id(cpu);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-30 06:54:41 +04:00
|
|
|
if (!iosapic_intr_info[irq].count)
|
2009-04-28 04:59:21 +04:00
|
|
|
return -1; /* not an IOSAPIC interrupt */
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
set_irq_affinity_info(irq, dest, redir);
|
|
|
|
|
|
|
|
/* dest contains both id and eid */
|
|
|
|
high32 = dest << IOSAPIC_DEST_SHIFT;
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
low32 = iosapic_intr_info[irq].low32 & ~(7 << IOSAPIC_DELIVERY_SHIFT);
|
2007-07-17 16:20:29 +04: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 16:22:48 +04:00
|
|
|
low32 &= IOSAPIC_VECTOR_MASK;
|
|
|
|
low32 |= irq_to_vector(irq);
|
2007-07-17 16:20:29 +04:00
|
|
|
|
2007-07-17 16:22:03 +04: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 16:21:26 +04:00
|
|
|
iosapic = rte->iosapic;
|
2007-07-17 16:20:29 +04:00
|
|
|
rte_index = rte->rte_index;
|
2007-07-17 16:21:26 +04:00
|
|
|
iosapic_write(iosapic, IOSAPIC_RTE_HIGH(rte_index), high32);
|
|
|
|
iosapic_write(iosapic, IOSAPIC_RTE_LOW(rte_index), low32);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2009-04-28 04:59:21 +04:00
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif
|
2009-04-28 04:59:21 +04:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handlers for level-triggered interrupts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int
|
2011-02-04 22:31:21 +03:00
|
|
|
iosapic_startup_level_irq (struct irq_data *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-02-04 22:31:21 +03:00
|
|
|
unmask_irq(data);
|
2005-04-17 02:20:36 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-04 22:31:21 +03:00
|
|
|
iosapic_unmask_level_irq (struct irq_data *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-02-04 22:31:21 +03:00
|
|
|
unsigned int irq = data->irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
ia64_vector vec = irq_to_vector(irq);
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
2007-07-17 16:22:48 +04:00
|
|
|
int do_unmask_irq = 0;
|
|
|
|
|
2008-02-25 08:32:22 +03:00
|
|
|
irq_complete_move(irq);
|
2011-03-25 22:30:53 +03:00
|
|
|
if (unlikely(irqd_is_setaffinity_pending(data))) {
|
2007-07-17 16:22:48 +04:00
|
|
|
do_unmask_irq = 1;
|
2011-02-04 22:31:21 +03:00
|
|
|
mask_irq(data);
|
2010-09-28 00:58:14 +04:00
|
|
|
} else
|
2011-02-04 22:31:21 +03:00
|
|
|
unmask_irq(data);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
list_for_each_entry(rte, &iosapic_intr_info[irq].rtes, rte_list)
|
2007-07-17 16:20:42 +04:00
|
|
|
iosapic_eoi(rte->iosapic->addr, vec);
|
2007-07-17 16:22:48 +04:00
|
|
|
|
|
|
|
if (unlikely(do_unmask_irq)) {
|
2011-03-25 22:30:53 +03:00
|
|
|
irq_move_masked_irq(data);
|
2011-02-04 22:31:21 +03:00
|
|
|
unmask_irq(data);
|
2007-07-17 16:22:48 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#define iosapic_shutdown_level_irq mask_irq
|
|
|
|
#define iosapic_enable_level_irq unmask_irq
|
|
|
|
#define iosapic_disable_level_irq mask_irq
|
2015-12-28 14:58:06 +03:00
|
|
|
#define iosapic_ack_level_irq iosapic_nop
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-12-08 01:44:05 +03:00
|
|
|
static struct irq_chip irq_type_iosapic_level = {
|
2011-02-04 22:31:21 +03: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-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handlers for edge-triggered interrupts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int
|
2011-02-04 22:31:21 +03:00
|
|
|
iosapic_startup_edge_irq (struct irq_data *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-02-04 22:31:21 +03:00
|
|
|
unmask_irq(data);
|
2005-04-17 02:20:36 +04: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 22:31:21 +03:00
|
|
|
iosapic_ack_edge_irq (struct irq_data *data)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2011-03-25 22:30:53 +03:00
|
|
|
irq_complete_move(data->irq);
|
|
|
|
irq_move_irq(data);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#define iosapic_enable_edge_irq unmask_irq
|
2015-12-28 14:58:06 +03:00
|
|
|
#define iosapic_disable_edge_irq iosapic_nop
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-12-08 01:44:05 +03:00
|
|
|
static struct irq_chip irq_type_iosapic_edge = {
|
2011-02-04 22:31:21 +03: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-17 02:20:36 +04:00
|
|
|
};
|
|
|
|
|
2007-12-08 01:44:05 +03:00
|
|
|
static unsigned int
|
2005-04-17 02:20:36 +04: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 16:21:26 +04:00
|
|
|
return __iosapic_read(addr, IOSAPIC_VERSION);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
static int iosapic_find_sharable_irq(unsigned long trigger, unsigned long pol)
|
2005-04-26 00:26:23 +04:00
|
|
|
{
|
2007-07-17 16:22:03 +04:00
|
|
|
int i, irq = -ENOSPC, min_count = -1;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_intr_info *info;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* shared vectors for edge-triggered interrupts are not
|
|
|
|
* supported yet
|
|
|
|
*/
|
|
|
|
if (trigger == IOSAPIC_EDGE)
|
2007-07-17 16:20:54 +04:00
|
|
|
return -EINVAL;
|
2005-04-26 00:26:23 +04:00
|
|
|
|
2009-02-22 01:40:27 +03:00
|
|
|
for (i = 0; i < NR_IRQS; i++) {
|
2005-04-26 00:26:23 +04:00
|
|
|
info = &iosapic_intr_info[i];
|
|
|
|
if (info->trigger == trigger && info->polarity == pol &&
|
2007-07-17 16:22:14 +04:00
|
|
|
(info->dmode == IOSAPIC_FIXED ||
|
|
|
|
info->dmode == IOSAPIC_LOWEST_PRIORITY) &&
|
|
|
|
can_request_irq(i, IRQF_SHARED)) {
|
2005-04-26 00:26:23 +04:00
|
|
|
if (min_count == -1 || info->count < min_count) {
|
2007-07-17 16:22:03 +04:00
|
|
|
irq = i;
|
2005-04-26 00:26:23 +04:00
|
|
|
min_count = info->count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-07-17 16:22:03 +04:00
|
|
|
return irq;
|
2005-04-26 00:26:23 +04:00
|
|
|
}
|
|
|
|
|
2005-04-17 02:20:36 +04: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 16:22:03 +04:00
|
|
|
iosapic_reassign_vector (int irq)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2007-07-17 16:22:03 +04:00
|
|
|
int new_irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-30 06:54:41 +04:00
|
|
|
if (iosapic_intr_info[irq].count) {
|
2007-07-17 16:22:03 +04:00
|
|
|
new_irq = create_irq();
|
|
|
|
if (new_irq < 0)
|
2008-03-05 02:15:00 +03:00
|
|
|
panic("%s: out of interrupt vectors!\n", __func__);
|
2006-03-27 12:12:19 +04:00
|
|
|
printk(KERN_INFO "Reassigning vector %d to %d\n",
|
2007-07-17 16:22:03 +04:00
|
|
|
irq_to_vector(irq), irq_to_vector(new_irq));
|
|
|
|
memcpy(&iosapic_intr_info[new_irq], &iosapic_intr_info[irq],
|
2005-04-17 02:20:36 +04:00
|
|
|
sizeof(struct iosapic_intr_info));
|
2007-07-17 16:22:03 +04: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 12:12:19 +04:00
|
|
|
sizeof(struct iosapic_intr_info));
|
2007-07-17 16:22:03 +04:00
|
|
|
iosapic_intr_info[irq].low32 = IOSAPIC_MASK;
|
|
|
|
INIT_LIST_HEAD(&iosapic_intr_info[irq].rtes);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
static inline int irq_is_shared (int irq)
|
2005-04-26 00:26:23 +04:00
|
|
|
{
|
2007-07-17 16:22:03 +04:00
|
|
|
return (iosapic_intr_info[irq].count > 1);
|
2005-04-26 00:26:23 +04:00
|
|
|
}
|
|
|
|
|
2008-05-19 17:13:42 +04: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 22:42:00 +04:00
|
|
|
static int
|
2007-07-17 16:22:03 +04:00
|
|
|
register_intr (unsigned int gsi, int irq, unsigned char delivery,
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned long polarity, unsigned long trigger)
|
|
|
|
{
|
2011-03-25 22:16:05 +03:00
|
|
|
struct irq_chip *chip, *irq_type;
|
2005-04-17 02:20:36 +04:00
|
|
|
int index;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
index = find_iosapic(gsi);
|
|
|
|
if (index < 0) {
|
2006-03-27 12:12:19 +04:00
|
|
|
printk(KERN_WARNING "%s: No IOSAPIC for GSI %u\n",
|
2008-03-05 02:15:00 +03:00
|
|
|
__func__, gsi);
|
2005-07-28 22:42:00 +04:00
|
|
|
return -ENODEV;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
rte = find_rte(irq, gsi);
|
2005-04-26 00:26:23 +04:00
|
|
|
if (!rte) {
|
2010-10-06 02:41:25 +04:00
|
|
|
rte = kzalloc(sizeof (*rte), GFP_ATOMIC);
|
2005-04-26 00:26:23 +04:00
|
|
|
if (!rte) {
|
2006-03-27 12:12:19 +04:00
|
|
|
printk(KERN_WARNING "%s: cannot allocate memory\n",
|
2008-03-05 02:15:00 +03:00
|
|
|
__func__);
|
2005-07-28 22:42:00 +04:00
|
|
|
return -ENOMEM;
|
2005-04-26 00:26:23 +04:00
|
|
|
}
|
|
|
|
|
2007-07-17 16:20:42 +04:00
|
|
|
rte->iosapic = &iosapic_lists[index];
|
|
|
|
rte->rte_index = gsi - rte->iosapic->gsi_base;
|
2005-04-26 00:26:23 +04:00
|
|
|
rte->refcnt++;
|
2007-07-17 16:22:03 +04:00
|
|
|
list_add_tail(&rte->rte_list, &iosapic_intr_info[irq].rtes);
|
|
|
|
iosapic_intr_info[irq].count++;
|
2005-04-28 11:25:58 +04:00
|
|
|
iosapic_lists[index].rtes_inuse++;
|
2005-04-26 00:26:23 +04:00
|
|
|
}
|
2007-07-17 16:22:23 +04:00
|
|
|
else if (rte->refcnt == NO_REF_RTE) {
|
2007-07-17 16:22:03 +04:00
|
|
|
struct iosapic_intr_info *info = &iosapic_intr_info[irq];
|
2007-07-17 16:22:23 +04:00
|
|
|
if (info->count > 0 &&
|
|
|
|
(info->trigger != trigger || info->polarity != polarity)){
|
2006-03-27 12:12:19 +04:00
|
|
|
printk (KERN_WARNING
|
|
|
|
"%s: cannot override the interrupt\n",
|
2008-03-05 02:15:00 +03:00
|
|
|
__func__);
|
2005-07-28 22:42:00 +04:00
|
|
|
return -EINVAL;
|
2005-04-26 00:26:23 +04:00
|
|
|
}
|
2007-07-17 16:22:23 +04:00
|
|
|
rte->refcnt++;
|
|
|
|
iosapic_intr_info[irq].count++;
|
|
|
|
iosapic_lists[index].rtes_inuse++;
|
2005-04-26 00:26:23 +04:00
|
|
|
}
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
iosapic_intr_info[irq].polarity = polarity;
|
|
|
|
iosapic_intr_info[irq].dmode = delivery;
|
|
|
|
iosapic_intr_info[irq].trigger = trigger;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-05-19 17:13:42 +04:00
|
|
|
irq_type = iosapic_get_irq_chip(trigger);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-03-25 22:16:05 +03:00
|
|
|
chip = irq_get_chip(irq);
|
|
|
|
if (irq_type != NULL && chip != irq_type) {
|
|
|
|
if (chip != &no_irq_chip)
|
2006-03-27 12:12:19 +04:00
|
|
|
printk(KERN_WARNING
|
|
|
|
"%s: changing vector %d from %s to %s\n",
|
2008-03-05 02:15:00 +03:00
|
|
|
__func__, irq_to_vector(irq),
|
2011-03-25 22:16:05 +03:00
|
|
|
chip->name, irq_type->name);
|
|
|
|
chip = irq_type;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2015-07-13 23:42:48 +03:00
|
|
|
irq_set_chip_handler_name_locked(irq_get_irq_data(irq), chip,
|
|
|
|
trigger == IOSAPIC_EDGE ? handle_edge_irq : handle_level_irq,
|
|
|
|
NULL);
|
2005-07-28 22:42:00 +04:00
|
|
|
return 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int
|
2007-07-17 16:22:03 +04:00
|
|
|
get_target_cpu (unsigned int gsi, int irq)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static int cpu = -1;
|
2005-11-12 01:32:40 +03:00
|
|
|
extern int cpe_vector;
|
2007-07-17 16:22:33 +04:00
|
|
|
cpumask_t domain = irq_to_domain(irq);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2005-04-26 00:26:23 +04:00
|
|
|
/*
|
|
|
|
* In case of vector shared by multiple RTEs, all RTEs that
|
|
|
|
* share the vector need to use the same destination CPU.
|
|
|
|
*/
|
2007-07-30 06:54:41 +04:00
|
|
|
if (iosapic_intr_info[irq].count)
|
2007-07-17 16:22:03 +04:00
|
|
|
return iosapic_intr_info[irq].dest;
|
2005-04-26 00:26:23 +04:00
|
|
|
|
2005-04-17 02:20:36 +04: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-12 01:32:40 +03:00
|
|
|
#ifdef CONFIG_ACPI
|
2007-07-17 16:22:03 +04:00
|
|
|
if (cpe_vector > 0 && irq_to_vector(irq) == IA64_CPEP_VECTOR)
|
2006-01-20 03:18:47 +03:00
|
|
|
return get_cpei_target_cpu();
|
2005-11-12 01:32:40 +03:00
|
|
|
#endif
|
|
|
|
|
2005-04-17 02:20:36 +04:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
{
|
|
|
|
int num_cpus, cpu_index, iosapic_index, numa_cpu, i = 0;
|
2008-12-26 14:53:40 +03:00
|
|
|
const struct cpumask *cpu_mask;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
iosapic_index = find_iosapic(gsi);
|
|
|
|
if (iosapic_index < 0 ||
|
|
|
|
iosapic_lists[iosapic_index].node == MAX_NUMNODES)
|
|
|
|
goto skip_numa_setup;
|
|
|
|
|
2008-12-26 14:53:40 +03: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-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!num_cpus)
|
|
|
|
goto skip_numa_setup;
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
/* Use irq assignment to distribute across cpus in node */
|
|
|
|
cpu_index = irq % num_cpus;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-12-26 14:53:40 +03:00
|
|
|
for_each_cpu_and(numa_cpu, cpu_mask, &domain)
|
|
|
|
if (cpu_online(numa_cpu) && i++ >= cpu_index)
|
|
|
|
break;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2008-12-26 14:53:40 +03:00
|
|
|
if (numa_cpu < nr_cpu_ids)
|
2005-04-17 02:20:36 +04: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 14:53:40 +03:00
|
|
|
if (++cpu >= nr_cpu_ids)
|
2005-04-17 02:20:36 +04:00
|
|
|
cpu = 0;
|
2015-03-05 03:19:16 +03:00
|
|
|
} while (!cpu_online(cpu) || !cpumask_test_cpu(cpu, &domain));
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
return cpu_physical_id(cpu);
|
2006-03-27 12:12:19 +04:00
|
|
|
#else /* CONFIG_SMP */
|
2005-04-17 02:20:36 +04:00
|
|
|
return cpu_physical_id(smp_processor_id());
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-11-07 09:38:30 +03: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-17 02:20:36 +04: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 16:22:03 +04:00
|
|
|
int irq, mask = 1, err;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int dest;
|
|
|
|
unsigned long flags;
|
2005-04-26 00:26:23 +04:00
|
|
|
struct iosapic_rte_info *rte;
|
|
|
|
u32 low32;
|
2007-11-07 09:38:30 +03:00
|
|
|
unsigned char dmode;
|
2011-03-25 22:16:05 +03:00
|
|
|
struct irq_desc *desc;
|
2007-07-17 16:20:54 +04:00
|
|
|
|
2005-04-17 02:20:36 +04: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 16:22:03 +04:00
|
|
|
irq = __gsi_to_irq(gsi);
|
|
|
|
if (irq > 0) {
|
|
|
|
rte = find_rte(irq, gsi);
|
2007-07-17 16:22:23 +04:00
|
|
|
if(iosapic_intr_info[irq].count == 0) {
|
|
|
|
assign_irq_vector(irq);
|
2014-05-07 19:44:22 +04:00
|
|
|
irq_init_desc(irq);
|
2007-07-17 16:22:23 +04:00
|
|
|
} else if (rte->refcnt != NO_REF_RTE) {
|
|
|
|
rte->refcnt++;
|
|
|
|
goto unlock_iosapic_lock;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
irq = create_irq();
|
2005-04-26 00:26:23 +04:00
|
|
|
|
|
|
|
/* If vector is running out, we try to find a sharable vector */
|
2007-07-17 16:21:48 +04:00
|
|
|
if (irq < 0) {
|
2007-07-17 16:22:03 +04:00
|
|
|
irq = iosapic_find_sharable_irq(trigger, polarity);
|
|
|
|
if (irq < 0)
|
2007-07-17 16:20:54 +04:00
|
|
|
goto unlock_iosapic_lock;
|
2007-07-17 16:22:03 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2011-03-25 22:16:05 +03:00
|
|
|
desc = irq_to_desc(irq);
|
|
|
|
raw_spin_lock(&desc->lock);
|
2007-07-17 16:22:03 +04:00
|
|
|
dest = get_target_cpu(gsi, irq);
|
2007-11-07 09:38:30 +03:00
|
|
|
dmode = choose_dmode();
|
|
|
|
err = register_intr(gsi, irq, dmode, polarity, trigger);
|
2007-07-17 16:20:29 +04:00
|
|
|
if (err < 0) {
|
2011-03-25 22:16:05 +03:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2007-07-17 16:22:03 +04:00
|
|
|
irq = err;
|
2007-08-01 16:18:44 +04:00
|
|
|
goto unlock_iosapic_lock;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2007-07-17 16:20:29 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the vector is shared and already unmasked for other
|
|
|
|
* interrupt sources, don't mask it.
|
|
|
|
*/
|
2007-07-17 16:22:03 +04:00
|
|
|
low32 = iosapic_intr_info[irq].low32;
|
|
|
|
if (irq_is_shared(irq) && !(low32 & IOSAPIC_MASK))
|
2007-07-17 16:20:29 +04:00
|
|
|
mask = 0;
|
2007-07-17 16:22:03 +04:00
|
|
|
set_rte(gsi, irq, dest, mask);
|
2005-04-17 02:20:36 +04: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 16:22:03 +04:00
|
|
|
cpu_logical_id(dest), dest, irq_to_vector(irq));
|
2007-08-01 16:18:44 +04:00
|
|
|
|
2011-03-25 22:16:05 +03:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2007-07-17 16:20:54 +04:00
|
|
|
unlock_iosapic_lock:
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
2007-07-17 16:22:03 +04:00
|
|
|
return irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
iosapic_unregister_intr (unsigned int gsi)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-07-17 16:22:03 +04:00
|
|
|
int irq, index;
|
2005-04-26 00:26:23 +04:00
|
|
|
u32 low32;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned long trigger, polarity;
|
2005-04-26 00:26:23 +04:00
|
|
|
unsigned int dest;
|
|
|
|
struct iosapic_rte_info *rte;
|
2005-04-17 02:20:36 +04: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 12:12:19 +04:00
|
|
|
printk(KERN_ERR "iosapic_unregister_intr(%u) unbalanced\n",
|
|
|
|
gsi);
|
2005-04-17 02:20:36 +04:00
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-07-17 16:20:54 +04:00
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 16:22:03 +04:00
|
|
|
if ((rte = find_rte(irq, gsi)) == NULL) {
|
2007-07-17 16:20:29 +04:00
|
|
|
printk(KERN_ERR "iosapic_unregister_intr(%u) unbalanced\n",
|
|
|
|
gsi);
|
|
|
|
WARN_ON(1);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:20:29 +04:00
|
|
|
if (--rte->refcnt > 0)
|
|
|
|
goto out;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:22:23 +04:00
|
|
|
rte->refcnt = NO_REF_RTE;
|
2007-07-17 16:20:54 +04:00
|
|
|
|
2007-07-17 16:20:29 +04:00
|
|
|
/* Mask the interrupt */
|
2007-07-17 16:22:03 +04:00
|
|
|
low32 = iosapic_intr_info[irq].low32 | IOSAPIC_MASK;
|
2007-07-17 16:21:26 +04:00
|
|
|
iosapic_write(rte->iosapic, IOSAPIC_RTE_LOW(rte->rte_index), low32);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
iosapic_intr_info[irq].count--;
|
2007-07-17 16:20:29 +04:00
|
|
|
index = find_iosapic(gsi);
|
|
|
|
iosapic_lists[index].rtes_inuse--;
|
|
|
|
WARN_ON(iosapic_lists[index].rtes_inuse < 0);
|
2005-04-26 00:26:23 +04:00
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
trigger = iosapic_intr_info[irq].trigger;
|
|
|
|
polarity = iosapic_intr_info[irq].polarity;
|
|
|
|
dest = iosapic_intr_info[irq].dest;
|
2007-07-17 16:20:29 +04: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 16:22:03 +04:00
|
|
|
cpu_logical_id(dest), dest, irq_to_vector(irq));
|
2005-04-26 00:26:23 +04:00
|
|
|
|
2007-07-17 16:22:23 +04:00
|
|
|
if (iosapic_intr_info[irq].count == 0) {
|
2007-01-25 08:48:04 +03:00
|
|
|
#ifdef CONFIG_SMP
|
2007-07-17 16:20:29 +04:00
|
|
|
/* Clear affinity */
|
2015-07-13 23:42:46 +03:00
|
|
|
cpumask_setall(irq_get_affinity_mask(irq));
|
2007-01-25 08:48:04 +03:00
|
|
|
#endif
|
2007-07-17 16:20:29 +04:00
|
|
|
/* Clear the interrupt information */
|
2007-07-17 16:22:23 +04: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 16:22:03 +04:00
|
|
|
iosapic_intr_info[irq].low32 |= IOSAPIC_MASK;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:22:23 +04:00
|
|
|
/* Destroy and reserve IRQ */
|
|
|
|
destroy_and_reserve_irq(irq);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2005-04-26 00:26:23 +04:00
|
|
|
out:
|
2007-07-17 16:20:54 +04:00
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
2005-04-17 02:20:36 +04: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 16:21:48 +04:00
|
|
|
int irq, vector, mask = 0;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int dest = ((id << 8) | eid) & 0xffff;
|
|
|
|
|
|
|
|
switch (int_type) {
|
|
|
|
case ACPI_INTERRUPT_PMI:
|
2007-07-17 16:22:23 +04:00
|
|
|
irq = vector = iosapic_vector;
|
2007-07-17 16:22:33 +04:00
|
|
|
bind_irq_vector(irq, vector, CPU_MASK_ALL);
|
2005-04-17 02:20:36 +04: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 16:22:03 +04:00
|
|
|
iosapic_reassign_vector(irq);
|
2005-04-17 02:20:36 +04:00
|
|
|
delivery = IOSAPIC_PMI;
|
|
|
|
break;
|
|
|
|
case ACPI_INTERRUPT_INIT:
|
2007-07-17 16:21:48 +04:00
|
|
|
irq = create_irq();
|
|
|
|
if (irq < 0)
|
2008-03-05 02:15:00 +03:00
|
|
|
panic("%s: out of interrupt vectors!\n", __func__);
|
2007-07-17 16:21:48 +04:00
|
|
|
vector = irq_to_vector(irq);
|
2005-04-17 02:20:36 +04:00
|
|
|
delivery = IOSAPIC_INIT;
|
|
|
|
break;
|
|
|
|
case ACPI_INTERRUPT_CPEI:
|
2007-07-17 16:22:23 +04:00
|
|
|
irq = vector = IA64_CPE_VECTOR;
|
2007-07-17 16:22:33 +04:00
|
|
|
BUG_ON(bind_irq_vector(irq, vector, CPU_MASK_ALL));
|
2007-11-09 04:51:01 +03:00
|
|
|
delivery = IOSAPIC_FIXED;
|
2005-04-17 02:20:36 +04:00
|
|
|
mask = 1;
|
|
|
|
break;
|
|
|
|
default:
|
2008-03-05 02:15:00 +03:00
|
|
|
printk(KERN_ERR "%s: invalid int type 0x%x\n", __func__,
|
2006-03-27 12:12:19 +04:00
|
|
|
int_type);
|
2005-04-17 02:20:36 +04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
register_intr(gsi, irq, delivery, polarity, trigger);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2006-03-27 12:12:19 +04:00
|
|
|
printk(KERN_INFO
|
|
|
|
"PLATFORM int %s (0x%x): GSI %u (%s, %s) -> CPU %d (0x%04x)"
|
|
|
|
" vector %d\n",
|
2005-04-17 02:20:36 +04: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 16:22:03 +04:00
|
|
|
set_rte(gsi, irq, dest, mask);
|
2005-04-17 02:20:36 +04:00
|
|
|
return vector;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ACPI calls this when it finds an entry for a legacy ISA IRQ override.
|
|
|
|
*/
|
2012-12-22 02:05:13 +04:00
|
|
|
void iosapic_override_isa_irq(unsigned int isa_irq, unsigned int gsi,
|
|
|
|
unsigned long polarity, unsigned long trigger)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2007-07-17 16:22:03 +04:00
|
|
|
int vector, irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int dest = cpu_physical_id(smp_processor_id());
|
2007-11-07 09:38:30 +03:00
|
|
|
unsigned char dmode;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:22:23 +04:00
|
|
|
irq = vector = isa_irq_to_vector(isa_irq);
|
2007-07-17 16:22:33 +04:00
|
|
|
BUG_ON(bind_irq_vector(irq, vector, CPU_MASK_ALL));
|
2007-11-07 09:38:30 +03:00
|
|
|
dmode = choose_dmode();
|
|
|
|
register_intr(gsi, irq, dmode, polarity, trigger);
|
2005-04-17 02:20:36 +04: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 16:22:03 +04:00
|
|
|
set_rte(gsi, irq, dest, 1);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2008-05-19 17:13:42 +04: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-17 02:20:36 +04:00
|
|
|
void __init
|
|
|
|
iosapic_system_init (int system_pcat_compat)
|
|
|
|
{
|
2007-07-17 16:22:03 +04:00
|
|
|
int irq;
|
2005-04-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:22:03 +04:00
|
|
|
for (irq = 0; irq < NR_IRQS; ++irq) {
|
|
|
|
iosapic_intr_info[irq].low32 = IOSAPIC_MASK;
|
2006-03-27 12:12:19 +04:00
|
|
|
/* mark as unused */
|
2007-07-17 16:22:03 +04:00
|
|
|
INIT_LIST_HEAD(&iosapic_intr_info[irq].rtes);
|
2007-07-17 16:22:23 +04:00
|
|
|
|
|
|
|
iosapic_intr_info[irq].count = 0;
|
2005-04-26 00:26:23 +04:00
|
|
|
}
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
pcat_compat = system_pcat_compat;
|
2008-05-19 17:13:42 +04:00
|
|
|
if (pcat_compat)
|
|
|
|
iosapic_pcat_compat_init();
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
2005-04-28 11:25:58 +04: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-05 02:15:00 +03:00
|
|
|
printk(KERN_WARNING "%s: failed to allocate iosapic\n", __func__);
|
2005-04-28 11:25:58 +04: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 12:13:46 +04:00
|
|
|
if (gsi_end < base || end < gsi_base)
|
2005-04-28 11:25:58 +04:00
|
|
|
continue; /* OK */
|
|
|
|
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
Fix kexec oops when iosapic was removed
Iosapic hotplug was supported in IA64 code, but will lead to kexec oops
when iosapic was removed. here is the code logic:
iosapic_remove
iosapic_free
memset(&iosapic_lists[index], 0, sizeof(iosapic_lists[0]))
iosapic_lists[index].addr was set to 0;
and then kexec a new kernel
kexec_disable_iosapic
iosapic_write(rte->iosapic,..)
__iosapic_write(iosapic->addr, reg, val);
addr was set to 0 when iosapic_remove, and oops happened
The call trace is:
Starting new kernel
kexec[11336]: Oops 8804682956800 [1]
Modules linked in: raw(N) ipv6(N) acpi_cpufreq(N) binfmt_misc(N) fuse(N) nls_iso
8859_1(N) loop(N) ipmi_si(N) ipmi_devintf(N) ipmi_msghandler(N) mca_ereport(N) s
csi_ereport(N) nic_ereport(N) pcie_ereport(N) err_transport(N) nvlist(PN) dm_mod
(N) tpm_tis(N) tpm(N) ppdev(N) tpm_bios(N) serio_raw(N) i2c_i801(N) iTCO_wdt(N)
i2c_core(N) iTCO_vendor_support(N) sg(N) ioatdma(N) igb(N) mptctl(N) dca(N) parp
ort_pc(N) parport(N) container(N) button(N) usbhid(N) hid(N) uhci_hcd(N) ehci_hc
d(N) usbcore(N) sd_mod(N) crc_t10dif(N) ext3(N) mbcache(N) jbd(N) fan(N) process
or(N) ide_pci_generic(N) ide_core(N) ata_piix(N) libata(N) mptsas(N) mptscsih(N)
mptbase(N) scsi_transport_sas(N) scsi_mod(N) thermal(N) thermal_sys(N) hwmon(N)
Supported: Yes, External
Pid: 11336, CPU 0, comm: kexec
psr : 0000101009522030 ifs : 8000000000000791 ip : [<a00000010004c160>] Tain
ted: P N (2.6.32.12_RAS_V1R3C00B011)
ip is at kexec_disable_iosapic+0x120/0x1e0
unat: 0000000000000000 pfs : 0000000000000791 rsc : 0000000000000003
rnat: 0000000000000000 bsps: 0000000000000000 pr : 65519aa6a555a659
ldrs: 0000000000000000 ccv : 00000000ea3cf51e fpsr: 0009804c8a70033f
csd : 0000000000000000 ssd : 0000000000000000
b0 : a00000010004c150 b6 : a000000100012620 b7 : a00000010000cda0
f6 : 000000000000000000000 f7 : 1003e0000000002000000
f8 : 1003e0000000050000003 f9 : 1003e0000028fb97183cd
f10 : 1003ee9f380df3c548b67 f11 : 1003e00000000000000cc
r1 : a0000001016cf660 r2 : 0000000000000000 r3 : 0000000000000000
r8 : 0000001009526030 r9 : a000000100012620 r10 : e00000010053f600
r11 : c0000000fec34040 r12 : e00000078f76fd30 r13 : e00000078f760000
r14 : 0000000000000000 r15 : 0000000000000000 r16 : 0000000000000000
r17 : 0000000000000000 r18 : 0000000000007fff r19 : 0000000000000000
r20 : 0000000000000000 r21 : e00000010053f590 r22 : a000000100cf0000
r23 : 0000000000000036 r24 : e0000007002f8a84 r25 : 0000000000000022
r26 : e0000007002f8a88 r27 : 0000000000000020 r28 : 0000000000000002
r29 : a0000001012c8c60 r30 : 0000000000000000 r31 : 0000000000322e49
Call Trace:
[<a000000100018ca0>] show_stack+0x80/0xa0
sp=e00000078f76f8f0 bsp=e00000078f761380
[<a000000100019300>] show_regs+0x640/0x920
sp=e00000078f76fac0 bsp=e00000078f761328
[<a00000010002a130>] die+0x190/0x2e0
sp=e00000078f76fad0 bsp=e00000078f7612e8
[<a000000100922fa0>] ia64_do_page_fault+0x840/0xb20
sp=e00000078f76fad0 bsp=e00000078f761288
[<a00000010000d5c0>] ia64_native_leave_kernel+0x0/0x270
sp=e00000078f76fb60 bsp=e00000078f761288
[<a00000010004c160>] kexec_disable_iosapic+0x120/0x1e0
sp=e00000078f76fd30 bsp=e00000078f761200
[<a000000100016970>] machine_shutdown+0x110/0x140
sp=e00000078f76fd30 bsp=e00000078f7611c8
[<a000000100133530>] kernel_kexec+0xd0/0x120
sp=e00000078f76fd30 bsp=e00000078f7611a0
[<a0000001000eca40>] sys_reboot+0x480/0x4e0
sp=e00000078f76fd30 bsp=e00000078f761128
[<a00000010000d420>] ia64_ret_from_syscall+0x0/0x20
sp=e00000078f76fe30 bsp=e00000078f761120
Kernel panic - not syncing: Fatal exception
With Tony and Toshi's advice, the patch removes the "rte" from rte_list
when the iosapic was removed.
Signed-off-by: Hanjun Guo <guohanjun@huawei.com>
Signed-off-by: Jianguo Wu <wujianguo@huawei.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2013-03-08 08:33:35 +04:00
|
|
|
static int
|
|
|
|
iosapic_delete_rte(unsigned int irq, unsigned int gsi)
|
|
|
|
{
|
|
|
|
struct iosapic_rte_info *rte, *temp;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(rte, temp, &iosapic_intr_info[irq].rtes,
|
|
|
|
rte_list) {
|
|
|
|
if (rte->iosapic->gsi_base + rte->rte_index == gsi) {
|
|
|
|
if (rte->refcnt)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
list_del(&rte->rte_list);
|
|
|
|
kfree(rte);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-12-22 02:05:13 +04:00
|
|
|
int iosapic_init(unsigned long phys_addr, unsigned int gsi_base)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
2005-04-28 11:25:58 +04:00
|
|
|
int num_rte, err, index;
|
2005-04-17 02:20:36 +04:00
|
|
|
unsigned int isa_irq, ver;
|
|
|
|
char __iomem *addr;
|
2005-04-28 11:25:58 +04:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 16:21:26 +04:00
|
|
|
index = find_iosapic(gsi_base);
|
|
|
|
if (index >= 0) {
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2007-07-17 16:20:29 +04:00
|
|
|
addr = ioremap(phys_addr, 0);
|
2009-08-12 01:52:11 +04:00
|
|
|
if (addr == NULL) {
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2007-07-17 16:20:29 +04: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-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:20:29 +04: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-17 02:20:36 +04:00
|
|
|
|
2007-07-17 16:20:29 +04: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-17 02:20:36 +04:00
|
|
|
#ifdef CONFIG_NUMA
|
2007-07-17 16:20:29 +04:00
|
|
|
iosapic_lists[index].node = MAX_NUMNODES;
|
2005-04-17 02:20:36 +04:00
|
|
|
#endif
|
2007-07-17 16:21:26 +04:00
|
|
|
spin_lock_init(&iosapic_lists[index].lock);
|
2005-04-28 11:25:58 +04:00
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
2005-04-17 02:20:36 +04:00
|
|
|
|
|
|
|
if ((gsi_base == 0) && pcat_compat) {
|
|
|
|
/*
|
2006-03-27 12:12:19 +04: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-17 02:20:36 +04:00
|
|
|
*/
|
|
|
|
for (isa_irq = 0; isa_irq < 16; ++isa_irq)
|
2006-03-27 12:12:19 +04:00
|
|
|
iosapic_override_isa_irq(isa_irq, isa_irq,
|
|
|
|
IOSAPIC_POL_HIGH,
|
|
|
|
IOSAPIC_EDGE);
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
2005-04-28 11:25:58 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-12-22 02:05:13 +04:00
|
|
|
int iosapic_remove(unsigned int gsi_base)
|
2005-04-28 11:25:58 +04:00
|
|
|
{
|
Fix kexec oops when iosapic was removed
Iosapic hotplug was supported in IA64 code, but will lead to kexec oops
when iosapic was removed. here is the code logic:
iosapic_remove
iosapic_free
memset(&iosapic_lists[index], 0, sizeof(iosapic_lists[0]))
iosapic_lists[index].addr was set to 0;
and then kexec a new kernel
kexec_disable_iosapic
iosapic_write(rte->iosapic,..)
__iosapic_write(iosapic->addr, reg, val);
addr was set to 0 when iosapic_remove, and oops happened
The call trace is:
Starting new kernel
kexec[11336]: Oops 8804682956800 [1]
Modules linked in: raw(N) ipv6(N) acpi_cpufreq(N) binfmt_misc(N) fuse(N) nls_iso
8859_1(N) loop(N) ipmi_si(N) ipmi_devintf(N) ipmi_msghandler(N) mca_ereport(N) s
csi_ereport(N) nic_ereport(N) pcie_ereport(N) err_transport(N) nvlist(PN) dm_mod
(N) tpm_tis(N) tpm(N) ppdev(N) tpm_bios(N) serio_raw(N) i2c_i801(N) iTCO_wdt(N)
i2c_core(N) iTCO_vendor_support(N) sg(N) ioatdma(N) igb(N) mptctl(N) dca(N) parp
ort_pc(N) parport(N) container(N) button(N) usbhid(N) hid(N) uhci_hcd(N) ehci_hc
d(N) usbcore(N) sd_mod(N) crc_t10dif(N) ext3(N) mbcache(N) jbd(N) fan(N) process
or(N) ide_pci_generic(N) ide_core(N) ata_piix(N) libata(N) mptsas(N) mptscsih(N)
mptbase(N) scsi_transport_sas(N) scsi_mod(N) thermal(N) thermal_sys(N) hwmon(N)
Supported: Yes, External
Pid: 11336, CPU 0, comm: kexec
psr : 0000101009522030 ifs : 8000000000000791 ip : [<a00000010004c160>] Tain
ted: P N (2.6.32.12_RAS_V1R3C00B011)
ip is at kexec_disable_iosapic+0x120/0x1e0
unat: 0000000000000000 pfs : 0000000000000791 rsc : 0000000000000003
rnat: 0000000000000000 bsps: 0000000000000000 pr : 65519aa6a555a659
ldrs: 0000000000000000 ccv : 00000000ea3cf51e fpsr: 0009804c8a70033f
csd : 0000000000000000 ssd : 0000000000000000
b0 : a00000010004c150 b6 : a000000100012620 b7 : a00000010000cda0
f6 : 000000000000000000000 f7 : 1003e0000000002000000
f8 : 1003e0000000050000003 f9 : 1003e0000028fb97183cd
f10 : 1003ee9f380df3c548b67 f11 : 1003e00000000000000cc
r1 : a0000001016cf660 r2 : 0000000000000000 r3 : 0000000000000000
r8 : 0000001009526030 r9 : a000000100012620 r10 : e00000010053f600
r11 : c0000000fec34040 r12 : e00000078f76fd30 r13 : e00000078f760000
r14 : 0000000000000000 r15 : 0000000000000000 r16 : 0000000000000000
r17 : 0000000000000000 r18 : 0000000000007fff r19 : 0000000000000000
r20 : 0000000000000000 r21 : e00000010053f590 r22 : a000000100cf0000
r23 : 0000000000000036 r24 : e0000007002f8a84 r25 : 0000000000000022
r26 : e0000007002f8a88 r27 : 0000000000000020 r28 : 0000000000000002
r29 : a0000001012c8c60 r30 : 0000000000000000 r31 : 0000000000322e49
Call Trace:
[<a000000100018ca0>] show_stack+0x80/0xa0
sp=e00000078f76f8f0 bsp=e00000078f761380
[<a000000100019300>] show_regs+0x640/0x920
sp=e00000078f76fac0 bsp=e00000078f761328
[<a00000010002a130>] die+0x190/0x2e0
sp=e00000078f76fad0 bsp=e00000078f7612e8
[<a000000100922fa0>] ia64_do_page_fault+0x840/0xb20
sp=e00000078f76fad0 bsp=e00000078f761288
[<a00000010000d5c0>] ia64_native_leave_kernel+0x0/0x270
sp=e00000078f76fb60 bsp=e00000078f761288
[<a00000010004c160>] kexec_disable_iosapic+0x120/0x1e0
sp=e00000078f76fd30 bsp=e00000078f761200
[<a000000100016970>] machine_shutdown+0x110/0x140
sp=e00000078f76fd30 bsp=e00000078f7611c8
[<a000000100133530>] kernel_kexec+0xd0/0x120
sp=e00000078f76fd30 bsp=e00000078f7611a0
[<a0000001000eca40>] sys_reboot+0x480/0x4e0
sp=e00000078f76fd30 bsp=e00000078f761128
[<a00000010000d420>] ia64_ret_from_syscall+0x0/0x20
sp=e00000078f76fe30 bsp=e00000078f761120
Kernel panic - not syncing: Fatal exception
With Tony and Toshi's advice, the patch removes the "rte" from rte_list
when the iosapic was removed.
Signed-off-by: Hanjun Guo <guohanjun@huawei.com>
Signed-off-by: Jianguo Wu <wujianguo@huawei.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2013-03-08 08:33:35 +04:00
|
|
|
int i, irq, index, err = 0;
|
2005-04-28 11:25:58 +04:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&iosapic_lock, flags);
|
2007-07-17 16:20:29 +04:00
|
|
|
index = find_iosapic(gsi_base);
|
|
|
|
if (index < 0) {
|
|
|
|
printk(KERN_WARNING "%s: No IOSAPIC for GSI base %u\n",
|
2008-03-05 02:15:00 +03:00
|
|
|
__func__, gsi_base);
|
2007-07-17 16:20:29 +04:00
|
|
|
goto out;
|
|
|
|
}
|
2005-04-28 11:25:58 +04:00
|
|
|
|
2007-07-17 16:20:29 +04:00
|
|
|
if (iosapic_lists[index].rtes_inuse) {
|
|
|
|
err = -EBUSY;
|
|
|
|
printk(KERN_WARNING "%s: IOSAPIC for GSI base %u is busy\n",
|
2008-03-05 02:15:00 +03:00
|
|
|
__func__, gsi_base);
|
2007-07-17 16:20:29 +04:00
|
|
|
goto out;
|
2005-04-28 11:25:58 +04:00
|
|
|
}
|
2007-07-17 16:20:29 +04:00
|
|
|
|
Fix kexec oops when iosapic was removed
Iosapic hotplug was supported in IA64 code, but will lead to kexec oops
when iosapic was removed. here is the code logic:
iosapic_remove
iosapic_free
memset(&iosapic_lists[index], 0, sizeof(iosapic_lists[0]))
iosapic_lists[index].addr was set to 0;
and then kexec a new kernel
kexec_disable_iosapic
iosapic_write(rte->iosapic,..)
__iosapic_write(iosapic->addr, reg, val);
addr was set to 0 when iosapic_remove, and oops happened
The call trace is:
Starting new kernel
kexec[11336]: Oops 8804682956800 [1]
Modules linked in: raw(N) ipv6(N) acpi_cpufreq(N) binfmt_misc(N) fuse(N) nls_iso
8859_1(N) loop(N) ipmi_si(N) ipmi_devintf(N) ipmi_msghandler(N) mca_ereport(N) s
csi_ereport(N) nic_ereport(N) pcie_ereport(N) err_transport(N) nvlist(PN) dm_mod
(N) tpm_tis(N) tpm(N) ppdev(N) tpm_bios(N) serio_raw(N) i2c_i801(N) iTCO_wdt(N)
i2c_core(N) iTCO_vendor_support(N) sg(N) ioatdma(N) igb(N) mptctl(N) dca(N) parp
ort_pc(N) parport(N) container(N) button(N) usbhid(N) hid(N) uhci_hcd(N) ehci_hc
d(N) usbcore(N) sd_mod(N) crc_t10dif(N) ext3(N) mbcache(N) jbd(N) fan(N) process
or(N) ide_pci_generic(N) ide_core(N) ata_piix(N) libata(N) mptsas(N) mptscsih(N)
mptbase(N) scsi_transport_sas(N) scsi_mod(N) thermal(N) thermal_sys(N) hwmon(N)
Supported: Yes, External
Pid: 11336, CPU 0, comm: kexec
psr : 0000101009522030 ifs : 8000000000000791 ip : [<a00000010004c160>] Tain
ted: P N (2.6.32.12_RAS_V1R3C00B011)
ip is at kexec_disable_iosapic+0x120/0x1e0
unat: 0000000000000000 pfs : 0000000000000791 rsc : 0000000000000003
rnat: 0000000000000000 bsps: 0000000000000000 pr : 65519aa6a555a659
ldrs: 0000000000000000 ccv : 00000000ea3cf51e fpsr: 0009804c8a70033f
csd : 0000000000000000 ssd : 0000000000000000
b0 : a00000010004c150 b6 : a000000100012620 b7 : a00000010000cda0
f6 : 000000000000000000000 f7 : 1003e0000000002000000
f8 : 1003e0000000050000003 f9 : 1003e0000028fb97183cd
f10 : 1003ee9f380df3c548b67 f11 : 1003e00000000000000cc
r1 : a0000001016cf660 r2 : 0000000000000000 r3 : 0000000000000000
r8 : 0000001009526030 r9 : a000000100012620 r10 : e00000010053f600
r11 : c0000000fec34040 r12 : e00000078f76fd30 r13 : e00000078f760000
r14 : 0000000000000000 r15 : 0000000000000000 r16 : 0000000000000000
r17 : 0000000000000000 r18 : 0000000000007fff r19 : 0000000000000000
r20 : 0000000000000000 r21 : e00000010053f590 r22 : a000000100cf0000
r23 : 0000000000000036 r24 : e0000007002f8a84 r25 : 0000000000000022
r26 : e0000007002f8a88 r27 : 0000000000000020 r28 : 0000000000000002
r29 : a0000001012c8c60 r30 : 0000000000000000 r31 : 0000000000322e49
Call Trace:
[<a000000100018ca0>] show_stack+0x80/0xa0
sp=e00000078f76f8f0 bsp=e00000078f761380
[<a000000100019300>] show_regs+0x640/0x920
sp=e00000078f76fac0 bsp=e00000078f761328
[<a00000010002a130>] die+0x190/0x2e0
sp=e00000078f76fad0 bsp=e00000078f7612e8
[<a000000100922fa0>] ia64_do_page_fault+0x840/0xb20
sp=e00000078f76fad0 bsp=e00000078f761288
[<a00000010000d5c0>] ia64_native_leave_kernel+0x0/0x270
sp=e00000078f76fb60 bsp=e00000078f761288
[<a00000010004c160>] kexec_disable_iosapic+0x120/0x1e0
sp=e00000078f76fd30 bsp=e00000078f761200
[<a000000100016970>] machine_shutdown+0x110/0x140
sp=e00000078f76fd30 bsp=e00000078f7611c8
[<a000000100133530>] kernel_kexec+0xd0/0x120
sp=e00000078f76fd30 bsp=e00000078f7611a0
[<a0000001000eca40>] sys_reboot+0x480/0x4e0
sp=e00000078f76fd30 bsp=e00000078f761128
[<a00000010000d420>] ia64_ret_from_syscall+0x0/0x20
sp=e00000078f76fe30 bsp=e00000078f761120
Kernel panic - not syncing: Fatal exception
With Tony and Toshi's advice, the patch removes the "rte" from rte_list
when the iosapic was removed.
Signed-off-by: Hanjun Guo <guohanjun@huawei.com>
Signed-off-by: Jianguo Wu <wujianguo@huawei.com>
Acked-by: Toshi Kani <toshi.kani@hp.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>
2013-03-08 08:33:35 +04:00
|
|
|
for (i = gsi_base; i < gsi_base + iosapic_lists[index].num_rte; i++) {
|
|
|
|
irq = __gsi_to_irq(i);
|
|
|
|
if (irq < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
err = iosapic_delete_rte(irq, i);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2007-07-17 16:20:29 +04:00
|
|
|
iounmap(iosapic_lists[index].addr);
|
|
|
|
iosapic_free(index);
|
2005-04-28 11:25:58 +04:00
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&iosapic_lock, flags);
|
|
|
|
return err;
|
2005-04-17 02:20:36 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_NUMA
|
2012-12-22 02:05:13 +04:00
|
|
|
void map_iosapic_to_node(unsigned int gsi_base, int node)
|
2005-04-17 02:20:36 +04:00
|
|
|
{
|
|
|
|
int index;
|
|
|
|
|
|
|
|
index = find_iosapic(gsi_base);
|
|
|
|
if (index < 0) {
|
|
|
|
printk(KERN_WARNING "%s: No IOSAPIC for GSI %u\n",
|
2008-03-05 02:15:00 +03:00
|
|
|
__func__, gsi_base);
|
2005-04-17 02:20:36 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
iosapic_lists[index].node = node;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|