2005-09-26 00:04:21 -06:00
|
|
|
/*
|
|
|
|
* arch/powerpc/kernel/mpic.c
|
|
|
|
*
|
|
|
|
* Driver for interrupt controllers following the OpenPIC standard, the
|
|
|
|
* common implementation beeing IBM's MPIC. This driver also can deal
|
|
|
|
* with various broken implementations of this HW.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2004 Benjamin Herrenschmidt, IBM Corp.
|
|
|
|
*
|
|
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
|
|
* License. See the file COPYING in the main directory of this archive
|
|
|
|
* for more details.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#undef DEBUG
|
2005-12-13 19:10:10 -07:00
|
|
|
#undef DEBUG_IPI
|
|
|
|
#undef DEBUG_IRQ
|
|
|
|
#undef DEBUG_LOW
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/spinlock.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-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
#include <asm/ptrace.h>
|
|
|
|
#include <asm/signal.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/mpic.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
|
2007-05-07 20:58:36 -06:00
|
|
|
#include "mpic.h"
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
#ifdef DEBUG
|
|
|
|
#define DBG(fmt...) printk(fmt)
|
|
|
|
#else
|
|
|
|
#define DBG(fmt...)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct mpic *mpics;
|
|
|
|
static struct mpic *mpic_primary;
|
2010-02-17 19:23:18 -07:00
|
|
|
static DEFINE_RAW_SPINLOCK(mpic_lock);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-09-30 21:49:08 -06:00
|
|
|
#ifdef CONFIG_PPC32 /* XXX for now */
|
2005-11-29 12:25:54 -07:00
|
|
|
#ifdef CONFIG_IRQ_ALL_CPUS
|
|
|
|
#define distribute_irqs (1)
|
|
|
|
#else
|
|
|
|
#define distribute_irqs (0)
|
|
|
|
#endif
|
2005-09-30 21:49:08 -06:00
|
|
|
#endif
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
#ifdef CONFIG_MPIC_WEIRD
|
|
|
|
static u32 mpic_infos[][MPIC_IDX_END] = {
|
|
|
|
[0] = { /* Original OpenPIC compatible MPIC */
|
|
|
|
MPIC_GREG_BASE,
|
|
|
|
MPIC_GREG_FEATURE_0,
|
|
|
|
MPIC_GREG_GLOBAL_CONF_0,
|
|
|
|
MPIC_GREG_VENDOR_ID,
|
|
|
|
MPIC_GREG_IPI_VECTOR_PRI_0,
|
|
|
|
MPIC_GREG_IPI_STRIDE,
|
|
|
|
MPIC_GREG_SPURIOUS,
|
|
|
|
MPIC_GREG_TIMER_FREQ,
|
|
|
|
|
|
|
|
MPIC_TIMER_BASE,
|
|
|
|
MPIC_TIMER_STRIDE,
|
|
|
|
MPIC_TIMER_CURRENT_CNT,
|
|
|
|
MPIC_TIMER_BASE_CNT,
|
|
|
|
MPIC_TIMER_VECTOR_PRI,
|
|
|
|
MPIC_TIMER_DESTINATION,
|
|
|
|
|
|
|
|
MPIC_CPU_BASE,
|
|
|
|
MPIC_CPU_STRIDE,
|
|
|
|
MPIC_CPU_IPI_DISPATCH_0,
|
|
|
|
MPIC_CPU_IPI_DISPATCH_STRIDE,
|
|
|
|
MPIC_CPU_CURRENT_TASK_PRI,
|
|
|
|
MPIC_CPU_WHOAMI,
|
|
|
|
MPIC_CPU_INTACK,
|
|
|
|
MPIC_CPU_EOI,
|
2007-12-20 12:11:18 -07:00
|
|
|
MPIC_CPU_MCACK,
|
2006-08-24 22:16:30 -06:00
|
|
|
|
|
|
|
MPIC_IRQ_BASE,
|
|
|
|
MPIC_IRQ_STRIDE,
|
|
|
|
MPIC_IRQ_VECTOR_PRI,
|
|
|
|
MPIC_VECPRI_VECTOR_MASK,
|
|
|
|
MPIC_VECPRI_POLARITY_POSITIVE,
|
|
|
|
MPIC_VECPRI_POLARITY_NEGATIVE,
|
|
|
|
MPIC_VECPRI_SENSE_LEVEL,
|
|
|
|
MPIC_VECPRI_SENSE_EDGE,
|
|
|
|
MPIC_VECPRI_POLARITY_MASK,
|
|
|
|
MPIC_VECPRI_SENSE_MASK,
|
|
|
|
MPIC_IRQ_DESTINATION
|
|
|
|
},
|
|
|
|
[1] = { /* Tsi108/109 PIC */
|
|
|
|
TSI108_GREG_BASE,
|
|
|
|
TSI108_GREG_FEATURE_0,
|
|
|
|
TSI108_GREG_GLOBAL_CONF_0,
|
|
|
|
TSI108_GREG_VENDOR_ID,
|
|
|
|
TSI108_GREG_IPI_VECTOR_PRI_0,
|
|
|
|
TSI108_GREG_IPI_STRIDE,
|
|
|
|
TSI108_GREG_SPURIOUS,
|
|
|
|
TSI108_GREG_TIMER_FREQ,
|
|
|
|
|
|
|
|
TSI108_TIMER_BASE,
|
|
|
|
TSI108_TIMER_STRIDE,
|
|
|
|
TSI108_TIMER_CURRENT_CNT,
|
|
|
|
TSI108_TIMER_BASE_CNT,
|
|
|
|
TSI108_TIMER_VECTOR_PRI,
|
|
|
|
TSI108_TIMER_DESTINATION,
|
|
|
|
|
|
|
|
TSI108_CPU_BASE,
|
|
|
|
TSI108_CPU_STRIDE,
|
|
|
|
TSI108_CPU_IPI_DISPATCH_0,
|
|
|
|
TSI108_CPU_IPI_DISPATCH_STRIDE,
|
|
|
|
TSI108_CPU_CURRENT_TASK_PRI,
|
|
|
|
TSI108_CPU_WHOAMI,
|
|
|
|
TSI108_CPU_INTACK,
|
|
|
|
TSI108_CPU_EOI,
|
2007-12-20 12:11:18 -07:00
|
|
|
TSI108_CPU_MCACK,
|
2006-08-24 22:16:30 -06:00
|
|
|
|
|
|
|
TSI108_IRQ_BASE,
|
|
|
|
TSI108_IRQ_STRIDE,
|
|
|
|
TSI108_IRQ_VECTOR_PRI,
|
|
|
|
TSI108_VECPRI_VECTOR_MASK,
|
|
|
|
TSI108_VECPRI_POLARITY_POSITIVE,
|
|
|
|
TSI108_VECPRI_POLARITY_NEGATIVE,
|
|
|
|
TSI108_VECPRI_SENSE_LEVEL,
|
|
|
|
TSI108_VECPRI_SENSE_EDGE,
|
|
|
|
TSI108_VECPRI_POLARITY_MASK,
|
|
|
|
TSI108_VECPRI_SENSE_MASK,
|
|
|
|
TSI108_IRQ_DESTINATION
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
#define MPIC_INFO(name) mpic->hw_set[MPIC_IDX_##name]
|
|
|
|
|
|
|
|
#else /* CONFIG_MPIC_WEIRD */
|
|
|
|
|
|
|
|
#define MPIC_INFO(name) MPIC_##name
|
|
|
|
|
|
|
|
#endif /* CONFIG_MPIC_WEIRD */
|
|
|
|
|
2011-03-14 04:01:07 -06:00
|
|
|
static inline unsigned int mpic_processor_id(struct mpic *mpic)
|
|
|
|
{
|
|
|
|
unsigned int cpu = 0;
|
|
|
|
|
|
|
|
if (mpic->flags & MPIC_PRIMARY)
|
|
|
|
cpu = hard_smp_processor_id();
|
|
|
|
|
|
|
|
return cpu;
|
|
|
|
}
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/*
|
|
|
|
* Register accessor functions
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
static inline u32 _mpic_read(enum mpic_reg_type type,
|
|
|
|
struct mpic_reg_bank *rb,
|
|
|
|
unsigned int reg)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2006-11-10 23:24:55 -07:00
|
|
|
switch(type) {
|
|
|
|
#ifdef CONFIG_PPC_DCR
|
|
|
|
case mpic_access_dcr:
|
2007-10-15 03:34:36 -06:00
|
|
|
return dcr_read(rb->dhost, reg);
|
2006-11-10 23:24:55 -07:00
|
|
|
#endif
|
|
|
|
case mpic_access_mmio_be:
|
|
|
|
return in_be32(rb->base + (reg >> 2));
|
|
|
|
case mpic_access_mmio_le:
|
|
|
|
default:
|
|
|
|
return in_le32(rb->base + (reg >> 2));
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
static inline void _mpic_write(enum mpic_reg_type type,
|
|
|
|
struct mpic_reg_bank *rb,
|
|
|
|
unsigned int reg, u32 value)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2006-11-10 23:24:55 -07:00
|
|
|
switch(type) {
|
|
|
|
#ifdef CONFIG_PPC_DCR
|
|
|
|
case mpic_access_dcr:
|
2008-02-21 02:39:01 -07:00
|
|
|
dcr_write(rb->dhost, reg, value);
|
|
|
|
break;
|
2006-11-10 23:24:55 -07:00
|
|
|
#endif
|
|
|
|
case mpic_access_mmio_be:
|
2008-02-21 02:39:01 -07:00
|
|
|
out_be32(rb->base + (reg >> 2), value);
|
|
|
|
break;
|
2006-11-10 23:24:55 -07:00
|
|
|
case mpic_access_mmio_le:
|
|
|
|
default:
|
2008-02-21 02:39:01 -07:00
|
|
|
out_le32(rb->base + (reg >> 2), value);
|
|
|
|
break;
|
2006-11-10 23:24:55 -07:00
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 _mpic_ipi_read(struct mpic *mpic, unsigned int ipi)
|
|
|
|
{
|
2006-11-10 23:24:55 -07:00
|
|
|
enum mpic_reg_type type = mpic->reg_type;
|
2006-08-24 22:16:30 -06:00
|
|
|
unsigned int offset = MPIC_INFO(GREG_IPI_VECTOR_PRI_0) +
|
|
|
|
(ipi * MPIC_INFO(GREG_IPI_STRIDE));
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
if ((mpic->flags & MPIC_BROKEN_IPI) && type == mpic_access_mmio_le)
|
|
|
|
type = mpic_access_mmio_be;
|
|
|
|
return _mpic_read(type, &mpic->gregs, offset);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void _mpic_ipi_write(struct mpic *mpic, unsigned int ipi, u32 value)
|
|
|
|
{
|
2006-08-24 22:16:30 -06:00
|
|
|
unsigned int offset = MPIC_INFO(GREG_IPI_VECTOR_PRI_0) +
|
|
|
|
(ipi * MPIC_INFO(GREG_IPI_STRIDE));
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
_mpic_write(mpic->reg_type, &mpic->gregs, offset, value);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 _mpic_cpu_read(struct mpic *mpic, unsigned int reg)
|
|
|
|
{
|
2011-03-14 04:01:07 -06:00
|
|
|
unsigned int cpu = mpic_processor_id(mpic);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
return _mpic_read(mpic->reg_type, &mpic->cpuregs[cpu], reg);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void _mpic_cpu_write(struct mpic *mpic, unsigned int reg, u32 value)
|
|
|
|
{
|
2011-03-14 04:01:07 -06:00
|
|
|
unsigned int cpu = mpic_processor_id(mpic);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
_mpic_write(mpic->reg_type, &mpic->cpuregs[cpu], reg, value);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline u32 _mpic_irq_read(struct mpic *mpic, unsigned int src_no, unsigned int reg)
|
|
|
|
{
|
|
|
|
unsigned int isu = src_no >> mpic->isu_shift;
|
|
|
|
unsigned int idx = src_no & mpic->isu_mask;
|
2009-07-05 10:08:52 -06:00
|
|
|
unsigned int val;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2009-07-05 10:08:52 -06:00
|
|
|
val = _mpic_read(mpic->reg_type, &mpic->isus[isu],
|
|
|
|
reg + (idx * MPIC_INFO(IRQ_STRIDE)));
|
2007-09-07 13:13:19 -06:00
|
|
|
#ifdef CONFIG_MPIC_BROKEN_REGREAD
|
|
|
|
if (reg == 0)
|
2009-07-05 10:08:52 -06:00
|
|
|
val = (val & (MPIC_VECPRI_MASK | MPIC_VECPRI_ACTIVITY)) |
|
|
|
|
mpic->isu_reg0_shadow[src_no];
|
2007-09-07 13:13:19 -06:00
|
|
|
#endif
|
2009-07-05 10:08:52 -06:00
|
|
|
return val;
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void _mpic_irq_write(struct mpic *mpic, unsigned int src_no,
|
|
|
|
unsigned int reg, u32 value)
|
|
|
|
{
|
|
|
|
unsigned int isu = src_no >> mpic->isu_shift;
|
|
|
|
unsigned int idx = src_no & mpic->isu_mask;
|
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
_mpic_write(mpic->reg_type, &mpic->isus[isu],
|
2006-08-24 22:16:30 -06:00
|
|
|
reg + (idx * MPIC_INFO(IRQ_STRIDE)), value);
|
2007-09-07 13:13:19 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_MPIC_BROKEN_REGREAD
|
|
|
|
if (reg == 0)
|
2009-07-05 10:08:52 -06:00
|
|
|
mpic->isu_reg0_shadow[src_no] =
|
|
|
|
value & ~(MPIC_VECPRI_MASK | MPIC_VECPRI_ACTIVITY);
|
2007-09-07 13:13:19 -06:00
|
|
|
#endif
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
#define mpic_read(b,r) _mpic_read(mpic->reg_type,&(b),(r))
|
|
|
|
#define mpic_write(b,r,v) _mpic_write(mpic->reg_type,&(b),(r),(v))
|
2005-09-26 00:04:21 -06:00
|
|
|
#define mpic_ipi_read(i) _mpic_ipi_read(mpic,(i))
|
|
|
|
#define mpic_ipi_write(i,v) _mpic_ipi_write(mpic,(i),(v))
|
|
|
|
#define mpic_cpu_read(i) _mpic_cpu_read(mpic,(i))
|
|
|
|
#define mpic_cpu_write(i,v) _mpic_cpu_write(mpic,(i),(v))
|
|
|
|
#define mpic_irq_read(s,r) _mpic_irq_read(mpic,(s),(r))
|
|
|
|
#define mpic_irq_write(s,r,v) _mpic_irq_write(mpic,(s),(r),(v))
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Low level utility functions
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2008-01-14 19:56:18 -07:00
|
|
|
static void _mpic_map_mmio(struct mpic *mpic, phys_addr_t phys_addr,
|
2006-11-10 23:24:55 -07:00
|
|
|
struct mpic_reg_bank *rb, unsigned int offset,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
rb->base = ioremap(phys_addr + offset, size);
|
|
|
|
BUG_ON(rb->base == NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC_DCR
|
2009-06-22 10:47:59 -06:00
|
|
|
static void _mpic_map_dcr(struct mpic *mpic, struct device_node *node,
|
|
|
|
struct mpic_reg_bank *rb,
|
2006-11-10 23:24:55 -07:00
|
|
|
unsigned int offset, unsigned int size)
|
|
|
|
{
|
2007-09-17 00:05:01 -06:00
|
|
|
const u32 *dbasep;
|
|
|
|
|
2009-06-22 10:47:59 -06:00
|
|
|
dbasep = of_get_property(node, "dcr-reg", NULL);
|
2007-09-17 00:05:01 -06:00
|
|
|
|
2009-06-22 10:47:59 -06:00
|
|
|
rb->dhost = dcr_map(node, *dbasep + offset, size);
|
2006-11-10 23:24:55 -07:00
|
|
|
BUG_ON(!DCR_MAP_OK(rb->dhost));
|
|
|
|
}
|
|
|
|
|
2009-06-22 10:47:59 -06:00
|
|
|
static inline void mpic_map(struct mpic *mpic, struct device_node *node,
|
|
|
|
phys_addr_t phys_addr, struct mpic_reg_bank *rb,
|
|
|
|
unsigned int offset, unsigned int size)
|
2006-11-10 23:24:55 -07:00
|
|
|
{
|
|
|
|
if (mpic->flags & MPIC_USES_DCR)
|
2009-06-22 10:47:59 -06:00
|
|
|
_mpic_map_dcr(mpic, node, rb, offset, size);
|
2006-11-10 23:24:55 -07:00
|
|
|
else
|
|
|
|
_mpic_map_mmio(mpic, phys_addr, rb, offset, size);
|
|
|
|
}
|
|
|
|
#else /* CONFIG_PPC_DCR */
|
2009-06-22 10:47:59 -06:00
|
|
|
#define mpic_map(m,n,p,b,o,s) _mpic_map_mmio(m,p,b,o,s)
|
2006-11-10 23:24:55 -07:00
|
|
|
#endif /* !CONFIG_PPC_DCR */
|
|
|
|
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Check if we have one of those nice broken MPICs with a flipped endian on
|
|
|
|
* reads from IPI registers
|
|
|
|
*/
|
|
|
|
static void __init mpic_test_broken_ipi(struct mpic *mpic)
|
|
|
|
{
|
|
|
|
u32 r;
|
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_IPI_VECTOR_PRI_0), MPIC_VECPRI_MASK);
|
|
|
|
r = mpic_read(mpic->gregs, MPIC_INFO(GREG_IPI_VECTOR_PRI_0));
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
if (r == le32_to_cpu(MPIC_VECPRI_MASK)) {
|
|
|
|
printk(KERN_INFO "mpic: Detected reversed IPI registers\n");
|
|
|
|
mpic->flags |= MPIC_BROKEN_IPI;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-23 02:47:08 -06:00
|
|
|
#ifdef CONFIG_MPIC_U3_HT_IRQS
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Test if an interrupt is sourced from HyperTransport (used on broken U3s)
|
|
|
|
* to force the edge setting on the MPIC and do the ack workaround.
|
|
|
|
*/
|
2005-12-13 19:10:10 -07:00
|
|
|
static inline int mpic_is_ht_interrupt(struct mpic *mpic, unsigned int source)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2005-12-13 19:10:10 -07:00
|
|
|
if (source >= 128 || !mpic->fixups)
|
2005-09-26 00:04:21 -06:00
|
|
|
return 0;
|
2005-12-13 19:10:10 -07:00
|
|
|
return mpic->fixups[source].base != NULL;
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2005-12-13 00:04:29 -07:00
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
static inline void mpic_ht_end_irq(struct mpic *mpic, unsigned int source)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2005-12-13 19:10:10 -07:00
|
|
|
struct mpic_irq_fixup *fixup = &mpic->fixups[source];
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
if (fixup->applebase) {
|
|
|
|
unsigned int soff = (fixup->index >> 3) & ~3;
|
|
|
|
unsigned int mask = 1U << (fixup->index & 0x1f);
|
|
|
|
writel(mask, fixup->applebase + soff);
|
|
|
|
} else {
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock(&mpic->fixup_lock);
|
2005-12-13 19:10:10 -07:00
|
|
|
writeb(0x11 + 2 * fixup->index, fixup->base + 2);
|
|
|
|
writel(fixup->data, fixup->base + 4);
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock(&mpic->fixup_lock);
|
2005-12-13 19:10:10 -07:00
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
static void mpic_startup_ht_interrupt(struct mpic *mpic, unsigned int source,
|
2011-03-25 09:20:15 -06:00
|
|
|
bool level)
|
2005-12-13 19:10:10 -07:00
|
|
|
{
|
|
|
|
struct mpic_irq_fixup *fixup = &mpic->fixups[source];
|
|
|
|
unsigned long flags;
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
if (fixup->base == NULL)
|
|
|
|
return;
|
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
DBG("startup_ht_interrupt(0x%x) index: %d\n",
|
|
|
|
source, fixup->index);
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_irqsave(&mpic->fixup_lock, flags);
|
2005-12-13 19:10:10 -07:00
|
|
|
/* Enable and configure */
|
|
|
|
writeb(0x10 + 2 * fixup->index, fixup->base + 2);
|
|
|
|
tmp = readl(fixup->base + 4);
|
|
|
|
tmp &= ~(0x23U);
|
2011-03-25 09:20:15 -06:00
|
|
|
if (level)
|
2005-12-13 19:10:10 -07:00
|
|
|
tmp |= 0x22;
|
|
|
|
writel(tmp, fixup->base + 4);
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock_irqrestore(&mpic->fixup_lock, flags);
|
2007-05-02 00:33:41 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
/* use the lowest bit inverted to the actual HW,
|
|
|
|
* set if this fixup was enabled, clear otherwise */
|
|
|
|
mpic->save_data[source].fixup_data = tmp | 1;
|
|
|
|
#endif
|
2005-12-13 19:10:10 -07:00
|
|
|
}
|
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
static void mpic_shutdown_ht_interrupt(struct mpic *mpic, unsigned int source)
|
2005-12-13 19:10:10 -07:00
|
|
|
{
|
|
|
|
struct mpic_irq_fixup *fixup = &mpic->fixups[source];
|
|
|
|
unsigned long flags;
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
if (fixup->base == NULL)
|
|
|
|
return;
|
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
DBG("shutdown_ht_interrupt(0x%x)\n", source);
|
2005-12-13 19:10:10 -07:00
|
|
|
|
|
|
|
/* Disable */
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_irqsave(&mpic->fixup_lock, flags);
|
2005-12-13 19:10:10 -07:00
|
|
|
writeb(0x10 + 2 * fixup->index, fixup->base + 2);
|
|
|
|
tmp = readl(fixup->base + 4);
|
2006-02-17 03:25:42 -07:00
|
|
|
tmp |= 1;
|
2005-12-13 19:10:10 -07:00
|
|
|
writel(tmp, fixup->base + 4);
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock_irqrestore(&mpic->fixup_lock, flags);
|
2007-05-02 00:33:41 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
/* use the lowest bit inverted to the actual HW,
|
|
|
|
* set if this fixup was enabled, clear otherwise */
|
|
|
|
mpic->save_data[source].fixup_data = tmp & ~1;
|
|
|
|
#endif
|
2005-12-13 19:10:10 -07:00
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2007-05-07 20:58:36 -06:00
|
|
|
#ifdef CONFIG_PCI_MSI
|
|
|
|
static void __init mpic_scan_ht_msi(struct mpic *mpic, u8 __iomem *devbase,
|
|
|
|
unsigned int devfn)
|
|
|
|
{
|
|
|
|
u8 __iomem *base;
|
|
|
|
u8 pos, flags;
|
|
|
|
u64 addr = 0;
|
|
|
|
|
|
|
|
for (pos = readb(devbase + PCI_CAPABILITY_LIST); pos != 0;
|
|
|
|
pos = readb(devbase + pos + PCI_CAP_LIST_NEXT)) {
|
|
|
|
u8 id = readb(devbase + pos + PCI_CAP_LIST_ID);
|
|
|
|
if (id == PCI_CAP_ID_HT) {
|
|
|
|
id = readb(devbase + pos + 3);
|
|
|
|
if ((id & HT_5BIT_CAP_MASK) == HT_CAPTYPE_MSI_MAPPING)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pos == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
base = devbase + pos;
|
|
|
|
|
|
|
|
flags = readb(base + HT_MSI_FLAGS);
|
|
|
|
if (!(flags & HT_MSI_FLAGS_FIXED)) {
|
|
|
|
addr = readl(base + HT_MSI_ADDR_LO) & HT_MSI_ADDR_LO_MASK;
|
|
|
|
addr = addr | ((u64)readl(base + HT_MSI_ADDR_HI) << 32);
|
|
|
|
}
|
|
|
|
|
2009-01-06 07:26:03 -07:00
|
|
|
printk(KERN_DEBUG "mpic: - HT:%02x.%x %s MSI mapping found @ 0x%llx\n",
|
2007-05-07 20:58:36 -06:00
|
|
|
PCI_SLOT(devfn), PCI_FUNC(devfn),
|
|
|
|
flags & HT_MSI_FLAGS_ENABLE ? "enabled" : "disabled", addr);
|
|
|
|
|
|
|
|
if (!(flags & HT_MSI_FLAGS_ENABLE))
|
|
|
|
writeb(flags | HT_MSI_FLAGS_ENABLE, base + HT_MSI_FLAGS);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void __init mpic_scan_ht_msi(struct mpic *mpic, u8 __iomem *devbase,
|
|
|
|
unsigned int devfn)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
static void __init mpic_scan_ht_pic(struct mpic *mpic, u8 __iomem *devbase,
|
|
|
|
unsigned int devfn, u32 vdid)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2005-12-13 00:04:29 -07:00
|
|
|
int i, irq, n;
|
2005-12-13 19:10:10 -07:00
|
|
|
u8 __iomem *base;
|
2005-09-26 00:04:21 -06:00
|
|
|
u32 tmp;
|
2005-12-13 00:04:29 -07:00
|
|
|
u8 pos;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
for (pos = readb(devbase + PCI_CAPABILITY_LIST); pos != 0;
|
|
|
|
pos = readb(devbase + pos + PCI_CAP_LIST_NEXT)) {
|
|
|
|
u8 id = readb(devbase + pos + PCI_CAP_LIST_ID);
|
2006-08-30 23:55:24 -06:00
|
|
|
if (id == PCI_CAP_ID_HT) {
|
2005-12-13 00:04:29 -07:00
|
|
|
id = readb(devbase + pos + 3);
|
2006-11-22 00:26:22 -07:00
|
|
|
if ((id & HT_5BIT_CAP_MASK) == HT_CAPTYPE_IRQ)
|
2005-12-13 00:04:29 -07:00
|
|
|
break;
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
2005-12-13 00:04:29 -07:00
|
|
|
if (pos == 0)
|
|
|
|
return;
|
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
base = devbase + pos;
|
|
|
|
writeb(0x01, base + 2);
|
|
|
|
n = (readl(base + 4) >> 16) & 0xff;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
printk(KERN_INFO "mpic: - HT:%02x.%x [0x%02x] vendor %04x device %04x"
|
|
|
|
" has %d irqs\n",
|
|
|
|
devfn >> 3, devfn & 0x7, pos, vdid & 0xffff, vdid >> 16, n + 1);
|
2005-12-13 00:04:29 -07:00
|
|
|
|
|
|
|
for (i = 0; i <= n; i++) {
|
2005-12-13 19:10:10 -07:00
|
|
|
writeb(0x10 + 2 * i, base + 2);
|
|
|
|
tmp = readl(base + 4);
|
2005-09-26 00:04:21 -06:00
|
|
|
irq = (tmp >> 16) & 0xff;
|
2005-12-13 19:10:10 -07:00
|
|
|
DBG("HT PIC index 0x%x, irq 0x%x, tmp: %08x\n", i, irq, tmp);
|
|
|
|
/* mask it , will be unmasked later */
|
|
|
|
tmp |= 0x1;
|
|
|
|
writel(tmp, base + 4);
|
|
|
|
mpic->fixups[irq].index = i;
|
|
|
|
mpic->fixups[irq].base = base;
|
|
|
|
/* Apple HT PIC has a non-standard way of doing EOIs */
|
|
|
|
if ((vdid & 0xffff) == 0x106b)
|
|
|
|
mpic->fixups[irq].applebase = devbase + 0x60;
|
|
|
|
else
|
|
|
|
mpic->fixups[irq].applebase = NULL;
|
|
|
|
writeb(0x11 + 2 * i, base + 2);
|
|
|
|
mpic->fixups[irq].data = readl(base + 4) | 0x80000000;
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-13 00:04:29 -07:00
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
static void __init mpic_scan_ht_pics(struct mpic *mpic)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
|
|
|
unsigned int devfn;
|
|
|
|
u8 __iomem *cfgspace;
|
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
printk(KERN_INFO "mpic: Setting up HT PICs workarounds for U3/U4\n");
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Allocate fixups array */
|
2009-07-01 04:59:57 -06:00
|
|
|
mpic->fixups = kzalloc(128 * sizeof(*mpic->fixups), GFP_KERNEL);
|
2005-09-26 00:04:21 -06:00
|
|
|
BUG_ON(mpic->fixups == NULL);
|
|
|
|
|
|
|
|
/* Init spinlock */
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_init(&mpic->fixup_lock);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-12-13 00:04:29 -07:00
|
|
|
/* Map U3 config space. We assume all IO-APICs are on the primary bus
|
|
|
|
* so we only need to map 64kB.
|
2005-09-26 00:04:21 -06:00
|
|
|
*/
|
2005-12-13 00:04:29 -07:00
|
|
|
cfgspace = ioremap(0xf2000000, 0x10000);
|
2005-09-26 00:04:21 -06:00
|
|
|
BUG_ON(cfgspace == NULL);
|
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
/* Now we scan all slots. We do a very quick scan, we read the header
|
|
|
|
* type, vendor ID and device ID only, that's plenty enough
|
2005-09-26 00:04:21 -06:00
|
|
|
*/
|
2005-12-13 00:04:29 -07:00
|
|
|
for (devfn = 0; devfn < 0x100; devfn++) {
|
2005-09-26 00:04:21 -06:00
|
|
|
u8 __iomem *devbase = cfgspace + (devfn << 8);
|
|
|
|
u8 hdr_type = readb(devbase + PCI_HEADER_TYPE);
|
|
|
|
u32 l = readl(devbase + PCI_VENDOR_ID);
|
2005-12-13 19:10:10 -07:00
|
|
|
u16 s;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
DBG("devfn %x, l: %x\n", devfn, l);
|
|
|
|
|
|
|
|
/* If no device, skip */
|
|
|
|
if (l == 0xffffffff || l == 0x00000000 ||
|
|
|
|
l == 0x0000ffff || l == 0xffff0000)
|
|
|
|
goto next;
|
2005-12-13 19:10:10 -07:00
|
|
|
/* Check if is supports capability lists */
|
|
|
|
s = readw(devbase + PCI_STATUS);
|
|
|
|
if (!(s & PCI_STATUS_CAP_LIST))
|
|
|
|
goto next;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
mpic_scan_ht_pic(mpic, devbase, devfn, l);
|
2007-05-07 20:58:36 -06:00
|
|
|
mpic_scan_ht_msi(mpic, devbase, devfn);
|
2005-12-13 00:04:29 -07:00
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
next:
|
|
|
|
/* next device, if function 0 */
|
2005-12-13 00:04:29 -07:00
|
|
|
if (PCI_FUNC(devfn) == 0 && (hdr_type & 0x80) == 0)
|
2005-09-26 00:04:21 -06:00
|
|
|
devfn += 7;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-23 02:47:08 -06:00
|
|
|
#else /* CONFIG_MPIC_U3_HT_IRQS */
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
|
|
|
|
static inline int mpic_is_ht_interrupt(struct mpic *mpic, unsigned int source)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init mpic_scan_ht_pics(struct mpic *mpic)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-04-23 02:47:08 -06:00
|
|
|
#endif /* CONFIG_MPIC_U3_HT_IRQS */
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2008-10-28 12:01:39 -06:00
|
|
|
#ifdef CONFIG_SMP
|
2010-05-06 02:01:46 -06:00
|
|
|
static int irq_choose_cpu(const struct cpumask *mask)
|
2008-10-28 12:01:39 -06:00
|
|
|
{
|
|
|
|
int cpuid;
|
|
|
|
|
2009-12-16 13:18:11 -07:00
|
|
|
if (cpumask_equal(mask, cpu_all_mask)) {
|
2010-05-06 02:01:46 -06:00
|
|
|
static int irq_rover = 0;
|
2010-02-17 19:23:18 -07:00
|
|
|
static DEFINE_RAW_SPINLOCK(irq_rover_lock);
|
2008-10-28 12:01:39 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* Round-robin distribution... */
|
|
|
|
do_round_robin:
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_irqsave(&irq_rover_lock, flags);
|
2008-10-28 12:01:39 -06:00
|
|
|
|
2010-05-06 02:01:46 -06:00
|
|
|
irq_rover = cpumask_next(irq_rover, cpu_online_mask);
|
|
|
|
if (irq_rover >= nr_cpu_ids)
|
|
|
|
irq_rover = cpumask_first(cpu_online_mask);
|
|
|
|
|
2008-10-28 12:01:39 -06:00
|
|
|
cpuid = irq_rover;
|
|
|
|
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock_irqrestore(&irq_rover_lock, flags);
|
2008-10-28 12:01:39 -06:00
|
|
|
} else {
|
2009-12-16 13:18:11 -07:00
|
|
|
cpuid = cpumask_first_and(mask, cpu_online_mask);
|
|
|
|
if (cpuid >= nr_cpu_ids)
|
2008-10-28 12:01:39 -06:00
|
|
|
goto do_round_robin;
|
|
|
|
}
|
|
|
|
|
2008-12-02 12:37:01 -07:00
|
|
|
return get_hard_smp_processor_id(cpuid);
|
2008-10-28 12:01:39 -06:00
|
|
|
}
|
|
|
|
#else
|
2010-05-06 02:01:46 -06:00
|
|
|
static int irq_choose_cpu(const struct cpumask *mask)
|
2008-10-28 12:01:39 -06:00
|
|
|
{
|
|
|
|
return hard_smp_processor_id();
|
|
|
|
}
|
|
|
|
#endif
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Find an mpic associated with a given linux interrupt */
|
2009-04-07 12:26:54 -06:00
|
|
|
static struct mpic *mpic_find(unsigned int irq)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2006-07-03 05:36:01 -06:00
|
|
|
if (irq < NUM_ISA_INTERRUPTS)
|
|
|
|
return NULL;
|
2007-01-28 22:33:18 -07:00
|
|
|
|
2011-03-25 09:45:20 -06:00
|
|
|
return irq_get_chip_data(irq);
|
2009-04-07 12:26:54 -06:00
|
|
|
}
|
2007-01-28 22:33:18 -07:00
|
|
|
|
2009-04-07 12:26:54 -06:00
|
|
|
/* Determine if the linux irq is an IPI */
|
|
|
|
static unsigned int mpic_is_ipi(struct mpic *mpic, unsigned int irq)
|
|
|
|
{
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = virq_to_hw(irq);
|
2006-07-03 05:36:01 -06:00
|
|
|
|
2009-04-07 12:26:54 -06:00
|
|
|
return (src >= mpic->ipi_vecs[0] && src <= mpic->ipi_vecs[3]);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2009-04-07 12:26:54 -06:00
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/* Convert a cpu mask from logical to physical cpu numbers. */
|
|
|
|
static inline u32 mpic_physmask(u32 cpumask)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
u32 mask = 0;
|
|
|
|
|
2011-05-10 13:28:59 -06:00
|
|
|
for (i = 0; i < min(32, NR_CPUS); ++i, cpumask >>= 1)
|
2005-09-26 00:04:21 -06:00
|
|
|
mask |= (cpumask & 1) << get_hard_smp_processor_id(i);
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
/* Get the mpic structure from the IPI number */
|
2011-03-08 15:26:43 -07:00
|
|
|
static inline struct mpic * mpic_from_ipi(struct irq_data *d)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
return irq_data_get_irq_chip_data(d);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Get the mpic structure from the irq number */
|
|
|
|
static inline struct mpic * mpic_from_irq(unsigned int irq)
|
|
|
|
{
|
2011-03-25 09:45:20 -06:00
|
|
|
return irq_get_chip_data(irq);
|
2011-03-08 15:26:43 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the mpic structure from the irq data */
|
|
|
|
static inline struct mpic * mpic_from_irq_data(struct irq_data *d)
|
|
|
|
{
|
|
|
|
return irq_data_get_irq_chip_data(d);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Send an EOI */
|
|
|
|
static inline void mpic_eoi(struct mpic *mpic)
|
|
|
|
{
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_cpu_write(MPIC_INFO(CPU_EOI), 0);
|
|
|
|
(void)mpic_cpu_read(MPIC_INFO(CPU_WHOAMI));
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Linux descriptor level callbacks
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
void mpic_unmask_irq(struct irq_data *d)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
|
|
|
unsigned int loops = 100000;
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
DBG("%p: %s: enable_irq: %d (src %d)\n", mpic, mpic->name, d->irq, src);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI),
|
|
|
|
mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) &
|
2005-11-17 23:18:15 -07:00
|
|
|
~MPIC_VECPRI_MASK);
|
2005-09-26 00:04:21 -06:00
|
|
|
/* make sure mask gets to controller before we return to user */
|
|
|
|
do {
|
|
|
|
if (!loops--) {
|
2011-01-17 05:10:41 -07:00
|
|
|
printk(KERN_ERR "%s: timeout on hwirq %u\n",
|
|
|
|
__func__, src);
|
2005-09-26 00:04:21 -06:00
|
|
|
break;
|
|
|
|
}
|
2006-08-24 22:16:30 -06:00
|
|
|
} while(mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) & MPIC_VECPRI_MASK);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
void mpic_mask_irq(struct irq_data *d)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
|
|
|
unsigned int loops = 100000;
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
DBG("%s: disable_irq: %d (src %d)\n", mpic->name, d->irq, src);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI),
|
|
|
|
mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) |
|
2005-11-17 23:18:15 -07:00
|
|
|
MPIC_VECPRI_MASK);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* make sure mask gets to controller before we return to user */
|
|
|
|
do {
|
|
|
|
if (!loops--) {
|
2011-01-17 05:10:41 -07:00
|
|
|
printk(KERN_ERR "%s: timeout on hwirq %u\n",
|
|
|
|
__func__, src);
|
2005-09-26 00:04:21 -06:00
|
|
|
break;
|
|
|
|
}
|
2006-08-24 22:16:30 -06:00
|
|
|
} while(!(mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI)) & MPIC_VECPRI_MASK));
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
void mpic_end_irq(struct irq_data *d)
|
2005-12-13 19:10:10 -07:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2006-07-03 03:32:51 -06:00
|
|
|
|
|
|
|
#ifdef DEBUG_IRQ
|
2011-03-08 15:26:43 -07:00
|
|
|
DBG("%s: end_irq: %d\n", mpic->name, d->irq);
|
2006-07-03 03:32:51 -06:00
|
|
|
#endif
|
|
|
|
/* We always EOI on end_irq() even for edge interrupts since that
|
|
|
|
* should only lower the priority, the MPIC should have properly
|
|
|
|
* latched another edge interrupt coming in anyway
|
|
|
|
*/
|
|
|
|
|
|
|
|
mpic_eoi(mpic);
|
|
|
|
}
|
|
|
|
|
2007-04-23 02:47:08 -06:00
|
|
|
#ifdef CONFIG_MPIC_U3_HT_IRQS
|
2006-07-03 03:32:51 -06:00
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
static void mpic_unmask_ht_irq(struct irq_data *d)
|
2006-07-03 03:32:51 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
2005-12-13 19:10:10 -07:00
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
mpic_unmask_irq(d);
|
2005-12-13 19:10:10 -07:00
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
if (irqd_is_level_type(d))
|
2006-07-03 03:32:51 -06:00
|
|
|
mpic_ht_end_irq(mpic, src);
|
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
static unsigned int mpic_startup_ht_irq(struct irq_data *d)
|
2006-07-03 03:32:51 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
2005-12-13 19:10:10 -07:00
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
mpic_unmask_irq(d);
|
2011-03-25 09:20:15 -06:00
|
|
|
mpic_startup_ht_interrupt(mpic, src, irqd_is_level_type(d));
|
2006-07-03 03:32:51 -06:00
|
|
|
|
|
|
|
return 0;
|
2005-12-13 19:10:10 -07:00
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
static void mpic_shutdown_ht_irq(struct irq_data *d)
|
2006-07-03 03:32:51 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
2006-07-03 03:32:51 -06:00
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
mpic_shutdown_ht_interrupt(mpic, src);
|
2011-03-08 15:26:43 -07:00
|
|
|
mpic_mask_irq(d);
|
2006-07-03 03:32:51 -06:00
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
static void mpic_end_ht_irq(struct irq_data *d)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
#ifdef DEBUG_IRQ
|
2011-03-08 15:26:43 -07:00
|
|
|
DBG("%s: end_irq: %d\n", mpic->name, d->irq);
|
2005-12-13 19:10:10 -07:00
|
|
|
#endif
|
2005-09-26 00:04:21 -06:00
|
|
|
/* We always EOI on end_irq() even for edge interrupts since that
|
|
|
|
* should only lower the priority, the MPIC should have properly
|
|
|
|
* latched another edge interrupt coming in anyway
|
|
|
|
*/
|
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
if (irqd_is_level_type(d))
|
2006-07-03 03:32:51 -06:00
|
|
|
mpic_ht_end_irq(mpic, src);
|
2005-09-26 00:04:21 -06:00
|
|
|
mpic_eoi(mpic);
|
|
|
|
}
|
2007-04-23 02:47:08 -06:00
|
|
|
#endif /* !CONFIG_MPIC_U3_HT_IRQS */
|
2006-07-03 03:32:51 -06:00
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
static void mpic_unmask_ipi(struct irq_data *d)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_ipi(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = virq_to_hw(d->irq) - mpic->ipi_vecs[0];
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
DBG("%s: enable_ipi: %d (ipi %d)\n", mpic->name, d->irq, src);
|
2005-09-26 00:04:21 -06:00
|
|
|
mpic_ipi_write(src, mpic_ipi_read(src) & ~MPIC_VECPRI_MASK);
|
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
static void mpic_mask_ipi(struct irq_data *d)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
|
|
|
/* NEVER disable an IPI... that's just plain wrong! */
|
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
static void mpic_end_ipi(struct irq_data *d)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_ipi(d);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* IPIs are marked IRQ_PER_CPU. This has the side effect of
|
|
|
|
* preventing the IRQ_PENDING/IRQ_INPROGRESS logic from
|
|
|
|
* applying to them. We EOI them late to avoid re-entering.
|
2006-07-01 20:29:22 -06:00
|
|
|
* We mark IPI's with IRQF_DISABLED as they must run with
|
2005-09-26 00:04:21 -06:00
|
|
|
* irqs disabled.
|
|
|
|
*/
|
|
|
|
mpic_eoi(mpic);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
int mpic_set_affinity(struct irq_data *d, const struct cpumask *cpumask,
|
|
|
|
bool force)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2008-10-28 12:01:39 -06:00
|
|
|
if (mpic->flags & MPIC_SINGLE_DEST_CPU) {
|
2009-12-16 13:18:11 -07:00
|
|
|
int cpuid = irq_choose_cpu(cpumask);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2008-10-28 12:01:39 -06:00
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_DESTINATION), 1 << cpuid);
|
|
|
|
} else {
|
2011-05-10 13:29:02 -06:00
|
|
|
u32 mask = cpumask_bits(cpumask)[0];
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2011-05-10 13:29:02 -06:00
|
|
|
mask &= cpumask_bits(cpu_online_mask)[0];
|
2008-10-28 12:01:39 -06:00
|
|
|
|
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_DESTINATION),
|
2011-05-10 13:29:02 -06:00
|
|
|
mpic_physmask(mask));
|
2008-10-28 12:01:39 -06:00
|
|
|
}
|
2009-04-27 18:59:21 -06:00
|
|
|
|
|
|
|
return 0;
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
static unsigned int mpic_type_to_vecpri(struct mpic *mpic, unsigned int type)
|
2006-07-03 05:36:01 -06:00
|
|
|
{
|
|
|
|
/* Now convert sense value */
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
switch(type & IRQ_TYPE_SENSE_MASK) {
|
2006-07-03 05:36:01 -06:00
|
|
|
case IRQ_TYPE_EDGE_RISING:
|
2006-08-24 22:16:30 -06:00
|
|
|
return MPIC_INFO(VECPRI_SENSE_EDGE) |
|
|
|
|
MPIC_INFO(VECPRI_POLARITY_POSITIVE);
|
2006-07-03 05:36:01 -06:00
|
|
|
case IRQ_TYPE_EDGE_FALLING:
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
case IRQ_TYPE_EDGE_BOTH:
|
2006-08-24 22:16:30 -06:00
|
|
|
return MPIC_INFO(VECPRI_SENSE_EDGE) |
|
|
|
|
MPIC_INFO(VECPRI_POLARITY_NEGATIVE);
|
2006-07-03 05:36:01 -06:00
|
|
|
case IRQ_TYPE_LEVEL_HIGH:
|
2006-08-24 22:16:30 -06:00
|
|
|
return MPIC_INFO(VECPRI_SENSE_LEVEL) |
|
|
|
|
MPIC_INFO(VECPRI_POLARITY_POSITIVE);
|
2006-07-03 05:36:01 -06:00
|
|
|
case IRQ_TYPE_LEVEL_LOW:
|
|
|
|
default:
|
2006-08-24 22:16:30 -06:00
|
|
|
return MPIC_INFO(VECPRI_SENSE_LEVEL) |
|
|
|
|
MPIC_INFO(VECPRI_POLARITY_NEGATIVE);
|
2006-07-03 05:36:01 -06:00
|
|
|
}
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
}
|
|
|
|
|
2011-03-08 15:26:43 -07:00
|
|
|
int mpic_set_irq_type(struct irq_data *d, unsigned int flow_type)
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
{
|
2011-03-08 15:26:43 -07:00
|
|
|
struct mpic *mpic = mpic_from_irq_data(d);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = irqd_to_hwirq(d);
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
unsigned int vecpri, vold, vnew;
|
|
|
|
|
2006-07-10 05:44:43 -06:00
|
|
|
DBG("mpic: set_irq_type(mpic:@%p,virq:%d,src:0x%x,type:0x%x)\n",
|
2011-03-08 15:26:43 -07:00
|
|
|
mpic, d->irq, src, flow_type);
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
|
|
|
|
if (src >= mpic->irq_count)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (flow_type == IRQ_TYPE_NONE)
|
|
|
|
if (mpic->senses && src < mpic->senses_count)
|
|
|
|
flow_type = mpic->senses[src];
|
|
|
|
if (flow_type == IRQ_TYPE_NONE)
|
|
|
|
flow_type = IRQ_TYPE_LEVEL_LOW;
|
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
irqd_set_trigger_type(d, flow_type);
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
|
|
|
|
if (mpic_is_ht_interrupt(mpic, src))
|
|
|
|
vecpri = MPIC_VECPRI_POLARITY_POSITIVE |
|
|
|
|
MPIC_VECPRI_SENSE_EDGE;
|
|
|
|
else
|
2006-08-24 22:16:30 -06:00
|
|
|
vecpri = mpic_type_to_vecpri(mpic, flow_type);
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
vold = mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI));
|
|
|
|
vnew = vold & ~(MPIC_INFO(VECPRI_POLARITY_MASK) |
|
|
|
|
MPIC_INFO(VECPRI_SENSE_MASK));
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
vnew |= vecpri;
|
|
|
|
if (vold != vnew)
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI), vnew);
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
|
2011-03-25 09:20:15 -06:00
|
|
|
return IRQ_SET_MASK_OK_NOCOPY;;
|
2006-07-03 05:36:01 -06:00
|
|
|
}
|
|
|
|
|
2007-12-11 23:44:46 -07:00
|
|
|
void mpic_set_vector(unsigned int virq, unsigned int vector)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_from_irq(virq);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = virq_to_hw(virq);
|
2007-12-11 23:44:46 -07:00
|
|
|
unsigned int vecpri;
|
|
|
|
|
|
|
|
DBG("mpic: set_vector(mpic:@%p,virq:%d,src:%d,vector:0x%x)\n",
|
|
|
|
mpic, virq, src, vector);
|
|
|
|
|
|
|
|
if (src >= mpic->irq_count)
|
|
|
|
return;
|
|
|
|
|
|
|
|
vecpri = mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI));
|
|
|
|
vecpri = vecpri & ~MPIC_INFO(VECPRI_VECTOR_MASK);
|
|
|
|
vecpri |= vector;
|
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI), vecpri);
|
|
|
|
}
|
|
|
|
|
2011-03-14 04:01:06 -06:00
|
|
|
void mpic_set_destination(unsigned int virq, unsigned int cpuid)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_from_irq(virq);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = virq_to_hw(virq);
|
2011-03-14 04:01:06 -06:00
|
|
|
|
|
|
|
DBG("mpic: set_destination(mpic:@%p,virq:%d,src:%d,cpuid:0x%x)\n",
|
|
|
|
mpic, virq, src, cpuid);
|
|
|
|
|
|
|
|
if (src >= mpic->irq_count)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_DESTINATION), 1 << cpuid);
|
|
|
|
}
|
|
|
|
|
2006-07-03 03:32:51 -06:00
|
|
|
static struct irq_chip mpic_irq_chip = {
|
2011-03-08 15:26:43 -07:00
|
|
|
.irq_mask = mpic_mask_irq,
|
|
|
|
.irq_unmask = mpic_unmask_irq,
|
|
|
|
.irq_eoi = mpic_end_irq,
|
|
|
|
.irq_set_type = mpic_set_irq_type,
|
2006-07-03 03:32:51 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static struct irq_chip mpic_ipi_chip = {
|
2011-03-08 15:26:43 -07:00
|
|
|
.irq_mask = mpic_mask_ipi,
|
|
|
|
.irq_unmask = mpic_unmask_ipi,
|
|
|
|
.irq_eoi = mpic_end_ipi,
|
2006-07-03 03:32:51 -06:00
|
|
|
};
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
2007-04-23 02:47:08 -06:00
|
|
|
#ifdef CONFIG_MPIC_U3_HT_IRQS
|
2006-07-03 03:32:51 -06:00
|
|
|
static struct irq_chip mpic_irq_ht_chip = {
|
2011-03-08 15:26:43 -07:00
|
|
|
.irq_startup = mpic_startup_ht_irq,
|
|
|
|
.irq_shutdown = mpic_shutdown_ht_irq,
|
|
|
|
.irq_mask = mpic_mask_irq,
|
|
|
|
.irq_unmask = mpic_unmask_ht_irq,
|
|
|
|
.irq_eoi = mpic_end_ht_irq,
|
|
|
|
.irq_set_type = mpic_set_irq_type,
|
2006-07-03 03:32:51 -06:00
|
|
|
};
|
2007-04-23 02:47:08 -06:00
|
|
|
#endif /* CONFIG_MPIC_U3_HT_IRQS */
|
2006-07-03 03:32:51 -06:00
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
static int mpic_host_match(struct irq_host *h, struct device_node *node)
|
|
|
|
{
|
|
|
|
/* Exact match, unless mpic node is NULL */
|
2007-08-28 02:47:54 -06:00
|
|
|
return h->of_node == NULL || h->of_node == node;
|
2006-07-03 05:36:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int mpic_host_map(struct irq_host *h, unsigned int virq,
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
irq_hw_number_t hw)
|
2006-07-03 05:36:01 -06:00
|
|
|
{
|
|
|
|
struct mpic *mpic = h->host_data;
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
struct irq_chip *chip;
|
2006-07-03 05:36:01 -06:00
|
|
|
|
2006-07-10 05:44:43 -06:00
|
|
|
DBG("mpic: map virq %d, hwirq 0x%lx\n", virq, hw);
|
2006-07-03 05:36:01 -06:00
|
|
|
|
2007-01-28 22:33:18 -07:00
|
|
|
if (hw == mpic->spurious_vec)
|
2006-07-03 05:36:01 -06:00
|
|
|
return -EINVAL;
|
2007-07-20 17:55:21 -06:00
|
|
|
if (mpic->protected && test_bit(hw, mpic->protected))
|
|
|
|
return -EINVAL;
|
2006-07-10 05:44:43 -06:00
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
#ifdef CONFIG_SMP
|
2007-01-28 22:33:18 -07:00
|
|
|
else if (hw >= mpic->ipi_vecs[0]) {
|
2006-07-03 05:36:01 -06:00
|
|
|
WARN_ON(!(mpic->flags & MPIC_PRIMARY));
|
|
|
|
|
2006-07-10 05:44:43 -06:00
|
|
|
DBG("mpic: mapping as IPI\n");
|
2011-03-25 09:45:20 -06:00
|
|
|
irq_set_chip_data(virq, mpic);
|
|
|
|
irq_set_chip_and_handler(virq, &mpic->hc_ipi,
|
2006-07-03 05:36:01 -06:00
|
|
|
handle_percpu_irq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
|
|
|
if (hw >= mpic->irq_count)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-05-07 20:58:36 -06:00
|
|
|
mpic_msi_reserve_hwirq(mpic, hw);
|
|
|
|
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
/* Default chip */
|
2006-07-03 05:36:01 -06:00
|
|
|
chip = &mpic->hc_irq;
|
|
|
|
|
2007-04-23 02:47:08 -06:00
|
|
|
#ifdef CONFIG_MPIC_U3_HT_IRQS
|
2006-07-03 05:36:01 -06:00
|
|
|
/* Check for HT interrupts, override vecpri */
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
if (mpic_is_ht_interrupt(mpic, hw))
|
2006-07-03 05:36:01 -06:00
|
|
|
chip = &mpic->hc_ht_irq;
|
2007-04-23 02:47:08 -06:00
|
|
|
#endif /* CONFIG_MPIC_U3_HT_IRQS */
|
2006-07-03 05:36:01 -06:00
|
|
|
|
2006-07-10 05:44:43 -06:00
|
|
|
DBG("mpic: mapping to irq chip @%p\n", chip);
|
2006-07-03 05:36:01 -06:00
|
|
|
|
2011-03-25 09:45:20 -06:00
|
|
|
irq_set_chip_data(virq, mpic);
|
|
|
|
irq_set_chip_and_handler(virq, chip, handle_fasteoi_irq);
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
|
|
|
|
/* Set default irq type */
|
2011-03-25 09:45:20 -06:00
|
|
|
irq_set_irq_type(virq, IRQ_TYPE_NONE);
|
[PATCH] powerpc: fix trigger handling in the new irq code
This patch slightly reworks the new irq code to fix a small design error. I
removed the passing of the trigger to the map() calls entirely, it was not a
good idea to have one call do two different things. It also fixes a couple of
corner cases.
Mapping a linux virtual irq to a physical irq now does only that. Setting the
trigger is a different action which has a different call.
The main changes are:
- I no longer call host->ops->map() for an already mapped irq, I just return
the virtual number that was already mapped. It was called before to give an
opportunity to change the trigger, but that was causing issues as that could
happen while the interrupt was in use by a device, and because of the
trigger change, map would potentially muck around with things in a racy way.
That was causing much burden on a given's controller implementation of
map() to get it right. This is much simpler now. map() is only called on
the initial mapping of an irq, meaning that you know that this irq is _not_
being used. You can initialize the hardware if you want (though you don't
have to).
- Controllers that can handle different type of triggers (level/edge/etc...)
now implement the standard irq_chip->set_type() call as defined by the
generic code. That means that you can use the standard set_irq_type() to
configure an irq line manually if you wish or (though I don't like that
interface), pass explicit trigger flags to request_irq() as defined by the
generic kernel interfaces. Also, using those interfaces guarantees that
your controller set_type callback is called with the descriptor lock held,
thus providing locking against activity on the same interrupt (including
mask/unmask/etc...) automatically. A result is that, for example, MPIC's
own map() implementation calls irq_set_type(NONE) to configure the hardware
to the default triggers.
- To allow the above, the irq_map array entry for the new mapped interrupt
is now set before map() callback is called for the controller.
- The irq_create_of_mapping() (also used by irq_of_parse_and_map()) function
for mapping interrupts from the device-tree now also call the separate
set_irq_type(), and only does so if there is a change in the trigger type.
- While I was at it, I changed pci_read_irq_line() (which is the helper I
would expect most archs to use in their pcibios_fixup() to get the PCI
interrupt routing from the device tree) to also handle a fallback when the
DT mapping fails consisting of reading the PCI_INTERRUPT_PIN to know wether
the device has an interrupt at all, and the the PCI_INTERRUPT_LINE to get an
interrupt number from the device. That number is then mapped using the
default controller, and the trigger is set to level low. That default
behaviour works for several platforms that don't have a proper interrupt
tree like Pegasos. If it doesn't work for your platform, then either
provide a proper interrupt tree from the firmware so that fallback isn't
needed, or don't call pci_read_irq_line()
- Add back a bit that got dropped by my main rework patch for properly
clearing pending IPIs on pSeries when using a kexec
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-10 05:44:42 -06:00
|
|
|
|
2011-03-14 04:01:06 -06:00
|
|
|
/* If the MPIC was reset, then all vectors have already been
|
|
|
|
* initialized. Otherwise, a per source lazy initialization
|
|
|
|
* is done here.
|
|
|
|
*/
|
|
|
|
if (!mpic_is_ipi(mpic, hw) && (mpic->flags & MPIC_NO_RESET)) {
|
|
|
|
mpic_set_vector(virq, hw);
|
2011-03-14 04:01:07 -06:00
|
|
|
mpic_set_destination(virq, mpic_processor_id(mpic));
|
2011-03-14 04:01:06 -06:00
|
|
|
mpic_irq_set_priority(virq, 8);
|
|
|
|
}
|
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mpic_host_xlate(struct irq_host *h, struct device_node *ct,
|
2009-12-07 19:39:50 -07:00
|
|
|
const u32 *intspec, unsigned int intsize,
|
2006-07-03 05:36:01 -06:00
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_flags)
|
|
|
|
|
|
|
|
{
|
|
|
|
static unsigned char map_mpic_senses[4] = {
|
|
|
|
IRQ_TYPE_EDGE_RISING,
|
|
|
|
IRQ_TYPE_LEVEL_LOW,
|
|
|
|
IRQ_TYPE_LEVEL_HIGH,
|
|
|
|
IRQ_TYPE_EDGE_FALLING,
|
|
|
|
};
|
|
|
|
|
|
|
|
*out_hwirq = intspec[0];
|
2006-07-10 05:44:43 -06:00
|
|
|
if (intsize > 1) {
|
|
|
|
u32 mask = 0x3;
|
|
|
|
|
|
|
|
/* Apple invented a new race of encoding on machines with
|
|
|
|
* an HT APIC. They encode, among others, the index within
|
|
|
|
* the HT APIC. We don't care about it here since thankfully,
|
|
|
|
* it appears that they have the APIC already properly
|
|
|
|
* configured, and thus our current fixup code that reads the
|
|
|
|
* APIC config works fine. However, we still need to mask out
|
|
|
|
* bits in the specifier to make sure we only get bit 0 which
|
|
|
|
* is the level/edge bit (the only sense bit exposed by Apple),
|
|
|
|
* as their bit 1 means something else.
|
|
|
|
*/
|
|
|
|
if (machine_is(powermac))
|
|
|
|
mask = 0x1;
|
|
|
|
*out_flags = map_mpic_senses[intspec[1] & mask];
|
|
|
|
} else
|
2006-07-03 05:36:01 -06:00
|
|
|
*out_flags = IRQ_TYPE_NONE;
|
|
|
|
|
2006-07-10 05:44:43 -06:00
|
|
|
DBG("mpic: xlate (%d cells: 0x%08x 0x%08x) to line 0x%lx sense 0x%x\n",
|
|
|
|
intsize, intspec[0], intspec[1], *out_hwirq, *out_flags);
|
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct irq_host_ops mpic_host_ops = {
|
|
|
|
.match = mpic_host_match,
|
|
|
|
.map = mpic_host_map,
|
|
|
|
.xlate = mpic_host_xlate,
|
|
|
|
};
|
|
|
|
|
2011-03-14 04:01:06 -06:00
|
|
|
static int mpic_reset_prohibited(struct device_node *node)
|
|
|
|
{
|
|
|
|
return node && of_get_property(node, "pic-no-reset", NULL);
|
|
|
|
}
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/*
|
|
|
|
* Exported functions
|
|
|
|
*/
|
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
struct mpic * __init mpic_alloc(struct device_node *node,
|
2006-11-10 23:24:56 -07:00
|
|
|
phys_addr_t phys_addr,
|
2005-09-26 00:04:21 -06:00
|
|
|
unsigned int flags,
|
|
|
|
unsigned int isu_size,
|
|
|
|
unsigned int irq_count,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
struct mpic *mpic;
|
2008-02-21 02:39:01 -07:00
|
|
|
u32 greg_feature;
|
2005-09-26 00:04:21 -06:00
|
|
|
const char *vers;
|
|
|
|
int i;
|
2007-01-28 22:33:18 -07:00
|
|
|
int intvec_top;
|
2006-11-10 23:24:56 -07:00
|
|
|
u64 paddr = phys_addr;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2009-06-18 16:01:20 -06:00
|
|
|
mpic = kzalloc(sizeof(struct mpic), GFP_KERNEL);
|
2005-09-26 00:04:21 -06:00
|
|
|
if (mpic == NULL)
|
|
|
|
return NULL;
|
2009-06-18 16:01:20 -06:00
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
mpic->name = name;
|
|
|
|
|
2006-07-03 03:32:51 -06:00
|
|
|
mpic->hc_irq = mpic_irq_chip;
|
2009-11-18 16:44:21 -07:00
|
|
|
mpic->hc_irq.name = name;
|
2005-09-26 00:04:21 -06:00
|
|
|
if (flags & MPIC_PRIMARY)
|
2011-03-08 15:26:43 -07:00
|
|
|
mpic->hc_irq.irq_set_affinity = mpic_set_affinity;
|
2007-04-23 02:47:08 -06:00
|
|
|
#ifdef CONFIG_MPIC_U3_HT_IRQS
|
2006-07-03 03:32:51 -06:00
|
|
|
mpic->hc_ht_irq = mpic_irq_ht_chip;
|
2009-11-18 16:44:21 -07:00
|
|
|
mpic->hc_ht_irq.name = name;
|
2006-07-03 03:32:51 -06:00
|
|
|
if (flags & MPIC_PRIMARY)
|
2011-03-08 15:26:43 -07:00
|
|
|
mpic->hc_ht_irq.irq_set_affinity = mpic_set_affinity;
|
2007-04-23 02:47:08 -06:00
|
|
|
#endif /* CONFIG_MPIC_U3_HT_IRQS */
|
2006-11-10 23:24:55 -07:00
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
#ifdef CONFIG_SMP
|
2006-07-03 03:32:51 -06:00
|
|
|
mpic->hc_ipi = mpic_ipi_chip;
|
2009-11-18 16:44:21 -07:00
|
|
|
mpic->hc_ipi.name = name;
|
2005-09-26 00:04:21 -06:00
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
|
|
|
mpic->flags = flags;
|
|
|
|
mpic->isu_size = isu_size;
|
|
|
|
mpic->irq_count = irq_count;
|
|
|
|
mpic->num_sources = 0; /* so far */
|
|
|
|
|
2007-01-28 22:33:18 -07:00
|
|
|
if (flags & MPIC_LARGE_VECTORS)
|
|
|
|
intvec_top = 2047;
|
|
|
|
else
|
|
|
|
intvec_top = 255;
|
|
|
|
|
|
|
|
mpic->timer_vecs[0] = intvec_top - 8;
|
|
|
|
mpic->timer_vecs[1] = intvec_top - 7;
|
|
|
|
mpic->timer_vecs[2] = intvec_top - 6;
|
|
|
|
mpic->timer_vecs[3] = intvec_top - 5;
|
|
|
|
mpic->ipi_vecs[0] = intvec_top - 4;
|
|
|
|
mpic->ipi_vecs[1] = intvec_top - 3;
|
|
|
|
mpic->ipi_vecs[2] = intvec_top - 2;
|
|
|
|
mpic->ipi_vecs[3] = intvec_top - 1;
|
|
|
|
mpic->spurious_vec = intvec_top;
|
|
|
|
|
2006-11-10 23:24:56 -07:00
|
|
|
/* Check for "big-endian" in device-tree */
|
2007-04-03 06:26:41 -06:00
|
|
|
if (node && of_get_property(node, "big-endian", NULL) != NULL)
|
2006-11-10 23:24:56 -07:00
|
|
|
mpic->flags |= MPIC_BIG_ENDIAN;
|
|
|
|
|
2007-07-20 17:55:21 -06:00
|
|
|
/* Look for protected sources */
|
|
|
|
if (node) {
|
2008-02-21 02:39:01 -07:00
|
|
|
int psize;
|
|
|
|
unsigned int bits, mapsize;
|
2007-07-20 17:55:21 -06:00
|
|
|
const u32 *psrc =
|
|
|
|
of_get_property(node, "protected-sources", &psize);
|
|
|
|
if (psrc) {
|
|
|
|
psize /= 4;
|
|
|
|
bits = intvec_top + 1;
|
|
|
|
mapsize = BITS_TO_LONGS(bits) * sizeof(unsigned long);
|
2009-07-01 04:59:57 -06:00
|
|
|
mpic->protected = kzalloc(mapsize, GFP_KERNEL);
|
2007-07-20 17:55:21 -06:00
|
|
|
BUG_ON(mpic->protected == NULL);
|
|
|
|
for (i = 0; i < psize; i++) {
|
|
|
|
if (psrc[i] > intvec_top)
|
|
|
|
continue;
|
|
|
|
__set_bit(psrc[i], mpic->protected);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-11-10 23:24:56 -07:00
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
#ifdef CONFIG_MPIC_WEIRD
|
|
|
|
mpic->hw_set = mpic_infos[MPIC_GET_REGSET(flags)];
|
|
|
|
#endif
|
|
|
|
|
2006-11-10 23:24:55 -07:00
|
|
|
/* default register type */
|
|
|
|
mpic->reg_type = (flags & MPIC_BIG_ENDIAN) ?
|
|
|
|
mpic_access_mmio_be : mpic_access_mmio_le;
|
|
|
|
|
2006-11-10 23:24:56 -07:00
|
|
|
/* If no physical address is passed in, a device-node is mandatory */
|
|
|
|
BUG_ON(paddr == 0 && node == NULL);
|
|
|
|
|
|
|
|
/* If no physical address passed in, check if it's dcr based */
|
2007-09-17 00:05:01 -06:00
|
|
|
if (paddr == 0 && of_get_property(node, "dcr-reg", NULL) != NULL) {
|
2006-11-10 23:24:55 -07:00
|
|
|
#ifdef CONFIG_PPC_DCR
|
2007-09-17 00:05:01 -06:00
|
|
|
mpic->flags |= MPIC_USES_DCR;
|
2006-11-10 23:24:55 -07:00
|
|
|
mpic->reg_type = mpic_access_dcr;
|
|
|
|
#else
|
2007-09-17 00:05:01 -06:00
|
|
|
BUG();
|
2006-11-10 23:24:55 -07:00
|
|
|
#endif /* CONFIG_PPC_DCR */
|
2007-09-17 00:05:01 -06:00
|
|
|
}
|
2006-11-10 23:24:55 -07:00
|
|
|
|
2006-11-10 23:24:56 -07:00
|
|
|
/* If the MPIC is not DCR based, and no physical address was passed
|
|
|
|
* in, try to obtain one
|
|
|
|
*/
|
|
|
|
if (paddr == 0 && !(mpic->flags & MPIC_USES_DCR)) {
|
2008-02-21 02:39:01 -07:00
|
|
|
const u32 *reg = of_get_property(node, "reg", NULL);
|
2006-11-10 23:24:56 -07:00
|
|
|
BUG_ON(reg == NULL);
|
|
|
|
paddr = of_translate_address(node, reg);
|
|
|
|
BUG_ON(paddr == OF_BAD_ADDR);
|
|
|
|
}
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/* Map the global registers */
|
2009-06-22 10:47:59 -06:00
|
|
|
mpic_map(mpic, node, paddr, &mpic->gregs, MPIC_INFO(GREG_BASE), 0x1000);
|
|
|
|
mpic_map(mpic, node, paddr, &mpic->tmregs, MPIC_INFO(TIMER_BASE), 0x1000);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Reset */
|
2011-03-14 04:01:06 -06:00
|
|
|
|
|
|
|
/* When using a device-node, reset requests are only honored if the MPIC
|
|
|
|
* is allowed to reset.
|
|
|
|
*/
|
|
|
|
if (mpic_reset_prohibited(node))
|
|
|
|
mpic->flags |= MPIC_NO_RESET;
|
|
|
|
|
|
|
|
if ((flags & MPIC_WANTS_RESET) && !(mpic->flags & MPIC_NO_RESET)) {
|
|
|
|
printk(KERN_DEBUG "mpic: Resetting\n");
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0),
|
|
|
|
mpic_read(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0))
|
2005-09-26 00:04:21 -06:00
|
|
|
| MPIC_GREG_GCONF_RESET);
|
2006-08-24 22:16:30 -06:00
|
|
|
while( mpic_read(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0))
|
2005-09-26 00:04:21 -06:00
|
|
|
& MPIC_GREG_GCONF_RESET)
|
|
|
|
mb();
|
|
|
|
}
|
|
|
|
|
2009-01-07 14:53:29 -07:00
|
|
|
/* CoreInt */
|
|
|
|
if (flags & MPIC_ENABLE_COREINT)
|
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0),
|
|
|
|
mpic_read(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0))
|
|
|
|
| MPIC_GREG_GCONF_COREINT);
|
|
|
|
|
2007-12-20 12:11:18 -07:00
|
|
|
if (flags & MPIC_ENABLE_MCK)
|
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0),
|
|
|
|
mpic_read(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0))
|
|
|
|
| MPIC_GREG_GCONF_MCK);
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/* Read feature register, calculate num CPUs and, for non-ISU
|
|
|
|
* MPICs, num sources as well. On ISU MPICs, sources are counted
|
|
|
|
* as ISUs are added
|
|
|
|
*/
|
2008-02-21 02:39:01 -07:00
|
|
|
greg_feature = mpic_read(mpic->gregs, MPIC_INFO(GREG_FEATURE_0));
|
|
|
|
mpic->num_cpus = ((greg_feature & MPIC_GREG_FEATURE_LAST_CPU_MASK)
|
2005-09-26 00:04:21 -06:00
|
|
|
>> MPIC_GREG_FEATURE_LAST_CPU_SHIFT) + 1;
|
2008-05-23 12:40:00 -06:00
|
|
|
if (isu_size == 0) {
|
2008-05-21 14:59:23 -06:00
|
|
|
if (flags & MPIC_BROKEN_FRR_NIRQS)
|
|
|
|
mpic->num_sources = mpic->irq_count;
|
|
|
|
else
|
|
|
|
mpic->num_sources =
|
|
|
|
((greg_feature & MPIC_GREG_FEATURE_LAST_SRC_MASK)
|
|
|
|
>> MPIC_GREG_FEATURE_LAST_SRC_SHIFT) + 1;
|
2008-05-23 12:40:00 -06:00
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Map the per-CPU registers */
|
|
|
|
for (i = 0; i < mpic->num_cpus; i++) {
|
2009-06-22 10:47:59 -06:00
|
|
|
mpic_map(mpic, node, paddr, &mpic->cpuregs[i],
|
2006-11-10 23:24:55 -07:00
|
|
|
MPIC_INFO(CPU_BASE) + i * MPIC_INFO(CPU_STRIDE),
|
|
|
|
0x1000);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize main ISU if none provided */
|
|
|
|
if (mpic->isu_size == 0) {
|
|
|
|
mpic->isu_size = mpic->num_sources;
|
2009-06-22 10:47:59 -06:00
|
|
|
mpic_map(mpic, node, paddr, &mpic->isus[0],
|
2006-11-10 23:24:55 -07:00
|
|
|
MPIC_INFO(IRQ_BASE), MPIC_INFO(IRQ_STRIDE) * mpic->isu_size);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
mpic->isu_shift = 1 + __ilog2(mpic->isu_size - 1);
|
|
|
|
mpic->isu_mask = (1 << mpic->isu_shift) - 1;
|
|
|
|
|
2009-05-08 06:08:20 -06:00
|
|
|
mpic->irqhost = irq_alloc_host(node, IRQ_HOST_MAP_LINEAR,
|
|
|
|
isu_size ? isu_size : mpic->num_sources,
|
|
|
|
&mpic_host_ops,
|
|
|
|
flags & MPIC_LARGE_VECTORS ? 2048 : 256);
|
|
|
|
if (mpic->irqhost == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
mpic->irqhost->host_data = mpic;
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/* Display version */
|
2008-02-21 02:39:01 -07:00
|
|
|
switch (greg_feature & MPIC_GREG_FEATURE_VERSION_MASK) {
|
2005-09-26 00:04:21 -06:00
|
|
|
case 1:
|
|
|
|
vers = "1.0";
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
vers = "1.2";
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
vers = "1.3";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
vers = "<unknown>";
|
|
|
|
break;
|
|
|
|
}
|
2006-11-10 23:24:56 -07:00
|
|
|
printk(KERN_INFO "mpic: Setting up MPIC \"%s\" version %s at %llx,"
|
|
|
|
" max %d CPUs\n",
|
|
|
|
name, vers, (unsigned long long)paddr, mpic->num_cpus);
|
|
|
|
printk(KERN_INFO "mpic: ISU size: %d, shift: %d, mask: %x\n",
|
|
|
|
mpic->isu_size, mpic->isu_shift, mpic->isu_mask);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
mpic->next = mpics;
|
|
|
|
mpics = mpic;
|
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
if (flags & MPIC_PRIMARY) {
|
2005-09-26 00:04:21 -06:00
|
|
|
mpic_primary = mpic;
|
2006-07-03 05:36:01 -06:00
|
|
|
irq_set_default_host(mpic->irqhost);
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
return mpic;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init mpic_assign_isu(struct mpic *mpic, unsigned int isu_num,
|
2006-11-10 23:24:56 -07:00
|
|
|
phys_addr_t paddr)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
|
|
|
unsigned int isu_first = isu_num * mpic->isu_size;
|
|
|
|
|
|
|
|
BUG_ON(isu_num >= MPIC_MAX_ISU);
|
|
|
|
|
2009-06-22 10:47:59 -06:00
|
|
|
mpic_map(mpic, mpic->irqhost->of_node,
|
|
|
|
paddr, &mpic->isus[isu_num], 0,
|
2006-11-10 23:24:55 -07:00
|
|
|
MPIC_INFO(IRQ_STRIDE) * mpic->isu_size);
|
2009-06-22 10:47:59 -06:00
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
if ((isu_first + mpic->isu_size) > mpic->num_sources)
|
|
|
|
mpic->num_sources = isu_first + mpic->isu_size;
|
|
|
|
}
|
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
void __init mpic_set_default_senses(struct mpic *mpic, u8 *senses, int count)
|
|
|
|
{
|
|
|
|
mpic->senses = senses;
|
|
|
|
mpic->senses_count = count;
|
|
|
|
}
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
void __init mpic_init(struct mpic *mpic)
|
|
|
|
{
|
|
|
|
int i;
|
2008-11-28 02:51:23 -07:00
|
|
|
int cpu;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
BUG_ON(mpic->num_sources == 0);
|
|
|
|
|
|
|
|
printk(KERN_INFO "mpic: Initializing for %d sources\n", mpic->num_sources);
|
|
|
|
|
|
|
|
/* Set current processor priority to max */
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_cpu_write(MPIC_INFO(CPU_CURRENT_TASK_PRI), 0xf);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Initialize timers: just disable them all */
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
mpic_write(mpic->tmregs,
|
2006-08-24 22:16:30 -06:00
|
|
|
i * MPIC_INFO(TIMER_STRIDE) +
|
|
|
|
MPIC_INFO(TIMER_DESTINATION), 0);
|
2005-09-26 00:04:21 -06:00
|
|
|
mpic_write(mpic->tmregs,
|
2006-08-24 22:16:30 -06:00
|
|
|
i * MPIC_INFO(TIMER_STRIDE) +
|
|
|
|
MPIC_INFO(TIMER_VECTOR_PRI),
|
2005-09-26 00:04:21 -06:00
|
|
|
MPIC_VECPRI_MASK |
|
2007-01-28 22:33:18 -07:00
|
|
|
(mpic->timer_vecs[0] + i));
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize IPIs to our reserved vectors and mark them disabled for now */
|
|
|
|
mpic_test_broken_ipi(mpic);
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
mpic_ipi_write(i,
|
|
|
|
MPIC_VECPRI_MASK |
|
|
|
|
(10 << MPIC_VECPRI_PRIORITY_SHIFT) |
|
2007-01-28 22:33:18 -07:00
|
|
|
(mpic->ipi_vecs[0] + i));
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize interrupt sources */
|
|
|
|
if (mpic->irq_count == 0)
|
|
|
|
mpic->irq_count = mpic->num_sources;
|
|
|
|
|
2005-12-13 19:10:10 -07:00
|
|
|
/* Do the HT PIC fixups on U3 broken mpic */
|
2005-09-26 00:04:21 -06:00
|
|
|
DBG("MPIC flags: %x\n", mpic->flags);
|
2007-05-07 20:58:37 -06:00
|
|
|
if ((mpic->flags & MPIC_U3_HT_IRQS) && (mpic->flags & MPIC_PRIMARY)) {
|
2007-05-02 00:33:41 -06:00
|
|
|
mpic_scan_ht_pics(mpic);
|
2007-05-07 20:58:37 -06:00
|
|
|
mpic_u3msi_init(mpic);
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2007-12-11 23:44:46 -07:00
|
|
|
mpic_pasemi_msi_init(mpic);
|
|
|
|
|
2011-03-14 04:01:07 -06:00
|
|
|
cpu = mpic_processor_id(mpic);
|
2008-11-28 02:51:23 -07:00
|
|
|
|
2011-03-14 04:01:06 -06:00
|
|
|
if (!(mpic->flags & MPIC_NO_RESET)) {
|
|
|
|
for (i = 0; i < mpic->num_sources; i++) {
|
|
|
|
/* start with vector = source number, and masked */
|
|
|
|
u32 vecpri = MPIC_VECPRI_MASK | i |
|
|
|
|
(8 << MPIC_VECPRI_PRIORITY_SHIFT);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2011-03-14 04:01:06 -06:00
|
|
|
/* check if protected */
|
|
|
|
if (mpic->protected && test_bit(i, mpic->protected))
|
|
|
|
continue;
|
|
|
|
/* init hw */
|
|
|
|
mpic_irq_write(i, MPIC_INFO(IRQ_VECTOR_PRI), vecpri);
|
|
|
|
mpic_irq_write(i, MPIC_INFO(IRQ_DESTINATION), 1 << cpu);
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2007-01-28 22:33:18 -07:00
|
|
|
/* Init spurious vector */
|
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_SPURIOUS), mpic->spurious_vec);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
/* Disable 8259 passthrough, if supported */
|
|
|
|
if (!(mpic->flags & MPIC_NO_PTHROU_DIS))
|
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0),
|
|
|
|
mpic_read(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0))
|
|
|
|
| MPIC_GREG_GCONF_8259_PTHROU_DIS);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2007-12-27 21:16:29 -07:00
|
|
|
if (mpic->flags & MPIC_NO_BIAS)
|
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0),
|
|
|
|
mpic_read(mpic->gregs, MPIC_INFO(GREG_GLOBAL_CONF_0))
|
|
|
|
| MPIC_GREG_GCONF_NO_BIAS);
|
|
|
|
|
2005-09-26 00:04:21 -06:00
|
|
|
/* Set current processor priority to 0 */
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_cpu_write(MPIC_INFO(CPU_CURRENT_TASK_PRI), 0);
|
2007-05-02 00:33:41 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
/* allocate memory to save mpic state */
|
2009-07-01 04:59:57 -06:00
|
|
|
mpic->save_data = kmalloc(mpic->num_sources * sizeof(*mpic->save_data),
|
|
|
|
GFP_KERNEL);
|
2007-05-02 00:33:41 -06:00
|
|
|
BUG_ON(mpic->save_data == NULL);
|
|
|
|
#endif
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2006-06-20 15:15:36 -06:00
|
|
|
void __init mpic_set_clk_ratio(struct mpic *mpic, u32 clock_ratio)
|
|
|
|
{
|
|
|
|
u32 v;
|
|
|
|
|
|
|
|
v = mpic_read(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1);
|
|
|
|
v &= ~MPIC_GREG_GLOBAL_CONF_1_CLK_RATIO_MASK;
|
|
|
|
v |= MPIC_GREG_GLOBAL_CONF_1_CLK_RATIO(clock_ratio);
|
|
|
|
mpic_write(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1, v);
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2006-06-20 15:15:36 -06:00
|
|
|
void __init mpic_set_serial_int(struct mpic *mpic, int enable)
|
|
|
|
{
|
2006-07-04 23:36:15 -06:00
|
|
|
unsigned long flags;
|
2006-06-20 15:15:36 -06:00
|
|
|
u32 v;
|
|
|
|
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_irqsave(&mpic_lock, flags);
|
2006-06-20 15:15:36 -06:00
|
|
|
v = mpic_read(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1);
|
|
|
|
if (enable)
|
|
|
|
v |= MPIC_GREG_GLOBAL_CONF_1_SIE;
|
|
|
|
else
|
|
|
|
v &= ~MPIC_GREG_GLOBAL_CONF_1_SIE;
|
|
|
|
mpic_write(mpic->gregs, MPIC_GREG_GLOBAL_CONF_1, v);
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock_irqrestore(&mpic_lock, flags);
|
2006-06-20 15:15:36 -06:00
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
void mpic_irq_set_priority(unsigned int irq, unsigned int pri)
|
|
|
|
{
|
2009-04-07 12:26:54 -06:00
|
|
|
struct mpic *mpic = mpic_find(irq);
|
2011-05-03 23:02:15 -06:00
|
|
|
unsigned int src = virq_to_hw(irq);
|
2005-09-26 00:04:21 -06:00
|
|
|
unsigned long flags;
|
|
|
|
u32 reg;
|
|
|
|
|
2008-05-21 00:24:31 -06:00
|
|
|
if (!mpic)
|
|
|
|
return;
|
|
|
|
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_irqsave(&mpic_lock, flags);
|
2009-04-07 12:26:54 -06:00
|
|
|
if (mpic_is_ipi(mpic, irq)) {
|
2007-01-28 22:33:18 -07:00
|
|
|
reg = mpic_ipi_read(src - mpic->ipi_vecs[0]) &
|
2005-11-17 23:18:15 -07:00
|
|
|
~MPIC_VECPRI_PRIORITY_MASK;
|
2007-01-28 22:33:18 -07:00
|
|
|
mpic_ipi_write(src - mpic->ipi_vecs[0],
|
2005-09-26 00:04:21 -06:00
|
|
|
reg | (pri << MPIC_VECPRI_PRIORITY_SHIFT));
|
|
|
|
} else {
|
2006-08-24 22:16:30 -06:00
|
|
|
reg = mpic_irq_read(src, MPIC_INFO(IRQ_VECTOR_PRI))
|
2005-11-17 23:18:15 -07:00
|
|
|
& ~MPIC_VECPRI_PRIORITY_MASK;
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_irq_write(src, MPIC_INFO(IRQ_VECTOR_PRI),
|
2005-09-26 00:04:21 -06:00
|
|
|
reg | (pri << MPIC_VECPRI_PRIORITY_SHIFT));
|
|
|
|
}
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock_irqrestore(&mpic_lock, flags);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void mpic_setup_this_cpu(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
unsigned long flags;
|
|
|
|
u32 msk = 1 << hard_smp_processor_id();
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
|
|
|
DBG("%s: setup_this_cpu(%d)\n", mpic->name, hard_smp_processor_id());
|
|
|
|
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_irqsave(&mpic_lock, flags);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* let the mpic know we want intrs. default affinity is 0xffffffff
|
|
|
|
* until changed via /proc. That's how it's done on x86. If we want
|
|
|
|
* it differently, then we should make sure we also change the default
|
2006-06-29 03:24:38 -06:00
|
|
|
* values of irq_desc[].affinity in irq.c.
|
2005-09-26 00:04:21 -06:00
|
|
|
*/
|
|
|
|
if (distribute_irqs) {
|
|
|
|
for (i = 0; i < mpic->num_sources ; i++)
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_irq_write(i, MPIC_INFO(IRQ_DESTINATION),
|
|
|
|
mpic_irq_read(i, MPIC_INFO(IRQ_DESTINATION)) | msk);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set current processor priority to 0 */
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_cpu_write(MPIC_INFO(CPU_CURRENT_TASK_PRI), 0);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock_irqrestore(&mpic_lock, flags);
|
2005-09-26 00:04:21 -06:00
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
}
|
|
|
|
|
|
|
|
int mpic_cpu_get_priority(void)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
|
2006-08-24 22:16:30 -06:00
|
|
|
return mpic_cpu_read(MPIC_INFO(CPU_CURRENT_TASK_PRI));
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void mpic_cpu_set_priority(int prio)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
|
|
|
|
prio &= MPIC_CPU_TASKPRI_MASK;
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_cpu_write(MPIC_INFO(CPU_CURRENT_TASK_PRI), prio);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void mpic_teardown_this_cpu(int secondary)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
unsigned long flags;
|
|
|
|
u32 msk = 1 << hard_smp_processor_id();
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
|
|
|
DBG("%s: teardown_this_cpu(%d)\n", mpic->name, hard_smp_processor_id());
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_lock_irqsave(&mpic_lock, flags);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* let the mpic know we don't want intrs. */
|
|
|
|
for (i = 0; i < mpic->num_sources ; i++)
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_irq_write(i, MPIC_INFO(IRQ_DESTINATION),
|
|
|
|
mpic_irq_read(i, MPIC_INFO(IRQ_DESTINATION)) & ~msk);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
/* Set current processor priority to max */
|
2006-08-24 22:16:30 -06:00
|
|
|
mpic_cpu_write(MPIC_INFO(CPU_CURRENT_TASK_PRI), 0xf);
|
2008-04-03 13:09:43 -06:00
|
|
|
/* We need to EOI the IPI since not all platforms reset the MPIC
|
|
|
|
* on boot and new interrupts wouldn't get delivered otherwise.
|
|
|
|
*/
|
|
|
|
mpic_eoi(mpic);
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2010-02-17 19:23:18 -07:00
|
|
|
raw_spin_unlock_irqrestore(&mpic_lock, flags);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-12-20 12:11:18 -07:00
|
|
|
static unsigned int _mpic_get_one_irq(struct mpic *mpic, int reg)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
2006-07-03 05:36:01 -06:00
|
|
|
u32 src;
|
2005-09-26 00:04:21 -06:00
|
|
|
|
2007-12-20 12:11:18 -07:00
|
|
|
src = mpic_cpu_read(reg) & MPIC_INFO(VECPRI_VECTOR_MASK);
|
2005-12-13 19:10:10 -07:00
|
|
|
#ifdef DEBUG_LOW
|
2007-12-20 12:11:18 -07:00
|
|
|
DBG("%s: get_one_irq(reg 0x%x): %d\n", mpic->name, reg, src);
|
2005-12-13 19:10:10 -07:00
|
|
|
#endif
|
2007-04-30 14:38:11 -06:00
|
|
|
if (unlikely(src == mpic->spurious_vec)) {
|
|
|
|
if (mpic->flags & MPIC_SPV_EOI)
|
|
|
|
mpic_eoi(mpic);
|
2006-07-03 05:36:01 -06:00
|
|
|
return NO_IRQ;
|
2007-04-30 14:38:11 -06:00
|
|
|
}
|
2007-07-20 17:55:21 -06:00
|
|
|
if (unlikely(mpic->protected && test_bit(src, mpic->protected))) {
|
|
|
|
if (printk_ratelimit())
|
|
|
|
printk(KERN_WARNING "%s: Got protected source %d !\n",
|
|
|
|
mpic->name, (int)src);
|
|
|
|
mpic_eoi(mpic);
|
|
|
|
return NO_IRQ;
|
|
|
|
}
|
|
|
|
|
2006-07-03 05:36:01 -06:00
|
|
|
return irq_linear_revmap(mpic->irqhost, src);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2007-12-20 12:11:18 -07:00
|
|
|
unsigned int mpic_get_one_irq(struct mpic *mpic)
|
|
|
|
{
|
|
|
|
return _mpic_get_one_irq(mpic, MPIC_INFO(CPU_INTACK));
|
|
|
|
}
|
|
|
|
|
2006-10-07 06:08:26 -06:00
|
|
|
unsigned int mpic_get_irq(void)
|
2005-09-26 00:04:21 -06:00
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
|
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
2006-10-07 06:08:26 -06:00
|
|
|
return mpic_get_one_irq(mpic);
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
|
|
|
|
2009-01-07 14:53:29 -07:00
|
|
|
unsigned int mpic_get_coreint_irq(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_BOOKE
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
u32 src;
|
|
|
|
|
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
|
|
|
src = mfspr(SPRN_EPR);
|
|
|
|
|
|
|
|
if (unlikely(src == mpic->spurious_vec)) {
|
|
|
|
if (mpic->flags & MPIC_SPV_EOI)
|
|
|
|
mpic_eoi(mpic);
|
|
|
|
return NO_IRQ;
|
|
|
|
}
|
|
|
|
if (unlikely(mpic->protected && test_bit(src, mpic->protected))) {
|
|
|
|
if (printk_ratelimit())
|
|
|
|
printk(KERN_WARNING "%s: Got protected source %d !\n",
|
|
|
|
mpic->name, (int)src);
|
|
|
|
return NO_IRQ;
|
|
|
|
}
|
|
|
|
|
|
|
|
return irq_linear_revmap(mpic->irqhost, src);
|
|
|
|
#else
|
|
|
|
return NO_IRQ;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-12-20 12:11:18 -07:00
|
|
|
unsigned int mpic_get_mcirq(void)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
|
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
|
|
|
return _mpic_get_one_irq(mpic, MPIC_INFO(CPU_MCACK));
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
void mpic_request_ipis(void)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
2008-10-09 19:56:50 -06:00
|
|
|
int i;
|
2005-09-26 00:04:21 -06:00
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
2010-02-06 00:47:20 -07:00
|
|
|
printk(KERN_INFO "mpic: requesting IPIs...\n");
|
2006-07-03 05:36:01 -06:00
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
unsigned int vipi = irq_create_mapping(mpic->irqhost,
|
2007-01-28 22:33:18 -07:00
|
|
|
mpic->ipi_vecs[0] + i);
|
2006-07-03 05:36:01 -06:00
|
|
|
if (vipi == NO_IRQ) {
|
2008-10-09 19:56:50 -06:00
|
|
|
printk(KERN_ERR "Failed to map %s\n", smp_ipi_name[i]);
|
|
|
|
continue;
|
2007-05-14 14:59:12 -06:00
|
|
|
}
|
2008-10-09 19:56:50 -06:00
|
|
|
smp_request_message_ipi(vipi, i);
|
2006-07-03 05:36:01 -06:00
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
}
|
2005-10-20 01:09:51 -06:00
|
|
|
|
2010-05-06 02:01:46 -06:00
|
|
|
static void mpic_send_ipi(unsigned int ipi_no, const struct cpumask *cpu_mask)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
|
|
|
|
BUG_ON(mpic == NULL);
|
|
|
|
|
|
|
|
#ifdef DEBUG_IPI
|
|
|
|
DBG("%s: send_ipi(ipi_no: %d)\n", mpic->name, ipi_no);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
mpic_cpu_write(MPIC_INFO(CPU_IPI_DISPATCH_0) +
|
|
|
|
ipi_no * MPIC_INFO(CPU_IPI_DISPATCH_STRIDE),
|
|
|
|
mpic_physmask(cpumask_bits(cpu_mask)[0]));
|
|
|
|
}
|
|
|
|
|
2005-10-20 01:09:51 -06:00
|
|
|
void smp_mpic_message_pass(int target, int msg)
|
|
|
|
{
|
2010-05-06 02:01:46 -06:00
|
|
|
cpumask_var_t tmp;
|
|
|
|
|
2005-10-20 01:09:51 -06:00
|
|
|
/* make sure we're sending something that translates to an IPI */
|
|
|
|
if ((unsigned int)msg > 3) {
|
|
|
|
printk("SMP %d: smp_message_pass: unknown msg %d\n",
|
|
|
|
smp_processor_id(), msg);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
switch (target) {
|
|
|
|
case MSG_ALL:
|
2010-05-06 02:01:46 -06:00
|
|
|
mpic_send_ipi(msg, cpu_online_mask);
|
2005-10-20 01:09:51 -06:00
|
|
|
break;
|
|
|
|
case MSG_ALL_BUT_SELF:
|
2010-05-06 02:01:46 -06:00
|
|
|
alloc_cpumask_var(&tmp, GFP_NOWAIT);
|
|
|
|
cpumask_andnot(tmp, cpu_online_mask,
|
|
|
|
cpumask_of(smp_processor_id()));
|
|
|
|
mpic_send_ipi(msg, tmp);
|
|
|
|
free_cpumask_var(tmp);
|
2005-10-20 01:09:51 -06:00
|
|
|
break;
|
|
|
|
default:
|
2010-05-06 02:01:46 -06:00
|
|
|
mpic_send_ipi(msg, cpumask_of(target));
|
2005-10-20 01:09:51 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-02-08 00:34:04 -07:00
|
|
|
|
|
|
|
int __init smp_mpic_probe(void)
|
|
|
|
{
|
|
|
|
int nr_cpus;
|
|
|
|
|
|
|
|
DBG("smp_mpic_probe()...\n");
|
|
|
|
|
2010-05-06 02:01:46 -06:00
|
|
|
nr_cpus = cpumask_weight(cpu_possible_mask);
|
2007-02-08 00:34:04 -07:00
|
|
|
|
|
|
|
DBG("nr_cpus: %d\n", nr_cpus);
|
|
|
|
|
|
|
|
if (nr_cpus > 1)
|
|
|
|
mpic_request_ipis();
|
|
|
|
|
|
|
|
return nr_cpus;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __devinit smp_mpic_setup_cpu(int cpu)
|
|
|
|
{
|
|
|
|
mpic_setup_this_cpu();
|
|
|
|
}
|
2010-06-29 03:42:26 -06:00
|
|
|
|
|
|
|
void mpic_reset_core(int cpu)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpic_primary;
|
|
|
|
u32 pir;
|
|
|
|
int cpuid = get_hard_smp_processor_id(cpu);
|
|
|
|
|
|
|
|
/* Set target bit for core reset */
|
|
|
|
pir = mpic_read(mpic->gregs, MPIC_INFO(GREG_PROCESSOR_INIT));
|
|
|
|
pir |= (1 << cpuid);
|
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_PROCESSOR_INIT), pir);
|
|
|
|
mpic_read(mpic->gregs, MPIC_INFO(GREG_PROCESSOR_INIT));
|
|
|
|
|
|
|
|
/* Restore target bit after reset complete */
|
|
|
|
pir &= ~(1 << cpuid);
|
|
|
|
mpic_write(mpic->gregs, MPIC_INFO(GREG_PROCESSOR_INIT), pir);
|
|
|
|
mpic_read(mpic->gregs, MPIC_INFO(GREG_PROCESSOR_INIT));
|
|
|
|
}
|
2005-09-26 00:04:21 -06:00
|
|
|
#endif /* CONFIG_SMP */
|
2007-05-02 00:33:41 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static int mpic_suspend(struct sys_device *dev, pm_message_t state)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = container_of(dev, struct mpic, sysdev);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < mpic->num_sources; i++) {
|
|
|
|
mpic->save_data[i].vecprio =
|
|
|
|
mpic_irq_read(i, MPIC_INFO(IRQ_VECTOR_PRI));
|
|
|
|
mpic->save_data[i].dest =
|
|
|
|
mpic_irq_read(i, MPIC_INFO(IRQ_DESTINATION));
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int mpic_resume(struct sys_device *dev)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = container_of(dev, struct mpic, sysdev);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < mpic->num_sources; i++) {
|
|
|
|
mpic_irq_write(i, MPIC_INFO(IRQ_VECTOR_PRI),
|
|
|
|
mpic->save_data[i].vecprio);
|
|
|
|
mpic_irq_write(i, MPIC_INFO(IRQ_DESTINATION),
|
|
|
|
mpic->save_data[i].dest);
|
|
|
|
|
|
|
|
#ifdef CONFIG_MPIC_U3_HT_IRQS
|
2010-06-12 09:36:48 -06:00
|
|
|
if (mpic->fixups) {
|
2007-05-02 00:33:41 -06:00
|
|
|
struct mpic_irq_fixup *fixup = &mpic->fixups[i];
|
|
|
|
|
|
|
|
if (fixup->base) {
|
|
|
|
/* we use the lowest bit in an inverted meaning */
|
|
|
|
if ((mpic->save_data[i].fixup_data & 1) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Enable and configure */
|
|
|
|
writeb(0x10 + 2 * fixup->index, fixup->base + 2);
|
|
|
|
|
|
|
|
writel(mpic->save_data[i].fixup_data & ~1,
|
|
|
|
fixup->base + 4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} /* end for loop */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct sysdev_class mpic_sysclass = {
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
.resume = mpic_resume,
|
|
|
|
.suspend = mpic_suspend,
|
|
|
|
#endif
|
2007-12-19 18:09:39 -07:00
|
|
|
.name = "mpic",
|
2007-05-02 00:33:41 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int mpic_init_sys(void)
|
|
|
|
{
|
|
|
|
struct mpic *mpic = mpics;
|
|
|
|
int error, id = 0;
|
|
|
|
|
|
|
|
error = sysdev_class_register(&mpic_sysclass);
|
|
|
|
|
|
|
|
while (mpic && !error) {
|
|
|
|
mpic->sysdev.cls = &mpic_sysclass;
|
|
|
|
mpic->sysdev.id = id++;
|
|
|
|
error = sysdev_register(&mpic->sysdev);
|
|
|
|
mpic = mpic->next;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
device_initcall(mpic_init_sys);
|