2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2006-10-03 23:01:26 +02:00
|
|
|
* linux/arch/ia64/kernel/irq_ia64.c
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* Copyright (C) 1998-2001 Hewlett-Packard Co
|
|
|
|
* Stephane Eranian <eranian@hpl.hp.com>
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
|
|
|
*
|
|
|
|
* 6/10/99: Updated to bring in sync with x86 version to facilitate
|
|
|
|
* support for SMP and different interrupt controllers.
|
|
|
|
*
|
|
|
|
* 09/15/00 Goutham Rao <goutham.rao@intel.com> Implemented pci_irq_to_vector
|
|
|
|
* PCI to vector allocation routine.
|
|
|
|
* 04/14/2004 Ashok Raj <ashok.raj@intel.com>
|
|
|
|
* Added CPU Hotplug handling for IPF.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/ioport.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/random.h> /* for rand_initialize_irq() */
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/threads.h>
|
|
|
|
#include <linux/bitops.h>
|
2006-10-04 11:16:38 +02:00
|
|
|
#include <linux/irq.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <asm/delay.h>
|
|
|
|
#include <asm/intrinsics.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/hw_irq.h>
|
|
|
|
#include <asm/machvec.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/system.h>
|
2007-05-08 23:50:43 +02:00
|
|
|
#include <asm/tlbflush.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_PERFMON
|
|
|
|
# include <asm/perfmon.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define IRQ_DEBUG 0
|
|
|
|
|
2007-07-17 14:22:23 +02:00
|
|
|
#define IRQ_VECTOR_UNASSIGNED (0)
|
|
|
|
|
|
|
|
#define IRQ_UNUSED (0)
|
|
|
|
#define IRQ_USED (1)
|
|
|
|
#define IRQ_RSVD (2)
|
|
|
|
|
2006-04-14 23:03:49 +02:00
|
|
|
/* These can be overridden in platform_irq_init */
|
|
|
|
int ia64_first_device_vector = IA64_DEF_FIRST_DEVICE_VECTOR;
|
|
|
|
int ia64_last_device_vector = IA64_DEF_LAST_DEVICE_VECTOR;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* default base addr of IPI table */
|
|
|
|
void __iomem *ipi_base_addr = ((void __iomem *)
|
|
|
|
(__IA64_UNCACHED_OFFSET | IA64_IPI_DEFAULT_BASE_ADDR));
|
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
static cpumask_t vector_allocation_domain(int cpu);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Legacy IRQ to IA-64 vector translation table.
|
|
|
|
*/
|
|
|
|
__u8 isa_irq_to_vector_map[16] = {
|
|
|
|
/* 8259 IRQ translation, first 16 entries */
|
|
|
|
0x2f, 0x20, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29,
|
|
|
|
0x28, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL(isa_irq_to_vector_map);
|
|
|
|
|
2007-07-17 14:22:23 +02:00
|
|
|
DEFINE_SPINLOCK(vector_lock);
|
|
|
|
|
|
|
|
struct irq_cfg irq_cfg[NR_IRQS] __read_mostly = {
|
2007-07-17 14:22:33 +02:00
|
|
|
[0 ... NR_IRQS - 1] = {
|
|
|
|
.vector = IRQ_VECTOR_UNASSIGNED,
|
|
|
|
.domain = CPU_MASK_NONE
|
|
|
|
}
|
2007-07-17 14:22:23 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_PER_CPU(int[IA64_NUM_VECTORS], vector_irq) = {
|
2007-08-29 01:01:21 +02:00
|
|
|
[0 ... IA64_NUM_VECTORS - 1] = -1
|
2007-07-17 14:22:23 +02:00
|
|
|
};
|
|
|
|
|
2007-07-25 10:59:22 +02:00
|
|
|
static cpumask_t vector_table[IA64_NUM_VECTORS] = {
|
|
|
|
[0 ... IA64_NUM_VECTORS - 1] = CPU_MASK_NONE
|
2007-07-17 14:22:33 +02:00
|
|
|
};
|
|
|
|
|
2007-07-17 14:22:23 +02:00
|
|
|
static int irq_status[NR_IRQS] = {
|
|
|
|
[0 ... NR_IRQS -1] = IRQ_UNUSED
|
|
|
|
};
|
|
|
|
|
|
|
|
int check_irq_used(int irq)
|
|
|
|
{
|
|
|
|
if (irq_status[irq] == IRQ_USED)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int find_unassigned_irq(void)
|
|
|
|
{
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
for (irq = IA64_FIRST_DEVICE_VECTOR; irq < NR_IRQS; irq++)
|
|
|
|
if (irq_status[irq] == IRQ_UNUSED)
|
|
|
|
return irq;
|
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
static inline int find_unassigned_vector(cpumask_t domain)
|
2007-07-17 14:22:23 +02:00
|
|
|
{
|
2007-07-17 14:22:33 +02:00
|
|
|
cpumask_t mask;
|
2007-07-25 10:59:22 +02:00
|
|
|
int pos, vector;
|
2007-07-17 14:22:33 +02:00
|
|
|
|
|
|
|
cpus_and(mask, domain, cpu_online_map);
|
|
|
|
if (cpus_empty(mask))
|
|
|
|
return -EINVAL;
|
2007-07-17 14:22:23 +02:00
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
for (pos = 0; pos < IA64_NUM_DEVICE_VECTORS; pos++) {
|
2007-07-25 10:59:22 +02:00
|
|
|
vector = IA64_FIRST_DEVICE_VECTOR + pos;
|
|
|
|
cpus_and(mask, domain, vector_table[vector]);
|
2007-07-17 14:22:33 +02:00
|
|
|
if (!cpus_empty(mask))
|
|
|
|
continue;
|
2007-07-25 10:59:22 +02:00
|
|
|
return vector;
|
2007-07-17 14:22:33 +02:00
|
|
|
}
|
2007-07-17 14:22:23 +02:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
static int __bind_irq_vector(int irq, int vector, cpumask_t domain)
|
2007-07-17 14:22:23 +02:00
|
|
|
{
|
2007-07-17 14:22:33 +02:00
|
|
|
cpumask_t mask;
|
2007-07-25 10:59:22 +02:00
|
|
|
int cpu;
|
2007-07-17 14:22:33 +02:00
|
|
|
struct irq_cfg *cfg = &irq_cfg[irq];
|
2007-07-17 14:22:23 +02:00
|
|
|
|
2007-07-26 08:30:45 +02:00
|
|
|
BUG_ON((unsigned)irq >= NR_IRQS);
|
|
|
|
BUG_ON((unsigned)vector >= IA64_NUM_VECTORS);
|
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
cpus_and(mask, domain, cpu_online_map);
|
|
|
|
if (cpus_empty(mask))
|
|
|
|
return -EINVAL;
|
|
|
|
if ((cfg->vector == vector) && cpus_equal(cfg->domain, domain))
|
2007-07-17 14:22:23 +02:00
|
|
|
return 0;
|
2007-07-17 14:22:33 +02:00
|
|
|
if (cfg->vector != IRQ_VECTOR_UNASSIGNED)
|
2007-07-17 14:22:23 +02:00
|
|
|
return -EBUSY;
|
2007-07-17 14:22:33 +02:00
|
|
|
for_each_cpu_mask(cpu, mask)
|
2007-07-17 14:22:23 +02:00
|
|
|
per_cpu(vector_irq, cpu)[vector] = irq;
|
2007-07-17 14:22:33 +02:00
|
|
|
cfg->vector = vector;
|
|
|
|
cfg->domain = domain;
|
2007-07-17 14:22:23 +02:00
|
|
|
irq_status[irq] = IRQ_USED;
|
2007-07-25 10:59:22 +02:00
|
|
|
cpus_or(vector_table[vector], vector_table[vector], domain);
|
2007-07-17 14:22:23 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
int bind_irq_vector(int irq, int vector, cpumask_t domain)
|
2007-07-17 14:22:23 +02:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
2007-07-17 14:22:33 +02:00
|
|
|
ret = __bind_irq_vector(irq, vector, domain);
|
2007-07-17 14:22:23 +02:00
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-07-17 14:22:48 +02:00
|
|
|
static void __clear_irq_vector(int irq)
|
2007-07-17 14:22:23 +02:00
|
|
|
{
|
2007-07-25 10:59:22 +02:00
|
|
|
int vector, cpu;
|
2007-07-17 14:22:33 +02:00
|
|
|
cpumask_t mask;
|
|
|
|
cpumask_t domain;
|
|
|
|
struct irq_cfg *cfg = &irq_cfg[irq];
|
2007-07-17 14:22:23 +02:00
|
|
|
|
|
|
|
BUG_ON((unsigned)irq >= NR_IRQS);
|
2007-07-17 14:22:33 +02:00
|
|
|
BUG_ON(cfg->vector == IRQ_VECTOR_UNASSIGNED);
|
|
|
|
vector = cfg->vector;
|
|
|
|
domain = cfg->domain;
|
|
|
|
cpus_and(mask, cfg->domain, cpu_online_map);
|
|
|
|
for_each_cpu_mask(cpu, mask)
|
2007-08-29 01:01:21 +02:00
|
|
|
per_cpu(vector_irq, cpu)[vector] = -1;
|
2007-07-17 14:22:33 +02:00
|
|
|
cfg->vector = IRQ_VECTOR_UNASSIGNED;
|
|
|
|
cfg->domain = CPU_MASK_NONE;
|
2007-07-17 14:22:23 +02:00
|
|
|
irq_status[irq] = IRQ_UNUSED;
|
2007-07-25 10:59:22 +02:00
|
|
|
cpus_andnot(vector_table[vector], vector_table[vector], domain);
|
2007-07-17 14:22:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void clear_irq_vector(int irq)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
|
|
|
__clear_irq_vector(irq);
|
2007-07-17 14:22:23 +02:00
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
int
|
2005-07-11 06:49:00 +02:00
|
|
|
assign_irq_vector (int irq)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-07-17 14:22:23 +02:00
|
|
|
unsigned long flags;
|
2007-07-17 14:22:33 +02:00
|
|
|
int vector, cpu;
|
2007-08-22 12:28:36 +02:00
|
|
|
cpumask_t domain = CPU_MASK_NONE;
|
2007-07-17 14:22:33 +02:00
|
|
|
|
|
|
|
vector = -ENOSPC;
|
2007-07-17 14:22:23 +02:00
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
domain = vector_allocation_domain(cpu);
|
|
|
|
vector = find_unassigned_vector(domain);
|
|
|
|
if (vector >= 0)
|
|
|
|
break;
|
|
|
|
}
|
2007-07-17 14:22:23 +02:00
|
|
|
if (vector < 0)
|
|
|
|
goto out;
|
2007-07-24 15:09:09 +02:00
|
|
|
if (irq == AUTO_ASSIGN)
|
|
|
|
irq = vector;
|
2007-07-17 14:22:33 +02:00
|
|
|
BUG_ON(__bind_irq_vector(irq, vector, domain));
|
2007-07-17 14:22:23 +02:00
|
|
|
out:
|
2007-07-17 14:22:33 +02:00
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
return vector;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
free_irq_vector (int vector)
|
|
|
|
{
|
2007-07-17 14:22:23 +02:00
|
|
|
if (vector < IA64_FIRST_DEVICE_VECTOR ||
|
|
|
|
vector > IA64_LAST_DEVICE_VECTOR)
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
2007-07-17 14:22:23 +02:00
|
|
|
clear_irq_vector(vector);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-04-14 23:03:49 +02:00
|
|
|
int
|
|
|
|
reserve_irq_vector (int vector)
|
|
|
|
{
|
|
|
|
if (vector < IA64_FIRST_DEVICE_VECTOR ||
|
|
|
|
vector > IA64_LAST_DEVICE_VECTOR)
|
|
|
|
return -EINVAL;
|
2007-07-17 14:22:33 +02:00
|
|
|
return !!bind_irq_vector(vector, vector, CPU_MASK_ALL);
|
2007-07-17 14:22:23 +02:00
|
|
|
}
|
2006-04-14 23:03:49 +02:00
|
|
|
|
2007-07-17 14:22:23 +02:00
|
|
|
/*
|
|
|
|
* Initialize vector_irq on a new cpu. This function must be called
|
|
|
|
* with vector_lock held.
|
|
|
|
*/
|
|
|
|
void __setup_vector_irq(int cpu)
|
|
|
|
{
|
|
|
|
int irq, vector;
|
|
|
|
|
|
|
|
/* Clear vector_irq */
|
|
|
|
for (vector = 0; vector < IA64_NUM_VECTORS; ++vector)
|
2007-08-29 01:01:21 +02:00
|
|
|
per_cpu(vector_irq, cpu)[vector] = -1;
|
2007-07-17 14:22:23 +02:00
|
|
|
/* Mark the inuse vectors */
|
|
|
|
for (irq = 0; irq < NR_IRQS; ++irq) {
|
2007-07-17 14:22:33 +02:00
|
|
|
if (!cpu_isset(cpu, irq_cfg[irq].domain))
|
|
|
|
continue;
|
|
|
|
vector = irq_to_vector(irq);
|
|
|
|
per_cpu(vector_irq, cpu)[vector] = irq;
|
2007-07-17 14:22:23 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-07-17 14:23:03 +02:00
|
|
|
#if defined(CONFIG_SMP) && (defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_DIG))
|
2007-07-17 14:22:55 +02:00
|
|
|
static enum vector_domain_type {
|
|
|
|
VECTOR_DOMAIN_NONE,
|
|
|
|
VECTOR_DOMAIN_PERCPU
|
|
|
|
} vector_domain_type = VECTOR_DOMAIN_NONE;
|
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
static cpumask_t vector_allocation_domain(int cpu)
|
|
|
|
{
|
2007-07-17 14:22:55 +02:00
|
|
|
if (vector_domain_type == VECTOR_DOMAIN_PERCPU)
|
|
|
|
return cpumask_of_cpu(cpu);
|
2007-07-17 14:22:33 +02:00
|
|
|
return CPU_MASK_ALL;
|
|
|
|
}
|
|
|
|
|
2007-07-17 14:22:55 +02:00
|
|
|
static int __init parse_vector_domain(char *arg)
|
|
|
|
{
|
|
|
|
if (!arg)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!strcmp(arg, "percpu")) {
|
|
|
|
vector_domain_type = VECTOR_DOMAIN_PERCPU;
|
|
|
|
no_int_routing = 1;
|
|
|
|
}
|
2007-07-26 08:32:38 +02:00
|
|
|
return 0;
|
2007-07-17 14:22:55 +02:00
|
|
|
}
|
|
|
|
early_param("vector", parse_vector_domain);
|
|
|
|
#else
|
|
|
|
static cpumask_t vector_allocation_domain(int cpu)
|
|
|
|
{
|
|
|
|
return CPU_MASK_ALL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
|
2007-07-17 14:22:23 +02:00
|
|
|
void destroy_and_reserve_irq(unsigned int irq)
|
|
|
|
{
|
2007-07-30 04:56:30 +02:00
|
|
|
unsigned long flags;
|
|
|
|
|
2007-07-17 14:22:23 +02:00
|
|
|
dynamic_irq_cleanup(irq);
|
|
|
|
|
2007-07-30 04:56:30 +02:00
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
|
|
|
__clear_irq_vector(irq);
|
|
|
|
irq_status[irq] = IRQ_RSVD;
|
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
2006-04-14 23:03:49 +02:00
|
|
|
}
|
|
|
|
|
2007-07-17 14:22:48 +02:00
|
|
|
static int __reassign_irq_vector(int irq, int cpu)
|
|
|
|
{
|
|
|
|
struct irq_cfg *cfg = &irq_cfg[irq];
|
|
|
|
int vector;
|
|
|
|
cpumask_t domain;
|
|
|
|
|
|
|
|
if (cfg->vector == IRQ_VECTOR_UNASSIGNED || !cpu_online(cpu))
|
|
|
|
return -EINVAL;
|
|
|
|
if (cpu_isset(cpu, cfg->domain))
|
|
|
|
return 0;
|
|
|
|
domain = vector_allocation_domain(cpu);
|
|
|
|
vector = find_unassigned_vector(domain);
|
|
|
|
if (vector < 0)
|
|
|
|
return -ENOSPC;
|
|
|
|
__clear_irq_vector(irq);
|
|
|
|
BUG_ON(__bind_irq_vector(irq, vector, domain));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int reassign_irq_vector(int irq, int cpu)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
|
|
|
ret = __reassign_irq_vector(irq, cpu);
|
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-10-04 11:16:38 +02:00
|
|
|
/*
|
|
|
|
* Dynamic irq allocate and deallocation for MSI
|
|
|
|
*/
|
|
|
|
int create_irq(void)
|
|
|
|
{
|
2007-07-17 14:22:23 +02:00
|
|
|
unsigned long flags;
|
2007-07-17 14:22:33 +02:00
|
|
|
int irq, vector, cpu;
|
2007-08-22 12:28:36 +02:00
|
|
|
cpumask_t domain = CPU_MASK_NONE;
|
2007-07-17 14:22:23 +02:00
|
|
|
|
2007-07-17 14:22:33 +02:00
|
|
|
irq = vector = -ENOSPC;
|
2007-07-17 14:22:23 +02:00
|
|
|
spin_lock_irqsave(&vector_lock, flags);
|
2007-07-17 14:22:33 +02:00
|
|
|
for_each_online_cpu(cpu) {
|
|
|
|
domain = vector_allocation_domain(cpu);
|
|
|
|
vector = find_unassigned_vector(domain);
|
|
|
|
if (vector >= 0)
|
|
|
|
break;
|
|
|
|
}
|
2007-07-17 14:22:23 +02:00
|
|
|
if (vector < 0)
|
|
|
|
goto out;
|
|
|
|
irq = find_unassigned_irq();
|
|
|
|
if (irq < 0)
|
|
|
|
goto out;
|
2007-07-17 14:22:33 +02:00
|
|
|
BUG_ON(__bind_irq_vector(irq, vector, domain));
|
2007-07-17 14:22:23 +02:00
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&vector_lock, flags);
|
|
|
|
if (irq >= 0)
|
|
|
|
dynamic_irq_init(irq);
|
|
|
|
return irq;
|
2006-10-04 11:16:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void destroy_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
dynamic_irq_cleanup(irq);
|
2007-07-17 14:22:23 +02:00
|
|
|
clear_irq_vector(irq);
|
2006-10-04 11:16:38 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
# define IS_RESCHEDULE(vec) (vec == IA64_IPI_RESCHEDULE)
|
2007-05-08 23:50:43 +02:00
|
|
|
# define IS_LOCAL_TLB_FLUSH(vec) (vec == IA64_IPI_LOCAL_TLB_FLUSH)
|
2005-04-17 00:20:36 +02:00
|
|
|
#else
|
|
|
|
# define IS_RESCHEDULE(vec) (0)
|
2007-05-08 23:50:43 +02:00
|
|
|
# define IS_LOCAL_TLB_FLUSH(vec) (0)
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* That's where the IVT branches when we get an external
|
|
|
|
* interrupt. This branches to the correct hardware IRQ handler via
|
|
|
|
* function ptr.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
ia64_handle_irq (ia64_vector vector, struct pt_regs *regs)
|
|
|
|
{
|
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 15:55:46 +02:00
|
|
|
struct pt_regs *old_regs = set_irq_regs(regs);
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long saved_tpr;
|
|
|
|
|
|
|
|
#if IRQ_DEBUG
|
|
|
|
{
|
|
|
|
unsigned long bsp, sp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: if the interrupt happened while executing in
|
|
|
|
* the context switch routine (ia64_switch_to), we may
|
|
|
|
* get a spurious stack overflow here. This is
|
|
|
|
* because the register and the memory stack are not
|
|
|
|
* switched atomically.
|
|
|
|
*/
|
|
|
|
bsp = ia64_getreg(_IA64_REG_AR_BSP);
|
|
|
|
sp = ia64_getreg(_IA64_REG_SP);
|
|
|
|
|
|
|
|
if ((sp - bsp) < 1024) {
|
|
|
|
static unsigned char count;
|
|
|
|
static long last_time;
|
|
|
|
|
|
|
|
if (jiffies - last_time > 5*HZ)
|
|
|
|
count = 0;
|
|
|
|
if (++count < 5) {
|
|
|
|
last_time = jiffies;
|
|
|
|
printk("ia64_handle_irq: DANGER: less than "
|
|
|
|
"1KB of free stack space!!\n"
|
|
|
|
"(bsp=0x%lx, sp=%lx)\n", bsp, sp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* IRQ_DEBUG */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Always set TPR to limit maximum interrupt nesting depth to
|
|
|
|
* 16 (without this, it would be ~240, which could easily lead
|
|
|
|
* to kernel stack overflows).
|
|
|
|
*/
|
|
|
|
irq_enter();
|
|
|
|
saved_tpr = ia64_getreg(_IA64_REG_CR_TPR);
|
|
|
|
ia64_srlz_d();
|
|
|
|
while (vector != IA64_SPURIOUS_INT_VECTOR) {
|
2007-05-08 23:50:43 +02:00
|
|
|
if (unlikely(IS_LOCAL_TLB_FLUSH(vector))) {
|
|
|
|
smp_local_flush_tlb();
|
|
|
|
kstat_this_cpu.irqs[vector]++;
|
|
|
|
} else if (unlikely(IS_RESCHEDULE(vector)))
|
|
|
|
kstat_this_cpu.irqs[vector]++;
|
2006-10-16 23:17:43 +02:00
|
|
|
else {
|
2007-08-29 01:01:21 +02:00
|
|
|
int irq = local_vector_to_irq(vector);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ia64_setreg(_IA64_REG_CR_TPR, vector);
|
|
|
|
ia64_srlz_d();
|
|
|
|
|
2007-08-29 01:01:21 +02:00
|
|
|
if (unlikely(irq < 0)) {
|
|
|
|
printk(KERN_ERR "%s: Unexpected interrupt "
|
|
|
|
"vector %d on CPU %d is not mapped "
|
|
|
|
"to any IRQ!\n", __FUNCTION__, vector,
|
|
|
|
smp_processor_id());
|
|
|
|
} else
|
|
|
|
generic_handle_irq(irq);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable interrupts and send EOI:
|
|
|
|
*/
|
|
|
|
local_irq_disable();
|
|
|
|
ia64_setreg(_IA64_REG_CR_TPR, saved_tpr);
|
|
|
|
}
|
|
|
|
ia64_eoi();
|
|
|
|
vector = ia64_get_ivr();
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* This must be done *after* the ia64_eoi(). For example, the keyboard softirq
|
|
|
|
* handler needs to be able to wait for further keyboard interrupts, which can't
|
|
|
|
* come through until ia64_eoi() has been done.
|
|
|
|
*/
|
|
|
|
irq_exit();
|
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 15:55:46 +02:00
|
|
|
set_irq_regs(old_regs);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
|
|
|
/*
|
|
|
|
* This function emulates a interrupt processing when a cpu is about to be
|
|
|
|
* brought down.
|
|
|
|
*/
|
|
|
|
void ia64_process_pending_intr(void)
|
|
|
|
{
|
|
|
|
ia64_vector vector;
|
|
|
|
unsigned long saved_tpr;
|
|
|
|
extern unsigned int vectors_in_migration[NR_IRQS];
|
|
|
|
|
|
|
|
vector = ia64_get_ivr();
|
|
|
|
|
|
|
|
irq_enter();
|
|
|
|
saved_tpr = ia64_getreg(_IA64_REG_CR_TPR);
|
|
|
|
ia64_srlz_d();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform normal interrupt style processing
|
|
|
|
*/
|
|
|
|
while (vector != IA64_SPURIOUS_INT_VECTOR) {
|
2007-05-08 23:50:43 +02:00
|
|
|
if (unlikely(IS_LOCAL_TLB_FLUSH(vector))) {
|
|
|
|
smp_local_flush_tlb();
|
|
|
|
kstat_this_cpu.irqs[vector]++;
|
|
|
|
} else if (unlikely(IS_RESCHEDULE(vector)))
|
|
|
|
kstat_this_cpu.irqs[vector]++;
|
2006-10-16 23:17:43 +02:00
|
|
|
else {
|
2006-10-06 19:09:41 +02:00
|
|
|
struct pt_regs *old_regs = set_irq_regs(NULL);
|
2007-08-29 01:01:21 +02:00
|
|
|
int irq = local_vector_to_irq(vector);
|
2006-10-06 19:09:41 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
ia64_setreg(_IA64_REG_CR_TPR, vector);
|
|
|
|
ia64_srlz_d();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now try calling normal ia64_handle_irq as it would have got called
|
|
|
|
* from a real intr handler. Try passing null for pt_regs, hopefully
|
|
|
|
* it will work. I hope it works!.
|
|
|
|
* Probably could shared code.
|
|
|
|
*/
|
2007-08-29 01:01:21 +02:00
|
|
|
if (unlikely(irq < 0)) {
|
|
|
|
printk(KERN_ERR "%s: Unexpected interrupt "
|
|
|
|
"vector %d on CPU %d not being mapped "
|
|
|
|
"to any IRQ!!\n", __FUNCTION__, vector,
|
|
|
|
smp_processor_id());
|
|
|
|
} else {
|
|
|
|
vectors_in_migration[irq]=0;
|
|
|
|
generic_handle_irq(irq);
|
|
|
|
}
|
2006-10-06 19:09:41 +02:00
|
|
|
set_irq_regs(old_regs);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable interrupts and send EOI
|
|
|
|
*/
|
|
|
|
local_irq_disable();
|
|
|
|
ia64_setreg(_IA64_REG_CR_TPR, saved_tpr);
|
|
|
|
}
|
|
|
|
ia64_eoi();
|
|
|
|
vector = ia64_get_ivr();
|
|
|
|
}
|
|
|
|
irq_exit();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
2006-10-16 23:17:43 +02:00
|
|
|
static irqreturn_t dummy_handler (int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
}
|
2007-05-08 23:50:43 +02:00
|
|
|
extern irqreturn_t handle_IPI (int irq, void *dev_id);
|
2006-10-16 23:17:43 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct irqaction ipi_irqaction = {
|
|
|
|
.handler = handle_IPI,
|
2006-07-02 04:29:17 +02:00
|
|
|
.flags = IRQF_DISABLED,
|
2005-04-17 00:20:36 +02:00
|
|
|
.name = "IPI"
|
|
|
|
};
|
2006-10-16 23:17:43 +02:00
|
|
|
|
|
|
|
static struct irqaction resched_irqaction = {
|
|
|
|
.handler = dummy_handler,
|
2007-02-14 09:33:16 +01:00
|
|
|
.flags = IRQF_DISABLED,
|
2006-10-16 23:17:43 +02:00
|
|
|
.name = "resched"
|
|
|
|
};
|
2007-05-08 23:50:43 +02:00
|
|
|
|
|
|
|
static struct irqaction tlb_irqaction = {
|
|
|
|
.handler = dummy_handler,
|
2007-05-09 09:43:17 +02:00
|
|
|
.flags = IRQF_DISABLED,
|
2007-05-08 23:50:43 +02:00
|
|
|
.name = "tlb_flush"
|
|
|
|
};
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
void
|
|
|
|
register_percpu_irq (ia64_vector vec, struct irqaction *action)
|
|
|
|
{
|
|
|
|
irq_desc_t *desc;
|
|
|
|
unsigned int irq;
|
|
|
|
|
2007-07-17 14:22:23 +02:00
|
|
|
irq = vec;
|
2007-07-17 14:22:33 +02:00
|
|
|
BUG_ON(bind_irq_vector(irq, vec, CPU_MASK_ALL));
|
2007-07-17 14:22:23 +02:00
|
|
|
desc = irq_desc + irq;
|
|
|
|
desc->status |= IRQ_PER_CPU;
|
|
|
|
desc->chip = &irq_type_ia64_lsapic;
|
|
|
|
if (action)
|
|
|
|
setup_irq(irq, action);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void __init
|
|
|
|
init_IRQ (void)
|
|
|
|
{
|
|
|
|
register_percpu_irq(IA64_SPURIOUS_INT_VECTOR, NULL);
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
register_percpu_irq(IA64_IPI_VECTOR, &ipi_irqaction);
|
2006-10-16 23:17:43 +02:00
|
|
|
register_percpu_irq(IA64_IPI_RESCHEDULE, &resched_irqaction);
|
2007-05-08 23:50:43 +02:00
|
|
|
register_percpu_irq(IA64_IPI_LOCAL_TLB_FLUSH, &tlb_irqaction);
|
2005-04-17 00:20:36 +02:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_PERFMON
|
|
|
|
pfm_init_percpu();
|
|
|
|
#endif
|
|
|
|
platform_irq_init();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ia64_send_ipi (int cpu, int vector, int delivery_mode, int redirect)
|
|
|
|
{
|
|
|
|
void __iomem *ipi_addr;
|
|
|
|
unsigned long ipi_data;
|
|
|
|
unsigned long phys_cpu_id;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
phys_cpu_id = cpu_physical_id(cpu);
|
|
|
|
#else
|
|
|
|
phys_cpu_id = (ia64_getreg(_IA64_REG_CR_LID) >> 16) & 0xffff;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cpu number is in 8bit ID and 8bit EID
|
|
|
|
*/
|
|
|
|
|
|
|
|
ipi_data = (delivery_mode << 8) | (vector & 0xff);
|
|
|
|
ipi_addr = ipi_base_addr + ((phys_cpu_id << 4) | ((redirect & 1) << 3));
|
|
|
|
|
|
|
|
writeq(ipi_data, ipi_addr);
|
|
|
|
}
|