2005-10-28 13:35:50 +08:00
|
|
|
/*
|
|
|
|
* arch/powerpc/platforms/pseries/xics.c
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* Copyright 2000 IBM Corporation.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
2006-07-03 19:36:01 +08:00
|
|
|
|
|
|
|
#undef DEBUG
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/gfp.h>
|
|
|
|
#include <linux/radix-tree.h>
|
|
|
|
#include <linux/cpu.h>
|
2006-07-03 19:36:01 +08:00
|
|
|
|
2006-03-21 17:45:59 +08:00
|
|
|
#include <asm/firmware.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/rtas.h>
|
|
|
|
#include <asm/hvcall.h>
|
|
|
|
#include <asm/machdep.h>
|
2005-10-28 09:47:17 +08:00
|
|
|
#include <asm/i8259.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-10-28 13:35:50 +08:00
|
|
|
#include "xics.h"
|
2006-07-19 06:01:28 +08:00
|
|
|
#include "plpar_wrappers.h"
|
2005-10-28 13:35:50 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define XICS_IPI 2
|
|
|
|
#define XICS_IRQ_SPURIOUS 0
|
|
|
|
|
|
|
|
/* Want a priority other than 0. Various HW issues require this. */
|
|
|
|
#define DEFAULT_PRIORITY 5
|
|
|
|
|
2005-10-28 13:35:50 +08:00
|
|
|
/*
|
2005-04-17 06:20:36 +08:00
|
|
|
* Mark IPIs as higher priority so we can take them inside interrupts that
|
2006-07-02 10:29:22 +08:00
|
|
|
* arent marked IRQF_DISABLED
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
#define IPI_PRIORITY 4
|
|
|
|
|
|
|
|
struct xics_ipl {
|
|
|
|
union {
|
|
|
|
u32 word;
|
|
|
|
u8 bytes[4];
|
|
|
|
} xirr_poll;
|
|
|
|
union {
|
|
|
|
u32 word;
|
|
|
|
u8 bytes[4];
|
|
|
|
} xirr;
|
|
|
|
u32 dummy;
|
|
|
|
union {
|
|
|
|
u32 word;
|
|
|
|
u8 bytes[4];
|
|
|
|
} qirr;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct xics_ipl __iomem *xics_per_cpu[NR_CPUS];
|
|
|
|
|
|
|
|
static unsigned int default_server = 0xFF;
|
2005-09-12 11:12:11 +08:00
|
|
|
static unsigned int default_distrib_server = 0;
|
|
|
|
static unsigned int interrupt_server_size = 8;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static struct irq_host *xics_host;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* XICS only has a single IPI, so encode the messages per CPU
|
|
|
|
*/
|
|
|
|
struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned;
|
|
|
|
|
|
|
|
/* RTAS service tokens */
|
2005-09-12 11:12:11 +08:00
|
|
|
static int ibm_get_xive;
|
|
|
|
static int ibm_set_xive;
|
|
|
|
static int ibm_int_on;
|
|
|
|
static int ibm_int_off;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
/* Direct HW low level accessors */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static inline unsigned int direct_xirr_info_get(int n_cpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
return in_be32(&xics_per_cpu[n_cpu]->xirr.word);
|
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static inline void direct_xirr_info_set(int n_cpu, int value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
out_be32(&xics_per_cpu[n_cpu]->xirr.word, value);
|
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static inline void direct_cppr_info(int n_cpu, u8 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
out_8(&xics_per_cpu[n_cpu]->xirr.bytes[0], value);
|
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static inline void direct_qirr_info(int n_cpu, u8 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
out_8(&xics_per_cpu[n_cpu]->qirr.bytes[0], value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
/* LPAR low level accessors */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static inline unsigned int lpar_xirr_info_get(int n_cpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned long lpar_rc;
|
2005-10-28 13:35:50 +08:00
|
|
|
unsigned long return_value;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
lpar_rc = plpar_xirr(&return_value);
|
2006-03-30 20:49:40 +08:00
|
|
|
if (lpar_rc != H_SUCCESS)
|
2005-10-28 13:35:50 +08:00
|
|
|
panic(" bad return code xirr - rc = %lx \n", lpar_rc);
|
2006-07-03 19:36:01 +08:00
|
|
|
return (unsigned int)return_value;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static inline void lpar_xirr_info_set(int n_cpu, int value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
unsigned long val64 = value & 0xffffffff;
|
|
|
|
|
|
|
|
lpar_rc = plpar_eoi(val64);
|
2006-03-30 20:49:40 +08:00
|
|
|
if (lpar_rc != H_SUCCESS)
|
2005-04-17 06:20:36 +08:00
|
|
|
panic("bad return code EOI - rc = %ld, value=%lx\n", lpar_rc,
|
2005-10-28 13:35:50 +08:00
|
|
|
val64);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static inline void lpar_cppr_info(int n_cpu, u8 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
|
|
|
lpar_rc = plpar_cppr(value);
|
2006-03-30 20:49:40 +08:00
|
|
|
if (lpar_rc != H_SUCCESS)
|
2005-10-28 13:35:50 +08:00
|
|
|
panic("bad return code cppr - rc = %lx\n", lpar_rc);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static inline void lpar_qirr_info(int n_cpu , u8 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned long lpar_rc;
|
|
|
|
|
|
|
|
lpar_rc = plpar_ipi(get_hard_smp_processor_id(n_cpu), value);
|
2006-03-30 20:49:40 +08:00
|
|
|
if (lpar_rc != H_SUCCESS)
|
2005-10-28 13:35:50 +08:00
|
|
|
panic("bad return code qirr - rc = %lx\n", lpar_rc);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
/* High level handlers and init code */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2006-07-03 19:36:01 +08:00
|
|
|
static int get_irq_server(unsigned int virq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned int server;
|
|
|
|
/* For the moment only implement delivery to all cpus or one cpu */
|
2006-07-03 19:36:01 +08:00
|
|
|
cpumask_t cpumask = irq_desc[virq].affinity;
|
2005-04-17 06:20:36 +08:00
|
|
|
cpumask_t tmp = CPU_MASK_NONE;
|
|
|
|
|
|
|
|
if (!distribute_irqs)
|
|
|
|
return default_server;
|
|
|
|
|
|
|
|
if (cpus_equal(cpumask, CPU_MASK_ALL)) {
|
|
|
|
server = default_distrib_server;
|
|
|
|
} else {
|
|
|
|
cpus_and(tmp, cpu_online_map, cpumask);
|
|
|
|
|
|
|
|
if (cpus_empty(tmp))
|
|
|
|
server = default_distrib_server;
|
|
|
|
else
|
|
|
|
server = get_hard_smp_processor_id(first_cpu(tmp));
|
|
|
|
}
|
|
|
|
|
|
|
|
return server;
|
|
|
|
|
|
|
|
}
|
|
|
|
#else
|
2006-07-03 19:36:01 +08:00
|
|
|
static int get_irq_server(unsigned int virq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
return default_server;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
|
|
|
|
static void xics_unmask_irq(unsigned int virq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned int irq;
|
|
|
|
int call_status;
|
|
|
|
unsigned int server;
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
pr_debug("xics: unmask virq %d\n", virq);
|
|
|
|
|
|
|
|
irq = (unsigned int)irq_map[virq].hwirq;
|
|
|
|
pr_debug(" -> map to hwirq 0x%x\n", irq);
|
|
|
|
if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
server = get_irq_server(virq);
|
2006-07-03 17:32:51 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq, server,
|
|
|
|
DEFAULT_PRIORITY);
|
|
|
|
if (call_status != 0) {
|
2005-09-12 11:12:11 +08:00
|
|
|
printk(KERN_ERR "xics_enable_irq: irq=%u: ibm_set_xive "
|
|
|
|
"returned %d\n", irq, call_status);
|
|
|
|
printk("set_xive %x, server %x\n", ibm_set_xive, server);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now unmask the interrupt (often a no-op) */
|
|
|
|
call_status = rtas_call(ibm_int_on, 1, 1, NULL, irq);
|
|
|
|
if (call_status != 0) {
|
2005-09-12 11:12:11 +08:00
|
|
|
printk(KERN_ERR "xics_enable_irq: irq=%u: ibm_int_on "
|
|
|
|
"returned %d\n", irq, call_status);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static void xics_mask_real_irq(unsigned int irq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int call_status;
|
|
|
|
|
|
|
|
if (irq == XICS_IPI)
|
|
|
|
return;
|
|
|
|
|
|
|
|
call_status = rtas_call(ibm_int_off, 1, 1, NULL, irq);
|
|
|
|
if (call_status != 0) {
|
2005-09-12 11:12:11 +08:00
|
|
|
printk(KERN_ERR "xics_disable_real_irq: irq=%u: "
|
|
|
|
"ibm_int_off returned %d\n", irq, call_status);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Have to set XIVE to 0xff to be able to remove a slot */
|
2006-12-20 21:29:40 +08:00
|
|
|
call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq,
|
|
|
|
default_server, 0xff);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (call_status != 0) {
|
2005-09-12 11:12:11 +08:00
|
|
|
printk(KERN_ERR "xics_disable_irq: irq=%u: ibm_set_xive(0xff)"
|
|
|
|
" returned %d\n", irq, call_status);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static void xics_mask_irq(unsigned int virq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned int irq;
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
pr_debug("xics: mask virq %d\n", virq);
|
|
|
|
|
|
|
|
irq = (unsigned int)irq_map[virq].hwirq;
|
|
|
|
if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
|
|
|
|
return;
|
|
|
|
xics_mask_real_irq(irq);
|
2006-07-03 17:32:51 +08:00
|
|
|
}
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static unsigned int xics_startup(unsigned int virq)
|
2006-07-03 17:32:51 +08:00
|
|
|
{
|
|
|
|
unsigned int irq;
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
/* force a reverse mapping of the interrupt so it gets in the cache */
|
|
|
|
irq = (unsigned int)irq_map[virq].hwirq;
|
|
|
|
irq_radix_revmap(xics_host, irq);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
/* unmask it */
|
2006-07-03 17:32:51 +08:00
|
|
|
xics_unmask_irq(virq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static void xics_eoi_direct(unsigned int virq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
2006-07-03 19:36:01 +08:00
|
|
|
unsigned int irq = (unsigned int)irq_map[virq].hwirq;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
iosync();
|
2006-07-03 19:36:01 +08:00
|
|
|
direct_xirr_info_set(cpu, (0xff << 24) | irq);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static void xics_eoi_lpar(unsigned int virq)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
2006-07-03 19:36:01 +08:00
|
|
|
unsigned int irq = (unsigned int)irq_map[virq].hwirq;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
iosync();
|
2006-07-03 19:36:01 +08:00
|
|
|
lpar_xirr_info_set(cpu, (0xff << 24) | irq);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static inline unsigned int xics_remap_irq(unsigned int vec)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-07-03 19:36:01 +08:00
|
|
|
unsigned int irq;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
vec &= 0x00ffffff;
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
if (vec == XICS_IRQ_SPURIOUS)
|
|
|
|
return NO_IRQ;
|
2006-07-03 19:36:01 +08:00
|
|
|
irq = irq_radix_revmap(xics_host, vec);
|
2006-07-03 17:32:51 +08:00
|
|
|
if (likely(irq != NO_IRQ))
|
2006-07-03 19:36:01 +08:00
|
|
|
return irq;
|
2006-07-03 17:32:51 +08:00
|
|
|
|
|
|
|
printk(KERN_ERR "Interrupt %u (real) is invalid,"
|
|
|
|
" disabling it.\n", vec);
|
|
|
|
xics_mask_real_irq(vec);
|
|
|
|
return NO_IRQ;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-10-07 20:08:26 +08:00
|
|
|
static unsigned int xics_get_irq_direct(void)
|
2006-07-03 17:32:51 +08:00
|
|
|
{
|
|
|
|
unsigned int cpu = smp_processor_id();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
return xics_remap_irq(direct_xirr_info_get(cpu));
|
|
|
|
}
|
|
|
|
|
2006-10-07 20:08:26 +08:00
|
|
|
static unsigned int xics_get_irq_lpar(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-07-03 17:32:51 +08:00
|
|
|
unsigned int cpu = smp_processor_id();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
return xics_remap_irq(lpar_xirr_info_get(cpu));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2005-04-17 06:20:36 +08:00
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
static irqreturn_t xics_ipi_dispatch(int cpu)
|
2006-07-03 17:32:51 +08:00
|
|
|
{
|
2005-04-17 06:20:36 +08:00
|
|
|
WARN_ON(cpu_is_offline(cpu));
|
|
|
|
|
|
|
|
while (xics_ipi_message[cpu].value) {
|
|
|
|
if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION,
|
|
|
|
&xics_ipi_message[cpu].value)) {
|
|
|
|
mb();
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
smp_message_recv(PPC_MSG_CALL_FUNCTION);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
if (test_and_clear_bit(PPC_MSG_RESCHEDULE,
|
|
|
|
&xics_ipi_message[cpu].value)) {
|
|
|
|
mb();
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
smp_message_recv(PPC_MSG_RESCHEDULE);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#if 0
|
|
|
|
if (test_and_clear_bit(PPC_MSG_MIGRATE_TASK,
|
|
|
|
&xics_ipi_message[cpu].value)) {
|
|
|
|
mb();
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
smp_message_recv(PPC_MSG_MIGRATE_TASK);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#endif
|
2005-12-04 15:39:43 +08:00
|
|
|
#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
|
2005-04-17 06:20:36 +08:00
|
|
|
if (test_and_clear_bit(PPC_MSG_DEBUGGER_BREAK,
|
|
|
|
&xics_ipi_message[cpu].value)) {
|
|
|
|
mb();
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
static irqreturn_t xics_ipi_action_direct(int irq, void *dev_id)
|
2006-07-03 17:32:51 +08:00
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
direct_qirr_info(cpu, 0xff);
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
return xics_ipi_dispatch(cpu);
|
2006-07-03 17:32:51 +08:00
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
static irqreturn_t xics_ipi_action_lpar(int irq, void *dev_id)
|
2006-07-03 17:32:51 +08:00
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
lpar_qirr_info(cpu, 0xff);
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
return xics_ipi_dispatch(cpu);
|
2006-07-03 17:32:51 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void xics_cause_IPI(int cpu)
|
|
|
|
{
|
2006-07-03 17:32:51 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
lpar_qirr_info(cpu, IPI_PRIORITY);
|
|
|
|
else
|
|
|
|
direct_qirr_info(cpu, IPI_PRIORITY);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-07-03 17:32:51 +08:00
|
|
|
|
2005-05-06 14:28:56 +08:00
|
|
|
#endif /* CONFIG_SMP */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static void xics_set_cpu_priority(int cpu, unsigned char cppr)
|
|
|
|
{
|
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
lpar_cppr_info(cpu, cppr);
|
|
|
|
else
|
|
|
|
direct_cppr_info(cpu, cppr);
|
|
|
|
iosync();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void xics_set_affinity(unsigned int virq, cpumask_t cpumask)
|
|
|
|
{
|
|
|
|
unsigned int irq;
|
|
|
|
int status;
|
|
|
|
int xics_status[2];
|
|
|
|
unsigned long newmask;
|
|
|
|
cpumask_t tmp = CPU_MASK_NONE;
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
irq = (unsigned int)irq_map[virq].hwirq;
|
|
|
|
if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
|
2006-07-03 17:32:51 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
|
|
|
|
|
|
|
|
if (status) {
|
|
|
|
printk(KERN_ERR "xics_set_affinity: irq=%u ibm,get-xive "
|
|
|
|
"returns %d\n", irq, status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For the moment only implement delivery to all cpus or one cpu */
|
|
|
|
if (cpus_equal(cpumask, CPU_MASK_ALL)) {
|
|
|
|
newmask = default_distrib_server;
|
|
|
|
} else {
|
|
|
|
cpus_and(tmp, cpu_online_map, cpumask);
|
|
|
|
if (cpus_empty(tmp))
|
|
|
|
return;
|
|
|
|
newmask = get_hard_smp_processor_id(first_cpu(tmp));
|
|
|
|
}
|
|
|
|
|
|
|
|
status = rtas_call(ibm_set_xive, 3, 1, NULL,
|
|
|
|
irq, newmask, xics_status[1]);
|
|
|
|
|
|
|
|
if (status) {
|
|
|
|
printk(KERN_ERR "xics_set_affinity: irq=%u ibm,set-xive "
|
|
|
|
"returns %d\n", irq, status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
void xics_setup_cpu(void)
|
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
|
|
|
xics_set_cpu_priority(cpu, 0xff);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Put the calling processor into the GIQ. This is really only
|
|
|
|
* necessary from a secondary thread as the OF start-cpu interface
|
|
|
|
* performs this function for us on primary threads.
|
|
|
|
*
|
|
|
|
* XXX: undo of teardown on kexec needs this too, as may hotplug
|
|
|
|
*/
|
2006-07-28 05:29:00 +08:00
|
|
|
rtas_set_indicator_fast(GLOBAL_INTERRUPT_QUEUE,
|
2006-07-03 19:36:01 +08:00
|
|
|
(1UL << interrupt_server_size) - 1 - default_distrib_server, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-03 17:32:51 +08:00
|
|
|
static struct irq_chip xics_pic_direct = {
|
|
|
|
.typename = " XICS ",
|
|
|
|
.startup = xics_startup,
|
|
|
|
.mask = xics_mask_irq,
|
|
|
|
.unmask = xics_unmask_irq,
|
|
|
|
.eoi = xics_eoi_direct,
|
|
|
|
.set_affinity = xics_set_affinity
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static struct irq_chip xics_pic_lpar = {
|
|
|
|
.typename = " XICS ",
|
|
|
|
.startup = xics_startup,
|
|
|
|
.mask = xics_mask_irq,
|
|
|
|
.unmask = xics_unmask_irq,
|
|
|
|
.eoi = xics_eoi_lpar,
|
|
|
|
.set_affinity = xics_set_affinity
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static int xics_host_match(struct irq_host *h, struct device_node *node)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-07-03 19:36:01 +08:00
|
|
|
/* IBM machines have interrupt parents of various funky types for things
|
|
|
|
* like vdevices, events, etc... The trick we use here is to match
|
|
|
|
* everything here except the legacy 8259 which is compatible "chrp,iic"
|
|
|
|
*/
|
2007-05-03 15:26:52 +08:00
|
|
|
return !of_device_is_compatible(node, "chrp,iic");
|
2006-07-03 19:36:01 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static int xics_host_map_direct(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 19:44:42 +08:00
|
|
|
irq_hw_number_t hw)
|
2006-07-03 19:36:01 +08: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 19:44:42 +08:00
|
|
|
pr_debug("xics: map_direct virq %d, hwirq 0x%lx\n", virq, hw);
|
2006-07-03 19:36:01 +08:00
|
|
|
|
|
|
|
get_irq_desc(virq)->status |= IRQ_LEVEL;
|
|
|
|
set_irq_chip_and_handler(virq, &xics_pic_direct, handle_fasteoi_irq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int xics_host_map_lpar(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 19:44:42 +08:00
|
|
|
irq_hw_number_t hw)
|
2006-07-03 19:36:01 +08: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 19:44:42 +08:00
|
|
|
pr_debug("xics: map_direct virq %d, hwirq 0x%lx\n", virq, hw);
|
2006-07-03 19:36:01 +08:00
|
|
|
|
|
|
|
get_irq_desc(virq)->status |= IRQ_LEVEL;
|
|
|
|
set_irq_chip_and_handler(virq, &xics_pic_lpar, handle_fasteoi_irq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int xics_host_xlate(struct irq_host *h, struct device_node *ct,
|
|
|
|
u32 *intspec, unsigned int intsize,
|
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_flags)
|
|
|
|
|
|
|
|
{
|
|
|
|
/* Current xics implementation translates everything
|
|
|
|
* to level. It is not technically right for MSIs but this
|
|
|
|
* is irrelevant at this point. We might get smarter in the future
|
2005-05-06 14:28:56 +08:00
|
|
|
*/
|
2006-07-03 19:36:01 +08:00
|
|
|
*out_hwirq = intspec[0];
|
|
|
|
*out_flags = IRQ_TYPE_LEVEL_LOW;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct irq_host_ops xics_host_direct_ops = {
|
|
|
|
.match = xics_host_match,
|
|
|
|
.map = xics_host_map_direct,
|
|
|
|
.xlate = xics_host_xlate,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct irq_host_ops xics_host_lpar_ops = {
|
|
|
|
.match = xics_host_match,
|
|
|
|
.map = xics_host_map_lpar,
|
|
|
|
.xlate = xics_host_xlate,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void __init xics_init_host(void)
|
|
|
|
{
|
|
|
|
struct irq_host_ops *ops;
|
|
|
|
|
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
ops = &xics_host_lpar_ops;
|
|
|
|
else
|
|
|
|
ops = &xics_host_direct_ops;
|
|
|
|
xics_host = irq_alloc_host(IRQ_HOST_MAP_TREE, 0, ops,
|
|
|
|
XICS_IRQ_SPURIOUS);
|
|
|
|
BUG_ON(xics_host == NULL);
|
|
|
|
irq_set_default_host(xics_host);
|
2005-05-06 14:28:56 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static void __init xics_map_one_cpu(int hw_id, unsigned long addr,
|
|
|
|
unsigned long size)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-07-03 19:36:01 +08:00
|
|
|
#ifdef CONFIG_SMP
|
2005-04-17 06:20:36 +08:00
|
|
|
int i;
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
/* This may look gross but it's good enough for now, we don't quite
|
|
|
|
* have a hard -> linux processor id matching.
|
|
|
|
*/
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
if (!cpu_present(i))
|
|
|
|
continue;
|
|
|
|
if (hw_id == get_hard_smp_processor_id(i)) {
|
|
|
|
xics_per_cpu[i] = ioremap(addr, size);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (hw_id != 0)
|
|
|
|
return;
|
|
|
|
xics_per_cpu[0] = ioremap(addr, size);
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
static void __init xics_init_one_node(struct device_node *np,
|
|
|
|
unsigned int *indx)
|
|
|
|
{
|
|
|
|
unsigned int ilen;
|
2006-07-12 13:39:43 +08:00
|
|
|
const u32 *ireg;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
/* This code does the theorically broken assumption that the interrupt
|
|
|
|
* server numbers are the same as the hard CPU numbers.
|
|
|
|
* This happens to be the case so far but we are playing with fire...
|
|
|
|
* should be fixed one of these days. -BenH.
|
|
|
|
*/
|
2007-04-03 20:26:41 +08:00
|
|
|
ireg = of_get_property(np, "ibm,interrupt-server-ranges", NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
/* Do that ever happen ? we'll know soon enough... but even good'old
|
|
|
|
* f80 does have that property ..
|
|
|
|
*/
|
|
|
|
WARN_ON(ireg == NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ireg) {
|
|
|
|
/*
|
|
|
|
* set node starting index for this node
|
|
|
|
*/
|
2006-07-03 19:36:01 +08:00
|
|
|
*indx = *ireg;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2007-04-03 20:26:41 +08:00
|
|
|
ireg = of_get_property(np, "reg", &ilen);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ireg)
|
|
|
|
panic("xics_init_IRQ: can't find interrupt reg property");
|
2005-10-28 13:35:50 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
while (ilen >= (4 * sizeof(u32))) {
|
|
|
|
unsigned long addr, size;
|
|
|
|
|
|
|
|
/* XXX Use proper OF parsing code here !!! */
|
|
|
|
addr = (unsigned long)*ireg++ << 32;
|
|
|
|
ilen -= sizeof(u32);
|
|
|
|
addr |= *ireg++;
|
|
|
|
ilen -= sizeof(u32);
|
|
|
|
size = (unsigned long)*ireg++ << 32;
|
|
|
|
ilen -= sizeof(u32);
|
|
|
|
size |= *ireg++;
|
|
|
|
ilen -= sizeof(u32);
|
|
|
|
xics_map_one_cpu(*indx, addr, size);
|
|
|
|
(*indx)++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void __init xics_setup_8259_cascade(void)
|
|
|
|
{
|
|
|
|
struct device_node *np, *old, *found = NULL;
|
|
|
|
int cascade, naddr;
|
2006-07-12 13:39:43 +08:00
|
|
|
const u32 *addrp;
|
2006-07-03 19:36:01 +08:00
|
|
|
unsigned long intack = 0;
|
|
|
|
|
|
|
|
for_each_node_by_type(np, "interrupt-controller")
|
2007-05-03 15:26:52 +08:00
|
|
|
if (of_device_is_compatible(np, "chrp,iic")) {
|
2006-07-03 19:36:01 +08:00
|
|
|
found = np;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (found == NULL) {
|
|
|
|
printk(KERN_DEBUG "xics: no ISA interrupt controller\n");
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-07-03 19:36:01 +08:00
|
|
|
cascade = irq_of_parse_and_map(found, 0);
|
|
|
|
if (cascade == NO_IRQ) {
|
|
|
|
printk(KERN_ERR "xics: failed to map cascade interrupt");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pr_debug("xics: cascade mapped to irq %d\n", cascade);
|
|
|
|
|
|
|
|
for (old = of_node_get(found); old != NULL ; old = np) {
|
|
|
|
np = of_get_parent(old);
|
|
|
|
of_node_put(old);
|
|
|
|
if (np == NULL)
|
|
|
|
break;
|
|
|
|
if (strcmp(np->name, "pci") != 0)
|
|
|
|
continue;
|
2007-04-03 20:26:41 +08:00
|
|
|
addrp = of_get_property(np, "8259-interrupt-acknowledge", NULL);
|
2006-07-03 19:36:01 +08:00
|
|
|
if (addrp == NULL)
|
|
|
|
continue;
|
2007-04-03 08:56:50 +08:00
|
|
|
naddr = of_n_addr_cells(np);
|
2006-07-03 19:36:01 +08:00
|
|
|
intack = addrp[naddr-1];
|
|
|
|
if (naddr > 1)
|
|
|
|
intack |= ((unsigned long)addrp[naddr-2]) << 32;
|
|
|
|
}
|
|
|
|
if (intack)
|
|
|
|
printk(KERN_DEBUG "xics: PCI 8259 intack at 0x%016lx\n", intack);
|
|
|
|
i8259_init(found, intack);
|
|
|
|
of_node_put(found);
|
|
|
|
set_irq_chained_handler(cascade, pseries_8259_cascade);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-11-17 20:12:24 +08:00
|
|
|
static struct device_node *cpuid_to_of_node(int cpu)
|
|
|
|
{
|
|
|
|
struct device_node *np;
|
|
|
|
u32 hcpuid = get_hard_smp_processor_id(cpu);
|
|
|
|
|
|
|
|
for_each_node_by_type(np, "cpu") {
|
|
|
|
int i, len;
|
|
|
|
const u32 *intserv;
|
|
|
|
|
2007-04-03 20:26:41 +08:00
|
|
|
intserv = of_get_property(np, "ibm,ppc-interrupt-server#s",
|
|
|
|
&len);
|
2006-11-17 20:12:24 +08:00
|
|
|
|
|
|
|
if (!intserv)
|
2007-04-03 20:26:41 +08:00
|
|
|
intserv = of_get_property(np, "reg", &len);
|
2006-11-17 20:12:24 +08:00
|
|
|
|
|
|
|
i = len / sizeof(u32);
|
|
|
|
|
|
|
|
while (i--)
|
|
|
|
if (intserv[i] == hcpuid)
|
|
|
|
return np;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
void __init xics_init_IRQ(void)
|
|
|
|
{
|
2006-11-17 20:12:24 +08:00
|
|
|
int i, j;
|
2006-07-03 19:36:01 +08:00
|
|
|
struct device_node *np;
|
2006-07-12 13:39:43 +08:00
|
|
|
u32 ilen, indx = 0;
|
2006-11-17 20:12:24 +08:00
|
|
|
const u32 *ireg, *isize;
|
2006-07-03 19:36:01 +08:00
|
|
|
int found = 0;
|
2006-11-17 20:12:24 +08:00
|
|
|
u32 hcpuid;
|
2006-07-03 19:36:01 +08:00
|
|
|
|
|
|
|
ppc64_boot_msg(0x20, "XICS Init");
|
|
|
|
|
|
|
|
ibm_get_xive = rtas_token("ibm,get-xive");
|
|
|
|
ibm_set_xive = rtas_token("ibm,set-xive");
|
|
|
|
ibm_int_on = rtas_token("ibm,int-on");
|
|
|
|
ibm_int_off = rtas_token("ibm,int-off");
|
|
|
|
|
|
|
|
for_each_node_by_type(np, "PowerPC-External-Interrupt-Presentation") {
|
|
|
|
found = 1;
|
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
break;
|
|
|
|
xics_init_one_node(np, &indx);
|
|
|
|
}
|
|
|
|
if (found == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
xics_init_host();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Find the server numbers for the boot cpu. */
|
2006-11-17 20:12:24 +08:00
|
|
|
np = cpuid_to_of_node(boot_cpuid);
|
|
|
|
BUG_ON(!np);
|
2007-04-03 20:26:41 +08:00
|
|
|
ireg = of_get_property(np, "ibm,ppc-interrupt-gserver#s", &ilen);
|
2006-11-17 20:12:24 +08:00
|
|
|
if (!ireg)
|
|
|
|
goto skip_gserver_check;
|
|
|
|
i = ilen / sizeof(int);
|
|
|
|
hcpuid = get_hard_smp_processor_id(boot_cpuid);
|
|
|
|
|
|
|
|
/* Global interrupt distribution server is specified in the last
|
|
|
|
* entry of "ibm,ppc-interrupt-gserver#s" property. Get the last
|
|
|
|
* entry fom this property for current boot cpu id and use it as
|
|
|
|
* default distribution server
|
|
|
|
*/
|
|
|
|
for (j = 0; j < i; j += 2) {
|
|
|
|
if (ireg[j] == hcpuid) {
|
|
|
|
default_server = hcpuid;
|
|
|
|
default_distrib_server = ireg[j+1];
|
|
|
|
|
2007-04-03 20:26:41 +08:00
|
|
|
isize = of_get_property(np,
|
2005-04-17 06:20:36 +08:00
|
|
|
"ibm,interrupt-server#-size", NULL);
|
2006-11-17 20:12:24 +08:00
|
|
|
if (isize)
|
|
|
|
interrupt_server_size = *isize;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2006-11-17 20:12:24 +08:00
|
|
|
skip_gserver_check:
|
2005-04-17 06:20:36 +08:00
|
|
|
of_node_put(np);
|
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
ppc_md.get_irq = xics_get_irq_lpar;
|
|
|
|
else
|
2006-07-03 17:32:51 +08:00
|
|
|
ppc_md.get_irq = xics_get_irq_direct;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-05-06 14:28:56 +08:00
|
|
|
xics_setup_cpu();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
xics_setup_8259_cascade();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
ppc64_boot_msg(0x21, "XICS Done");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-07-03 17:32:51 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
void xics_request_IPIs(void)
|
|
|
|
{
|
2006-07-03 19:36:01 +08:00
|
|
|
unsigned int ipi;
|
2007-05-29 15:01:52 +08:00
|
|
|
int rc;
|
2006-07-03 19:36:01 +08: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 19:44:42 +08:00
|
|
|
ipi = irq_create_mapping(xics_host, XICS_IPI);
|
2006-07-03 19:36:01 +08:00
|
|
|
BUG_ON(ipi == NO_IRQ);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-02 10:29:22 +08:00
|
|
|
/*
|
|
|
|
* IPIs are marked IRQF_DISABLED as they must run with irqs
|
|
|
|
* disabled
|
|
|
|
*/
|
2006-07-03 19:36:01 +08:00
|
|
|
set_irq_handler(ipi, handle_percpu_irq);
|
2006-07-03 17:32:51 +08:00
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
2007-05-29 15:01:52 +08:00
|
|
|
rc = request_irq(ipi, xics_ipi_action_lpar, IRQF_DISABLED,
|
|
|
|
"IPI", NULL);
|
2006-07-03 17:32:51 +08:00
|
|
|
else
|
2007-05-29 15:01:52 +08:00
|
|
|
rc = request_irq(ipi, xics_ipi_action_direct, IRQF_DISABLED,
|
|
|
|
"IPI", NULL);
|
|
|
|
BUG_ON(rc);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-07-03 17:32:51 +08:00
|
|
|
#endif /* CONFIG_SMP */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-05 03:53:37 +08:00
|
|
|
void xics_teardown_cpu(int secondary)
|
[PATCH] ppc64: kexec support for ppc64
This patch implements the kexec support for ppc64 platforms.
A couple of notes:
1) We copy the pages in virtual mode, using the full base kernel
and a statically allocated stack. At kexec_prepare time we
scan the pages and if any overlap our (0, _end[]) range we
return -ETXTBSY.
On PowerPC 64 systems running in LPAR (logical partitioning)
mode, only a small region of memory, referred to as the RMO,
can be accessed in real mode. Since Linux runs with only one
zone of memory in the memory allocator, and it can be orders of
magnitude more memory than the RMO, looping until we allocate
pages in the source region is not feasible. Copying in virtual
means we don't have to write a hash table generation and call
hypervisor to insert translations, instead we rely on the pinned
kernel linear mapping. The kernel already has move to linked
location built in, so there is no requirement to load it at 0.
If we want to load something other than a kernel, then a stub
can be written to copy a linear chunk in real mode.
2) The start entry point gets passed parameters from the kernel.
Slaves are started at a fixed address after copying code from
the entry point.
All CPUs get passed their firmware assigned physical id in r3
(most calling conventions use this register for the first
argument).
This is used to distinguish each CPU from all other CPUs.
Since firmware is not around, there is no other way to obtain
this information other than to pass it somewhere.
A single CPU, referred to here as the master and the one executing
the kexec call, branches to start with the address of start in r4.
While this can be calculated, we have to load it through a gpr to
branch to this point so defining the register this is contained
in is free. A stack of unspecified size is available at r1
(also common calling convention).
All remaining running CPUs are sent to start at absolute address
0x60 after copying the first 0x100 bytes from start to address 0.
This convention was chosen because it matches what the kernel
has been doing itself. (only gpr3 is defined).
Note: This is not quite the convention of the kexec bootblock v2
in the kernel. A stub has been written to convert between them,
and we may adjust the kernel in the future to allow this directly
without any stub.
3) Destination pages can be placed anywhere, even where they
would not be accessible in real mode. This will allow us to
place ram disks above the RMO if we choose.
Signed-off-by: Milton Miller <miltonm@bga.com>
Signed-off-by: R Sharada <sharada@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 05:58:10 +08:00
|
|
|
{
|
|
|
|
int cpu = smp_processor_id();
|
2006-07-03 19:36:01 +08:00
|
|
|
unsigned int ipi;
|
|
|
|
struct irq_desc *desc;
|
[PATCH] ppc64: kexec support for ppc64
This patch implements the kexec support for ppc64 platforms.
A couple of notes:
1) We copy the pages in virtual mode, using the full base kernel
and a statically allocated stack. At kexec_prepare time we
scan the pages and if any overlap our (0, _end[]) range we
return -ETXTBSY.
On PowerPC 64 systems running in LPAR (logical partitioning)
mode, only a small region of memory, referred to as the RMO,
can be accessed in real mode. Since Linux runs with only one
zone of memory in the memory allocator, and it can be orders of
magnitude more memory than the RMO, looping until we allocate
pages in the source region is not feasible. Copying in virtual
means we don't have to write a hash table generation and call
hypervisor to insert translations, instead we rely on the pinned
kernel linear mapping. The kernel already has move to linked
location built in, so there is no requirement to load it at 0.
If we want to load something other than a kernel, then a stub
can be written to copy a linear chunk in real mode.
2) The start entry point gets passed parameters from the kernel.
Slaves are started at a fixed address after copying code from
the entry point.
All CPUs get passed their firmware assigned physical id in r3
(most calling conventions use this register for the first
argument).
This is used to distinguish each CPU from all other CPUs.
Since firmware is not around, there is no other way to obtain
this information other than to pass it somewhere.
A single CPU, referred to here as the master and the one executing
the kexec call, branches to start with the address of start in r4.
While this can be calculated, we have to load it through a gpr to
branch to this point so defining the register this is contained
in is free. A stack of unspecified size is available at r1
(also common calling convention).
All remaining running CPUs are sent to start at absolute address
0x60 after copying the first 0x100 bytes from start to address 0.
This convention was chosen because it matches what the kernel
has been doing itself. (only gpr3 is defined).
Note: This is not quite the convention of the kexec bootblock v2
in the kernel. A stub has been written to convert between them,
and we may adjust the kernel in the future to allow this directly
without any stub.
3) Destination pages can be placed anywhere, even where they
would not be accessible in real mode. This will allow us to
place ram disks above the RMO if we choose.
Signed-off-by: Milton Miller <miltonm@bga.com>
Signed-off-by: R Sharada <sharada@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 05:58:10 +08:00
|
|
|
|
2006-07-03 19:36:01 +08:00
|
|
|
xics_set_cpu_priority(cpu, 0);
|
2006-04-06 11:10:18 +08: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 19:44:42 +08:00
|
|
|
/*
|
|
|
|
* Clear IPI
|
|
|
|
*/
|
|
|
|
if (firmware_has_feature(FW_FEATURE_LPAR))
|
|
|
|
lpar_qirr_info(cpu, 0xff);
|
|
|
|
else
|
|
|
|
direct_qirr_info(cpu, 0xff);
|
|
|
|
|
2006-04-06 11:10:18 +08:00
|
|
|
/*
|
|
|
|
* we need to EOI the IPI if we got here from kexec down IPI
|
|
|
|
*
|
|
|
|
* probably need to check all the other interrupts too
|
|
|
|
* should we be flagging idle loop instead?
|
|
|
|
* or creating some task to be scheduled?
|
|
|
|
*/
|
2006-07-03 19:36:01 +08:00
|
|
|
|
|
|
|
ipi = irq_find_mapping(xics_host, XICS_IPI);
|
|
|
|
if (ipi == XICS_IRQ_SPURIOUS)
|
|
|
|
return;
|
|
|
|
desc = get_irq_desc(ipi);
|
2006-07-03 17:32:51 +08:00
|
|
|
if (desc->chip && desc->chip->eoi)
|
[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 19:44:42 +08:00
|
|
|
desc->chip->eoi(ipi);
|
2006-04-06 11:10:18 +08:00
|
|
|
|
[PATCH] ppc64: kexec support for ppc64
This patch implements the kexec support for ppc64 platforms.
A couple of notes:
1) We copy the pages in virtual mode, using the full base kernel
and a statically allocated stack. At kexec_prepare time we
scan the pages and if any overlap our (0, _end[]) range we
return -ETXTBSY.
On PowerPC 64 systems running in LPAR (logical partitioning)
mode, only a small region of memory, referred to as the RMO,
can be accessed in real mode. Since Linux runs with only one
zone of memory in the memory allocator, and it can be orders of
magnitude more memory than the RMO, looping until we allocate
pages in the source region is not feasible. Copying in virtual
means we don't have to write a hash table generation and call
hypervisor to insert translations, instead we rely on the pinned
kernel linear mapping. The kernel already has move to linked
location built in, so there is no requirement to load it at 0.
If we want to load something other than a kernel, then a stub
can be written to copy a linear chunk in real mode.
2) The start entry point gets passed parameters from the kernel.
Slaves are started at a fixed address after copying code from
the entry point.
All CPUs get passed their firmware assigned physical id in r3
(most calling conventions use this register for the first
argument).
This is used to distinguish each CPU from all other CPUs.
Since firmware is not around, there is no other way to obtain
this information other than to pass it somewhere.
A single CPU, referred to here as the master and the one executing
the kexec call, branches to start with the address of start in r4.
While this can be calculated, we have to load it through a gpr to
branch to this point so defining the register this is contained
in is free. A stack of unspecified size is available at r1
(also common calling convention).
All remaining running CPUs are sent to start at absolute address
0x60 after copying the first 0x100 bytes from start to address 0.
This convention was chosen because it matches what the kernel
has been doing itself. (only gpr3 is defined).
Note: This is not quite the convention of the kexec bootblock v2
in the kernel. A stub has been written to convert between them,
and we may adjust the kernel in the future to allow this directly
without any stub.
3) Destination pages can be placed anywhere, even where they
would not be accessible in real mode. This will allow us to
place ram disks above the RMO if we choose.
Signed-off-by: Milton Miller <miltonm@bga.com>
Signed-off-by: R Sharada <sharada@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 05:58:10 +08:00
|
|
|
/*
|
2005-08-05 03:53:37 +08:00
|
|
|
* Some machines need to have at least one cpu in the GIQ,
|
|
|
|
* so leave the master cpu in the group.
|
[PATCH] ppc64: kexec support for ppc64
This patch implements the kexec support for ppc64 platforms.
A couple of notes:
1) We copy the pages in virtual mode, using the full base kernel
and a statically allocated stack. At kexec_prepare time we
scan the pages and if any overlap our (0, _end[]) range we
return -ETXTBSY.
On PowerPC 64 systems running in LPAR (logical partitioning)
mode, only a small region of memory, referred to as the RMO,
can be accessed in real mode. Since Linux runs with only one
zone of memory in the memory allocator, and it can be orders of
magnitude more memory than the RMO, looping until we allocate
pages in the source region is not feasible. Copying in virtual
means we don't have to write a hash table generation and call
hypervisor to insert translations, instead we rely on the pinned
kernel linear mapping. The kernel already has move to linked
location built in, so there is no requirement to load it at 0.
If we want to load something other than a kernel, then a stub
can be written to copy a linear chunk in real mode.
2) The start entry point gets passed parameters from the kernel.
Slaves are started at a fixed address after copying code from
the entry point.
All CPUs get passed their firmware assigned physical id in r3
(most calling conventions use this register for the first
argument).
This is used to distinguish each CPU from all other CPUs.
Since firmware is not around, there is no other way to obtain
this information other than to pass it somewhere.
A single CPU, referred to here as the master and the one executing
the kexec call, branches to start with the address of start in r4.
While this can be calculated, we have to load it through a gpr to
branch to this point so defining the register this is contained
in is free. A stack of unspecified size is available at r1
(also common calling convention).
All remaining running CPUs are sent to start at absolute address
0x60 after copying the first 0x100 bytes from start to address 0.
This convention was chosen because it matches what the kernel
has been doing itself. (only gpr3 is defined).
Note: This is not quite the convention of the kexec bootblock v2
in the kernel. A stub has been written to convert between them,
and we may adjust the kernel in the future to allow this directly
without any stub.
3) Destination pages can be placed anywhere, even where they
would not be accessible in real mode. This will allow us to
place ram disks above the RMO if we choose.
Signed-off-by: Milton Miller <miltonm@bga.com>
Signed-off-by: R Sharada <sharada@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 05:58:10 +08:00
|
|
|
*/
|
2006-04-06 11:10:18 +08:00
|
|
|
if (secondary)
|
2006-07-28 05:29:00 +08:00
|
|
|
rtas_set_indicator_fast(GLOBAL_INTERRUPT_QUEUE,
|
2006-07-03 19:36:01 +08:00
|
|
|
(1UL << interrupt_server_size) - 1 -
|
|
|
|
default_distrib_server, 0);
|
[PATCH] ppc64: kexec support for ppc64
This patch implements the kexec support for ppc64 platforms.
A couple of notes:
1) We copy the pages in virtual mode, using the full base kernel
and a statically allocated stack. At kexec_prepare time we
scan the pages and if any overlap our (0, _end[]) range we
return -ETXTBSY.
On PowerPC 64 systems running in LPAR (logical partitioning)
mode, only a small region of memory, referred to as the RMO,
can be accessed in real mode. Since Linux runs with only one
zone of memory in the memory allocator, and it can be orders of
magnitude more memory than the RMO, looping until we allocate
pages in the source region is not feasible. Copying in virtual
means we don't have to write a hash table generation and call
hypervisor to insert translations, instead we rely on the pinned
kernel linear mapping. The kernel already has move to linked
location built in, so there is no requirement to load it at 0.
If we want to load something other than a kernel, then a stub
can be written to copy a linear chunk in real mode.
2) The start entry point gets passed parameters from the kernel.
Slaves are started at a fixed address after copying code from
the entry point.
All CPUs get passed their firmware assigned physical id in r3
(most calling conventions use this register for the first
argument).
This is used to distinguish each CPU from all other CPUs.
Since firmware is not around, there is no other way to obtain
this information other than to pass it somewhere.
A single CPU, referred to here as the master and the one executing
the kexec call, branches to start with the address of start in r4.
While this can be calculated, we have to load it through a gpr to
branch to this point so defining the register this is contained
in is free. A stack of unspecified size is available at r1
(also common calling convention).
All remaining running CPUs are sent to start at absolute address
0x60 after copying the first 0x100 bytes from start to address 0.
This convention was chosen because it matches what the kernel
has been doing itself. (only gpr3 is defined).
Note: This is not quite the convention of the kexec bootblock v2
in the kernel. A stub has been written to convert between them,
and we may adjust the kernel in the future to allow this directly
without any stub.
3) Destination pages can be placed anywhere, even where they
would not be accessible in real mode. This will allow us to
place ram disks above the RMO if we choose.
Signed-off-by: Milton Miller <miltonm@bga.com>
Signed-off-by: R Sharada <sharada@in.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-26 05:58:10 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
|
|
|
|
/* Interrupts are disabled. */
|
|
|
|
void xics_migrate_irqs_away(void)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
unsigned int irq, virq, cpu = smp_processor_id();
|
|
|
|
|
|
|
|
/* Reject any interrupt that was queued to us... */
|
2006-07-03 17:32:51 +08:00
|
|
|
xics_set_cpu_priority(cpu, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* remove ourselves from the global interrupt queue */
|
2006-07-28 05:29:00 +08:00
|
|
|
status = rtas_set_indicator_fast(GLOBAL_INTERRUPT_QUEUE,
|
2005-04-17 06:20:36 +08:00
|
|
|
(1UL << interrupt_server_size) - 1 - default_distrib_server, 0);
|
|
|
|
WARN_ON(status < 0);
|
|
|
|
|
|
|
|
/* Allow IPIs again... */
|
2006-07-03 17:32:51 +08:00
|
|
|
xics_set_cpu_priority(cpu, DEFAULT_PRIORITY);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
for_each_irq(virq) {
|
2006-07-03 17:32:51 +08:00
|
|
|
struct irq_desc *desc;
|
2005-04-17 06:20:36 +08:00
|
|
|
int xics_status[2];
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* We cant set affinity on ISA interrupts */
|
2006-07-03 19:36:01 +08:00
|
|
|
if (virq < NUM_ISA_INTERRUPTS)
|
2005-04-17 06:20:36 +08:00
|
|
|
continue;
|
2006-07-03 19:36:01 +08:00
|
|
|
if (irq_map[virq].host != xics_host)
|
|
|
|
continue;
|
|
|
|
irq = (unsigned int)irq_map[virq].hwirq;
|
2005-04-17 06:20:36 +08:00
|
|
|
/* We need to get IPIs still. */
|
2006-07-03 19:36:01 +08:00
|
|
|
if (irq == XICS_IPI || irq == XICS_IRQ_SPURIOUS)
|
2005-04-17 06:20:36 +08:00
|
|
|
continue;
|
2006-07-03 19:36:01 +08:00
|
|
|
desc = get_irq_desc(virq);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* We only need to migrate enabled IRQS */
|
[PATCH] genirq: rename desc->handler to desc->chip
This patch-queue improves the generic IRQ layer to be truly generic, by adding
various abstractions and features to it, without impacting existing
functionality.
While the queue can be best described as "fix and improve everything in the
generic IRQ layer that we could think of", and thus it consists of many
smaller features and lots of cleanups, the one feature that stands out most is
the new 'irq chip' abstraction.
The irq-chip abstraction is about describing and coding and IRQ controller
driver by mapping its raw hardware capabilities [and quirks, if needed] in a
straightforward way, without having to think about "IRQ flow"
(level/edge/etc.) type of details.
This stands in contrast with the current 'irq-type' model of genirq
architectures, which 'mixes' raw hardware capabilities with 'flow' details.
The patchset supports both types of irq controller designs at once, and
converts i386 and x86_64 to the new irq-chip design.
As a bonus side-effect of the irq-chip approach, chained interrupt controllers
(master/slave PIC constructs, etc.) are now supported by design as well.
The end result of this patchset intends to be simpler architecture-level code
and more consolidation between architectures.
We reused many bits of code and many concepts from Russell King's ARM IRQ
layer, the merging of which was one of the motivations for this patchset.
This patch:
rename desc->handler to desc->chip.
Originally i did not want to do this, because it's a big patch. But having
both "desc->handler", "desc->handle_irq" and "action->handler" caused a
large degree of confusion and made the code appear alot less clean than it
truly is.
I have also attempted a dual approach as well by introducing a
desc->chip alias - but that just wasnt robust enough and broke
frequently.
So lets get over with this quickly. The conversion was done automatically
via scripts and converts all the code in the kernel.
This renaming patch is the first one amongst the patches, so that the
remaining patches can stay flexible and can be merged and split up
without having some big monolithic patch act as a merge barrier.
[akpm@osdl.org: build fix]
[akpm@osdl.org: another build fix]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-29 17:24:36 +08:00
|
|
|
if (desc == NULL || desc->chip == NULL
|
2005-04-17 06:20:36 +08:00
|
|
|
|| desc->action == NULL
|
[PATCH] genirq: rename desc->handler to desc->chip
This patch-queue improves the generic IRQ layer to be truly generic, by adding
various abstractions and features to it, without impacting existing
functionality.
While the queue can be best described as "fix and improve everything in the
generic IRQ layer that we could think of", and thus it consists of many
smaller features and lots of cleanups, the one feature that stands out most is
the new 'irq chip' abstraction.
The irq-chip abstraction is about describing and coding and IRQ controller
driver by mapping its raw hardware capabilities [and quirks, if needed] in a
straightforward way, without having to think about "IRQ flow"
(level/edge/etc.) type of details.
This stands in contrast with the current 'irq-type' model of genirq
architectures, which 'mixes' raw hardware capabilities with 'flow' details.
The patchset supports both types of irq controller designs at once, and
converts i386 and x86_64 to the new irq-chip design.
As a bonus side-effect of the irq-chip approach, chained interrupt controllers
(master/slave PIC constructs, etc.) are now supported by design as well.
The end result of this patchset intends to be simpler architecture-level code
and more consolidation between architectures.
We reused many bits of code and many concepts from Russell King's ARM IRQ
layer, the merging of which was one of the motivations for this patchset.
This patch:
rename desc->handler to desc->chip.
Originally i did not want to do this, because it's a big patch. But having
both "desc->handler", "desc->handle_irq" and "action->handler" caused a
large degree of confusion and made the code appear alot less clean than it
truly is.
I have also attempted a dual approach as well by introducing a
desc->chip alias - but that just wasnt robust enough and broke
frequently.
So lets get over with this quickly. The conversion was done automatically
via scripts and converts all the code in the kernel.
This renaming patch is the first one amongst the patches, so that the
remaining patches can stay flexible and can be merged and split up
without having some big monolithic patch act as a merge barrier.
[akpm@osdl.org: build fix]
[akpm@osdl.org: another build fix]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-29 17:24:36 +08:00
|
|
|
|| desc->chip->set_affinity == NULL)
|
2005-04-17 06:20:36 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&desc->lock, flags);
|
|
|
|
|
|
|
|
status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
|
|
|
|
if (status) {
|
2005-09-12 11:12:11 +08:00
|
|
|
printk(KERN_ERR "migrate_irqs_away: irq=%u "
|
2005-04-17 06:20:36 +08:00
|
|
|
"ibm,get-xive returns %d\n",
|
|
|
|
virq, status);
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only support delivery to all cpus or to one cpu.
|
|
|
|
* The irq has to be migrated only in the single cpu
|
|
|
|
* case.
|
|
|
|
*/
|
|
|
|
if (xics_status[0] != get_hard_smp_processor_id(cpu))
|
|
|
|
goto unlock;
|
|
|
|
|
2005-09-12 11:12:11 +08:00
|
|
|
printk(KERN_WARNING "IRQ %u affinity broken off cpu %u\n",
|
2005-04-17 06:20:36 +08:00
|
|
|
virq, cpu);
|
|
|
|
|
|
|
|
/* Reset affinity to all cpus */
|
[PATCH] genirq: rename desc->handler to desc->chip
This patch-queue improves the generic IRQ layer to be truly generic, by adding
various abstractions and features to it, without impacting existing
functionality.
While the queue can be best described as "fix and improve everything in the
generic IRQ layer that we could think of", and thus it consists of many
smaller features and lots of cleanups, the one feature that stands out most is
the new 'irq chip' abstraction.
The irq-chip abstraction is about describing and coding and IRQ controller
driver by mapping its raw hardware capabilities [and quirks, if needed] in a
straightforward way, without having to think about "IRQ flow"
(level/edge/etc.) type of details.
This stands in contrast with the current 'irq-type' model of genirq
architectures, which 'mixes' raw hardware capabilities with 'flow' details.
The patchset supports both types of irq controller designs at once, and
converts i386 and x86_64 to the new irq-chip design.
As a bonus side-effect of the irq-chip approach, chained interrupt controllers
(master/slave PIC constructs, etc.) are now supported by design as well.
The end result of this patchset intends to be simpler architecture-level code
and more consolidation between architectures.
We reused many bits of code and many concepts from Russell King's ARM IRQ
layer, the merging of which was one of the motivations for this patchset.
This patch:
rename desc->handler to desc->chip.
Originally i did not want to do this, because it's a big patch. But having
both "desc->handler", "desc->handle_irq" and "action->handler" caused a
large degree of confusion and made the code appear alot less clean than it
truly is.
I have also attempted a dual approach as well by introducing a
desc->chip alias - but that just wasnt robust enough and broke
frequently.
So lets get over with this quickly. The conversion was done automatically
via scripts and converts all the code in the kernel.
This renaming patch is the first one amongst the patches, so that the
remaining patches can stay flexible and can be merged and split up
without having some big monolithic patch act as a merge barrier.
[akpm@osdl.org: build fix]
[akpm@osdl.org: another build fix]
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-06-29 17:24:36 +08:00
|
|
|
desc->chip->set_affinity(virq, CPU_MASK_ALL);
|
2006-06-29 17:24:38 +08:00
|
|
|
irq_desc[irq].affinity = CPU_MASK_ALL;
|
2005-04-17 06:20:36 +08:00
|
|
|
unlock:
|
|
|
|
spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|