Skip to content

L
linux
Commit e5217fb8 authored by Linus Torvalds's avatar Linus Torvalds
Browse files
Options

Merge branches 'irq-cleanup-for-linus' and 'irq-fixes-for-linus' of... 

Merge branches 'irq-cleanup-for-linus' and 'irq-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'irq-cleanup-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  vlynq: Convert irq functions

* 'irq-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  genirq; Fix cleanup fallout
  genirq: Fix typo and remove unused variable
  genirq: Fix new kernel-doc warnings
  genirq: Add setter for AFFINITY_SET in irq_data state
  genirq: Provide setter inline for IRQD_IRQ_INPROGRESS
  genirq: Remove handle_IRQ_event
  arm: Ns9xxx: Remove private irq flow handler
  powerpc: cell: Use the core flow handler
  genirq: Provide edge_eoi flow handler
  genirq: Move INPROGRESS, MASKED and DISABLED state flags to irq_data
  genirq: Split irq_set_affinity() so it can be called with lock held.
  genirq: Add chip flag for restricting cpu_on/offline calls
  genirq: Add chip hooks for taking CPUs on/off line.
  genirq: Add irq disabled flag to irq_data state
  genirq: Reserve the irq when calling irq_set_chip()
parents 5ede9ddf 8ec4ad2b 0ef5ca1e
Show whitespace changes
Inline Side-by-side
Showing with 297 additions and 235 deletions
arch/arm/mach-ns9xxx/irq.c
View file @ e5217fb8
...@@ -31,17 +31,11 @@ static void ns9xxx_mask_irq(struct irq_data *d) ...@@ -31,17 +31,11 @@ static void ns9xxx_mask_irq(struct irq_data *d)
__raw_writel(ic, SYS_IC(prio / 4)); __raw_writel(ic, SYS_IC(prio / 4));
} }
static void ns9xxx_ack_irq(struct irq_data *d) static void ns9xxx_eoi_irq(struct irq_data *d)
{ {
__raw_writel(0, SYS_ISRADDR); __raw_writel(0, SYS_ISRADDR);
} }
static void ns9xxx_maskack_irq(struct irq_data *d)
{
ns9xxx_mask_irq(d);
ns9xxx_ack_irq(d);
}
static void ns9xxx_unmask_irq(struct irq_data *d) static void ns9xxx_unmask_irq(struct irq_data *d)
{ {
/* XXX: better use cpp symbols */ /* XXX: better use cpp symbols */
...@@ -52,56 +46,11 @@ static void ns9xxx_unmask_irq(struct irq_data *d) ...@@ -52,56 +46,11 @@ static void ns9xxx_unmask_irq(struct irq_data *d)
} }
static struct irq_chip ns9xxx_chip = { static struct irq_chip ns9xxx_chip = {
.irq_ack = ns9xxx_ack_irq, .irq_eoi = ns9xxx_eoi_irq,
.irq_mask = ns9xxx_mask_irq, .irq_mask = ns9xxx_mask_irq,
.irq_mask_ack = ns9xxx_maskack_irq,
.irq_unmask = ns9xxx_unmask_irq, .irq_unmask = ns9xxx_unmask_irq,
}; };
#if 0
#define handle_irq handle_level_irq
#else
static void handle_prio_irq(unsigned int irq, struct irq_desc *desc)
{
struct irqaction *action;
irqreturn_t action_ret;
raw_spin_lock(&desc->lock);
BUG_ON(desc->status & IRQ_INPROGRESS);
desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
kstat_incr_irqs_this_cpu(irq, desc);
action = desc->action;
if (unlikely(!action || (desc->status & IRQ_DISABLED)))
goto out_mask;
desc->status |= IRQ_INPROGRESS;
raw_spin_unlock(&desc->lock);
action_ret = handle_IRQ_event(irq, action);
/* XXX: There is no direct way to access noirqdebug, so check
* unconditionally for spurious irqs...
* Maybe this function should go to kernel/irq/chip.c? */
note_interrupt(irq, desc, action_ret);
raw_spin_lock(&desc->lock);
desc->status &= ~IRQ_INPROGRESS;
if (desc->status & IRQ_DISABLED)
out_mask:
desc->irq_data.chip->irq_mask(&desc->irq_data);
/* ack unconditionally to unmask lower prio irqs */
desc->irq_data.chip->irq_ack(&desc->irq_data);
raw_spin_unlock(&desc->lock);
}
#define handle_irq handle_prio_irq
#endif
void __init ns9xxx_init_irq(void) void __init ns9xxx_init_irq(void)
{ {
int i; int i;
...@@ -119,7 +68,8 @@ void __init ns9xxx_init_irq(void) ...@@ -119,7 +68,8 @@ void __init ns9xxx_init_irq(void)
for (i = 0; i <= 31; ++i) { for (i = 0; i <= 31; ++i) {
set_irq_chip(i, &ns9xxx_chip); set_irq_chip(i, &ns9xxx_chip);
set_irq_handler(i, handle_irq); set_irq_handler(i, handle_fasteoi_irq);
set_irq_flags(i, IRQF_VALID); set_irq_flags(i, IRQF_VALID);
irq_set_status_flags(i, IRQ_LEVEL);
} }
} }
arch/powerpc/platforms/cell/Kconfig
View file @ e5217fb8
...@@ -9,6 +9,7 @@ config PPC_CELL_COMMON ...@@ -9,6 +9,7 @@ config PPC_CELL_COMMON
select PPC_INDIRECT_IO select PPC_INDIRECT_IO
select PPC_NATIVE select PPC_NATIVE
select PPC_RTAS select PPC_RTAS
select IRQ_EDGE_EOI_HANDLER
config PPC_CELL_NATIVE config PPC_CELL_NATIVE
bool bool
......
arch/powerpc/platforms/cell/interrupt.c
View file @ e5217fb8
...@@ -235,54 +235,6 @@ static int iic_host_match(struct irq_host *h, struct device_node *node) ...@@ -235,54 +235,6 @@ static int iic_host_match(struct irq_host *h, struct device_node *node)
"IBM,CBEA-Internal-Interrupt-Controller"); "IBM,CBEA-Internal-Interrupt-Controller");
} }
extern int noirqdebug;
static void handle_iic_irq(unsigned int irq, struct irq_desc *desc)
{
struct irq_chip *chip = get_irq_desc_chip(desc);
raw_spin_lock(&desc->lock);
desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
/*
* If we're currently running this IRQ, or its disabled,
* we shouldn't process the IRQ. Mark it pending, handle
* the necessary masking and go out
*/
if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
!desc->action)) {
desc->status |= IRQ_PENDING;
goto out_eoi;
}
kstat_incr_irqs_this_cpu(irq, desc);
/* Mark the IRQ currently in progress.*/
desc->status |= IRQ_INPROGRESS;
do {
struct irqaction *action = desc->action;
irqreturn_t action_ret;
if (unlikely(!action))
goto out_eoi;
desc->status &= ~IRQ_PENDING;
raw_spin_unlock(&desc->lock);
action_ret = handle_IRQ_event(irq, action);
if (!noirqdebug)
note_interrupt(irq, desc, action_ret);
raw_spin_lock(&desc->lock);
} while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
desc->status &= ~IRQ_INPROGRESS;
out_eoi:
chip->irq_eoi(&desc->irq_data);
raw_spin_unlock(&desc->lock);
}
static int iic_host_map(struct irq_host *h, unsigned int virq, static int iic_host_map(struct irq_host *h, unsigned int virq,
irq_hw_number_t hw) irq_hw_number_t hw)
{ {
...@@ -295,7 +247,7 @@ static int iic_host_map(struct irq_host *h, unsigned int virq, ...@@ -295,7 +247,7 @@ static int iic_host_map(struct irq_host *h, unsigned int virq,
handle_iic_irq); handle_iic_irq);
break; break;
default: default:
set_irq_chip_and_handler(virq, &iic_chip, handle_iic_irq); set_irq_chip_and_handler(virq, &iic_chip, handle_edge_eoi_irq);
} }
return 0; return 0;
} }
......
drivers/vlynq/vlynq.c
View file @ e5217fb8
...@@ -135,40 +135,40 @@ static void vlynq_reset(struct vlynq_device *dev) ...@@ -135,40 +135,40 @@ static void vlynq_reset(struct vlynq_device *dev)
msleep(5); msleep(5);
} }
static void vlynq_irq_unmask(unsigned int irq) static void vlynq_irq_unmask(struct irq_data *d)
{ {
u32 val; struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
struct vlynq_device *dev = get_irq_chip_data(irq);
int virq; int virq;
u32 val;
BUG_ON(!dev); BUG_ON(!dev);
virq = irq - dev->irq_start; virq = d->irq - dev->irq_start;
val = readl(&dev->remote->int_device[virq >> 2]); val = readl(&dev->remote->int_device[virq >> 2]);
val |= (VINT_ENABLE | virq) << VINT_OFFSET(virq); val |= (VINT_ENABLE | virq) << VINT_OFFSET(virq);
writel(val, &dev->remote->int_device[virq >> 2]); writel(val, &dev->remote->int_device[virq >> 2]);
} }
static void vlynq_irq_mask(unsigned int irq) static void vlynq_irq_mask(struct irq_data *d)
{ {
u32 val; struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
struct vlynq_device *dev = get_irq_chip_data(irq);
int virq; int virq;
u32 val;
BUG_ON(!dev); BUG_ON(!dev);
virq = irq - dev->irq_start; virq = d->irq - dev->irq_start;
val = readl(&dev->remote->int_device[virq >> 2]); val = readl(&dev->remote->int_device[virq >> 2]);
val &= ~(VINT_ENABLE << VINT_OFFSET(virq)); val &= ~(VINT_ENABLE << VINT_OFFSET(virq));
writel(val, &dev->remote->int_device[virq >> 2]); writel(val, &dev->remote->int_device[virq >> 2]);
} }
static int vlynq_irq_type(unsigned int irq, unsigned int flow_type) static int vlynq_irq_type(struct irq_data *d, unsigned int flow_type)
{ {
u32 val; struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
struct vlynq_device *dev = get_irq_chip_data(irq);
int virq; int virq;
u32 val;
BUG_ON(!dev); BUG_ON(!dev);
virq = irq - dev->irq_start; virq = d->irq - dev->irq_start;
val = readl(&dev->remote->int_device[virq >> 2]); val = readl(&dev->remote->int_device[virq >> 2]);
switch (flow_type & IRQ_TYPE_SENSE_MASK) { switch (flow_type & IRQ_TYPE_SENSE_MASK) {
case IRQ_TYPE_EDGE_RISING: case IRQ_TYPE_EDGE_RISING:
...@@ -192,10 +192,9 @@ static int vlynq_irq_type(unsigned int irq, unsigned int flow_type) ...@@ -192,10 +192,9 @@ static int vlynq_irq_type(unsigned int irq, unsigned int flow_type)
return 0; return 0;
} }
static void vlynq_local_ack(unsigned int irq) static void vlynq_local_ack(struct irq_data *d)
{ {
struct vlynq_device *dev = get_irq_chip_data(irq); struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
u32 status = readl(&dev->local->status); u32 status = readl(&dev->local->status);
pr_debug("%s: local status: 0x%08x\n", pr_debug("%s: local status: 0x%08x\n",
...@@ -203,10 +202,9 @@ static void vlynq_local_ack(unsigned int irq) ...@@ -203,10 +202,9 @@ static void vlynq_local_ack(unsigned int irq)
writel(status, &dev->local->status); writel(status, &dev->local->status);
} }
static void vlynq_remote_ack(unsigned int irq) static void vlynq_remote_ack(struct irq_data *d)
{ {
struct vlynq_device *dev = get_irq_chip_data(irq); struct vlynq_device *dev = irq_data_get_irq_chip_data(d);
u32 status = readl(&dev->remote->status); u32 status = readl(&dev->remote->status);
pr_debug("%s: remote status: 0x%08x\n", pr_debug("%s: remote status: 0x%08x\n",
...@@ -238,23 +236,23 @@ static irqreturn_t vlynq_irq(int irq, void *dev_id) ...@@ -238,23 +236,23 @@ static irqreturn_t vlynq_irq(int irq, void *dev_id)
static struct irq_chip vlynq_irq_chip = { static struct irq_chip vlynq_irq_chip = {
.name = "vlynq", .name = "vlynq",
.unmask = vlynq_irq_unmask, .irq_unmask = vlynq_irq_unmask,
.mask = vlynq_irq_mask, .irq_mask = vlynq_irq_mask,
.set_type = vlynq_irq_type, .irq_set_type = vlynq_irq_type,
}; };
static struct irq_chip vlynq_local_chip = { static struct irq_chip vlynq_local_chip = {
.name = "vlynq local error", .name = "vlynq local error",
.unmask = vlynq_irq_unmask, .irq_unmask = vlynq_irq_unmask,
.mask = vlynq_irq_mask, .irq_mask = vlynq_irq_mask,
.ack = vlynq_local_ack, .irq_ack = vlynq_local_ack,
}; };
static struct irq_chip vlynq_remote_chip = { static struct irq_chip vlynq_remote_chip = {
.name = "vlynq local error", .name = "vlynq local error",
.unmask = vlynq_irq_unmask, .irq_unmask = vlynq_irq_unmask,
.mask = vlynq_irq_mask, .irq_mask = vlynq_irq_mask,
.ack = vlynq_remote_ack, .irq_ack = vlynq_remote_ack,
}; };
static int vlynq_setup_irq(struct vlynq_device *dev) static int vlynq_setup_irq(struct vlynq_device *dev)
...@@ -291,17 +289,17 @@ static int vlynq_setup_irq(struct vlynq_device *dev) ...@@ -291,17 +289,17 @@ static int vlynq_setup_irq(struct vlynq_device *dev)
for (i = dev->irq_start; i <= dev->irq_end; i++) { for (i = dev->irq_start; i <= dev->irq_end; i++) {
virq = i - dev->irq_start; virq = i - dev->irq_start;
if (virq == dev->local_irq) { if (virq == dev->local_irq) {
set_irq_chip_and_handler(i, &vlynq_local_chip, irq_set_chip_and_handler(i, &vlynq_local_chip,
handle_level_irq); handle_level_irq);
set_irq_chip_data(i, dev); irq_set_chip_data(i, dev);
} else if (virq == dev->remote_irq) { } else if (virq == dev->remote_irq) {
set_irq_chip_and_handler(i, &vlynq_remote_chip, irq_set_chip_and_handler(i, &vlynq_remote_chip,
handle_level_irq); handle_level_irq);
set_irq_chip_data(i, dev); irq_set_chip_data(i, dev);
} else { } else {
set_irq_chip_and_handler(i, &vlynq_irq_chip, irq_set_chip_and_handler(i, &vlynq_irq_chip,
handle_simple_irq); handle_simple_irq);
set_irq_chip_data(i, dev); irq_set_chip_data(i, dev);
writel(0, &dev->remote->int_device[virq >> 2]); writel(0, &dev->remote->int_device[virq >> 2]);
} }
} }
......
include/linux/irq.h
View file @ e5217fb8
...@@ -135,7 +135,7 @@ struct msi_desc; ...@@ -135,7 +135,7 @@ struct msi_desc;
* struct irq_data - per irq and irq chip data passed down to chip functions * struct irq_data - per irq and irq chip data passed down to chip functions
* @irq: interrupt number * @irq: interrupt number
* @node: node index useful for balancing * @node: node index useful for balancing
* @state_use_accessor: status information for irq chip functions. * @state_use_accessors: status information for irq chip functions.
* Use accessor functions to deal with it * Use accessor functions to deal with it
* @chip: low level interrupt hardware access * @chip: low level interrupt hardware access
* @handler_data: per-IRQ data for the irq_chip methods * @handler_data: per-IRQ data for the irq_chip methods
...@@ -174,6 +174,9 @@ struct irq_data { ...@@ -174,6 +174,9 @@ struct irq_data {
* from suspend * from suspend
* IRDQ_MOVE_PCNTXT - Interrupt can be moved in process * IRDQ_MOVE_PCNTXT - Interrupt can be moved in process
* context * context
* IRQD_IRQ_DISABLED - Disabled state of the interrupt
* IRQD_IRQ_MASKED - Masked state of the interrupt
* IRQD_IRQ_INPROGRESS - In progress state of the interrupt
*/ */
enum { enum {
IRQD_TRIGGER_MASK = 0xf, IRQD_TRIGGER_MASK = 0xf,
...@@ -184,6 +187,9 @@ enum { ...@@ -184,6 +187,9 @@ enum {
IRQD_LEVEL = (1 << 13), IRQD_LEVEL = (1 << 13),
IRQD_WAKEUP_STATE = (1 << 14), IRQD_WAKEUP_STATE = (1 << 14),
IRQD_MOVE_PCNTXT = (1 << 15), IRQD_MOVE_PCNTXT = (1 << 15),
IRQD_IRQ_DISABLED = (1 << 16),
IRQD_IRQ_MASKED = (1 << 17),
IRQD_IRQ_INPROGRESS = (1 << 18),
}; };
static inline bool irqd_is_setaffinity_pending(struct irq_data *d) static inline bool irqd_is_setaffinity_pending(struct irq_data *d)
...@@ -206,6 +212,11 @@ static inline bool irqd_affinity_was_set(struct irq_data *d) ...@@ -206,6 +212,11 @@ static inline bool irqd_affinity_was_set(struct irq_data *d)
return d->state_use_accessors & IRQD_AFFINITY_SET; return d->state_use_accessors & IRQD_AFFINITY_SET;
} }
static inline void irqd_mark_affinity_was_set(struct irq_data *d)
{
d->state_use_accessors |= IRQD_AFFINITY_SET;
}
static inline u32 irqd_get_trigger_type(struct irq_data *d) static inline u32 irqd_get_trigger_type(struct irq_data *d)
{ {
return d->state_use_accessors & IRQD_TRIGGER_MASK; return d->state_use_accessors & IRQD_TRIGGER_MASK;
...@@ -235,6 +246,36 @@ static inline bool irqd_can_move_in_process_context(struct irq_data *d) ...@@ -235,6 +246,36 @@ static inline bool irqd_can_move_in_process_context(struct irq_data *d)
return d->state_use_accessors & IRQD_MOVE_PCNTXT; return d->state_use_accessors & IRQD_MOVE_PCNTXT;
} }
static inline bool irqd_irq_disabled(struct irq_data *d)
{
return d->state_use_accessors & IRQD_IRQ_DISABLED;
}
static inline bool irqd_irq_masked(struct irq_data *d)
{
return d->state_use_accessors & IRQD_IRQ_MASKED;
}
static inline bool irqd_irq_inprogress(struct irq_data *d)
{
return d->state_use_accessors & IRQD_IRQ_INPROGRESS;
}
/*
* Functions for chained handlers which can be enabled/disabled by the
* standard disable_irq/enable_irq calls. Must be called with
* irq_desc->lock held.
*/
static inline void irqd_set_chained_irq_inprogress(struct irq_data *d)
{
d->state_use_accessors |= IRQD_IRQ_INPROGRESS;
}
static inline void irqd_clr_chained_irq_inprogress(struct irq_data *d)
{
d->state_use_accessors &= ~IRQD_IRQ_INPROGRESS;
}
/** /**
* struct irq_chip - hardware interrupt chip descriptor * struct irq_chip - hardware interrupt chip descriptor
* *
...@@ -271,6 +312,8 @@ static inline bool irqd_can_move_in_process_context(struct irq_data *d) ...@@ -271,6 +312,8 @@ static inline bool irqd_can_move_in_process_context(struct irq_data *d)
* @irq_set_wake: enable/disable power-management wake-on of an IRQ * @irq_set_wake: enable/disable power-management wake-on of an IRQ
* @irq_bus_lock: function to lock access to slow bus (i2c) chips * @irq_bus_lock: function to lock access to slow bus (i2c) chips
* @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips
* @irq_cpu_online: configure an interrupt source for a secondary CPU
* @irq_cpu_offline: un-configure an interrupt source for a secondary CPU
* @irq_print_chip: optional to print special chip info in show_interrupts * @irq_print_chip: optional to print special chip info in show_interrupts
* @flags: chip specific flags * @flags: chip specific flags
* *
...@@ -319,6 +362,9 @@ struct irq_chip { ...@@ -319,6 +362,9 @@ struct irq_chip {
void (*irq_bus_lock)(struct irq_data *data); void (*irq_bus_lock)(struct irq_data *data);
void (*irq_bus_sync_unlock)(struct irq_data *data); void (*irq_bus_sync_unlock)(struct irq_data *data);
void (*irq_cpu_online)(struct irq_data *data);
void (*irq_cpu_offline)(struct irq_data *data);
void (*irq_print_chip)(struct irq_data *data, struct seq_file *p); void (*irq_print_chip)(struct irq_data *data, struct seq_file *p);
unsigned long flags; unsigned long flags;
...@@ -335,11 +381,14 @@ struct irq_chip { ...@@ -335,11 +381,14 @@ struct irq_chip {
* IRQCHIP_SET_TYPE_MASKED: Mask before calling chip.irq_set_type() * IRQCHIP_SET_TYPE_MASKED: Mask before calling chip.irq_set_type()
* IRQCHIP_EOI_IF_HANDLED: Only issue irq_eoi() when irq was handled * IRQCHIP_EOI_IF_HANDLED: Only issue irq_eoi() when irq was handled
* IRQCHIP_MASK_ON_SUSPEND: Mask non wake irqs in the suspend path * IRQCHIP_MASK_ON_SUSPEND: Mask non wake irqs in the suspend path
* IRQCHIP_ONOFFLINE_ENABLED: Only call irq_on/off_line callbacks
* when irq enabled
*/ */
enum { enum {
IRQCHIP_SET_TYPE_MASKED = (1 << 0), IRQCHIP_SET_TYPE_MASKED = (1 << 0),
IRQCHIP_EOI_IF_HANDLED = (1 << 1), IRQCHIP_EOI_IF_HANDLED = (1 << 1),
IRQCHIP_MASK_ON_SUSPEND = (1 << 2), IRQCHIP_MASK_ON_SUSPEND = (1 << 2),
IRQCHIP_ONOFFLINE_ENABLED = (1 << 3),
}; };
/* This include will go away once we isolated irq_desc usage to core code */ /* This include will go away once we isolated irq_desc usage to core code */
...@@ -364,6 +413,10 @@ struct irqaction; ...@@ -364,6 +413,10 @@ struct irqaction;
extern int setup_irq(unsigned int irq, struct irqaction *new); extern int setup_irq(unsigned int irq, struct irqaction *new);
extern void remove_irq(unsigned int irq, struct irqaction *act); extern void remove_irq(unsigned int irq, struct irqaction *act);
extern void irq_cpu_online(void);
extern void irq_cpu_offline(void);
extern int __irq_set_affinity_locked(struct irq_data *data, const struct cpumask *cpumask);
#ifdef CONFIG_GENERIC_HARDIRQS #ifdef CONFIG_GENERIC_HARDIRQS
#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ) #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
...@@ -380,9 +433,6 @@ static inline void irq_move_masked_irq(struct irq_data *data) { } ...@@ -380,9 +433,6 @@ static inline void irq_move_masked_irq(struct irq_data *data) { }
extern int no_irq_affinity; extern int no_irq_affinity;
/* Handle irq action chains: */
extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action);
/* /*
* Built-in IRQ handlers for various IRQ types, * Built-in IRQ handlers for various IRQ types,
* callable via desc->handle_irq() * callable via desc->handle_irq()
...@@ -390,6 +440,7 @@ extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action); ...@@ -390,6 +440,7 @@ extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action);
extern void handle_level_irq(unsigned int irq, struct irq_desc *desc); extern void handle_level_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc); extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc); extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_edge_eoi_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc); extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc); extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc); extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
......
kernel/irq/Kconfig
View file @ e5217fb8
...@@ -51,6 +51,10 @@ config HARDIRQS_SW_RESEND ...@@ -51,6 +51,10 @@ config HARDIRQS_SW_RESEND
config IRQ_PREFLOW_FASTEOI config IRQ_PREFLOW_FASTEOI
bool bool
# Edge style eoi based handler (cell)
config IRQ_EDGE_EOI_HANDLER
bool
# Support forced irq threading # Support forced irq threading
config IRQ_FORCED_THREADING config IRQ_FORCED_THREADING
bool bool
......
kernel/irq/chip.c
View file @ e5217fb8
...@@ -37,6 +37,12 @@ int irq_set_chip(unsigned int irq, struct irq_chip *chip) ...@@ -37,6 +37,12 @@ int irq_set_chip(unsigned int irq, struct irq_chip *chip)
irq_chip_set_defaults(chip); irq_chip_set_defaults(chip);
desc->irq_data.chip = chip; desc->irq_data.chip = chip;
irq_put_desc_unlock(desc, flags); irq_put_desc_unlock(desc, flags);
/*
* For !CONFIG_SPARSE_IRQ make the irq show up in
* allocated_irqs. For the CONFIG_SPARSE_IRQ case, it is
* already marked, and this call is harmless.
*/
irq_reserve_irq(irq);
return 0; return 0;
} }
EXPORT_SYMBOL(irq_set_chip); EXPORT_SYMBOL(irq_set_chip);
...@@ -134,25 +140,25 @@ EXPORT_SYMBOL_GPL(irq_get_irq_data); ...@@ -134,25 +140,25 @@ EXPORT_SYMBOL_GPL(irq_get_irq_data);
static void irq_state_clr_disabled(struct irq_desc *desc) static void irq_state_clr_disabled(struct irq_desc *desc)
{ {
desc->istate &= ~IRQS_DISABLED; irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
irq_compat_clr_disabled(desc); irq_compat_clr_disabled(desc);
} }
static void irq_state_set_disabled(struct irq_desc *desc) static void irq_state_set_disabled(struct irq_desc *desc)
{ {
desc->istate |= IRQS_DISABLED; irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
irq_compat_set_disabled(desc); irq_compat_set_disabled(desc);
} }
static void irq_state_clr_masked(struct irq_desc *desc) static void irq_state_clr_masked(struct irq_desc *desc)
{ {
desc->istate &= ~IRQS_MASKED; irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
irq_compat_clr_masked(desc); irq_compat_clr_masked(desc);
} }
static void irq_state_set_masked(struct irq_desc *desc) static void irq_state_set_masked(struct irq_desc *desc)
{ {
desc->istate |= IRQS_MASKED; irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
irq_compat_set_masked(desc); irq_compat_set_masked(desc);
} }
...@@ -372,11 +378,11 @@ void handle_nested_irq(unsigned int irq) ...@@ -372,11 +378,11 @@ void handle_nested_irq(unsigned int irq)
kstat_incr_irqs_this_cpu(irq, desc); kstat_incr_irqs_this_cpu(irq, desc);
action = desc->action; action = desc->action;
if (unlikely(!action || (desc->istate & IRQS_DISABLED))) if (unlikely(!action || irqd_irq_disabled(&desc->irq_data)))
goto out_unlock; goto out_unlock;
irq_compat_set_progress(desc); irq_compat_set_progress(desc);
desc->istate |= IRQS_INPROGRESS; irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
raw_spin_unlock_irq(&desc->lock); raw_spin_unlock_irq(&desc->lock);
action_ret = action->thread_fn(action->irq, action->dev_id); action_ret = action->thread_fn(action->irq, action->dev_id);
...@@ -384,7 +390,7 @@ void handle_nested_irq(unsigned int irq) ...@@ -384,7 +390,7 @@ void handle_nested_irq(unsigned int irq)
note_interrupt(irq, desc, action_ret); note_interrupt(irq, desc, action_ret);
raw_spin_lock_irq(&desc->lock); raw_spin_lock_irq(&desc->lock);
desc->istate &= ~IRQS_INPROGRESS; irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
irq_compat_clr_progress(desc); irq_compat_clr_progress(desc);
out_unlock: out_unlock:
...@@ -416,14 +422,14 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc) ...@@ -416,14 +422,14 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc)
{ {
raw_spin_lock(&desc->lock); raw_spin_lock(&desc->lock);
if (unlikely(desc->istate & IRQS_INPROGRESS)) if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
if (!irq_check_poll(desc)) if (!irq_check_poll(desc))
goto out_unlock; goto out_unlock;
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING); desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
kstat_incr_irqs_this_cpu(irq, desc); kstat_incr_irqs_this_cpu(irq, desc);
if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED))) if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
goto out_unlock; goto out_unlock;
handle_irq_event(desc); handle_irq_event(desc);
...@@ -448,7 +454,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc) ...@@ -448,7 +454,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
raw_spin_lock(&desc->lock); raw_spin_lock(&desc->lock);
mask_ack_irq(desc); mask_ack_irq(desc);
if (unlikely(desc->istate & IRQS_INPROGRESS)) if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
if (!irq_check_poll(desc)) if (!irq_check_poll(desc))
goto out_unlock; goto out_unlock;
...@@ -459,12 +465,12 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc) ...@@ -459,12 +465,12 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
* If its disabled or no action available * If its disabled or no action available
* keep it masked and get out of here * keep it masked and get out of here
*/ */
if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED))) if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
goto out_unlock; goto out_unlock;
handle_irq_event(desc); handle_irq_event(desc);
if (!(desc->istate & (IRQS_DISABLED | IRQS_ONESHOT))) if (!irqd_irq_disabled(&desc->irq_data) && !(desc->istate & IRQS_ONESHOT))
unmask_irq(desc); unmask_irq(desc);
out_unlock: out_unlock:
raw_spin_unlock(&desc->lock); raw_spin_unlock(&desc->lock);
...@@ -496,7 +502,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc) ...@@ -496,7 +502,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
{ {
raw_spin_lock(&desc->lock); raw_spin_lock(&desc->lock);
if (unlikely(desc->istate & IRQS_INPROGRESS)) if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
if (!irq_check_poll(desc)) if (!irq_check_poll(desc))
goto out; goto out;
...@@ -507,7 +513,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc) ...@@ -507,7 +513,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
* If its disabled or no action available * If its disabled or no action available
* then mask it and get out of here: * then mask it and get out of here:
*/ */
if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED))) { if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
irq_compat_set_pending(desc); irq_compat_set_pending(desc);
desc->istate |= IRQS_PENDING; desc->istate |= IRQS_PENDING;
mask_irq(desc); mask_irq(desc);
...@@ -558,8 +564,8 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc) ...@@ -558,8 +564,8 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
* we shouldn't process the IRQ. Mark it pending, handle * we shouldn't process the IRQ. Mark it pending, handle
* the necessary masking and go out * the necessary masking and go out
*/ */
if (unlikely((desc->istate & (IRQS_DISABLED | IRQS_INPROGRESS) || if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
!desc->action))) { irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
if (!irq_check_poll(desc)) { if (!irq_check_poll(desc)) {
irq_compat_set_pending(desc); irq_compat_set_pending(desc);
desc->istate |= IRQS_PENDING; desc->istate |= IRQS_PENDING;
...@@ -584,19 +590,64 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc) ...@@ -584,19 +590,64 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
* Renable it, if it was not disabled in meantime. * Renable it, if it was not disabled in meantime.
*/ */
if (unlikely(desc->istate & IRQS_PENDING)) { if (unlikely(desc->istate & IRQS_PENDING)) {
if (!(desc->istate & IRQS_DISABLED) && if (!irqd_irq_disabled(&desc->irq_data) &&
(desc->istate & IRQS_MASKED)) irqd_irq_masked(&desc->irq_data))
unmask_irq(desc); unmask_irq(desc);
} }
handle_irq_event(desc); handle_irq_event(desc);
} while ((desc->istate & IRQS_PENDING) && } while ((desc->istate & IRQS_PENDING) &&
!(desc->istate & IRQS_DISABLED)); !irqd_irq_disabled(&desc->irq_data));
out_unlock:
raw_spin_unlock(&desc->lock);
}
#ifdef CONFIG_IRQ_EDGE_EOI_HANDLER
/**
* handle_edge_eoi_irq - edge eoi type IRQ handler
* @irq: the interrupt number
* @desc: the interrupt description structure for this irq
*
* Similar as the above handle_edge_irq, but using eoi and w/o the
* mask/unmask logic.
*/
void handle_edge_eoi_irq(unsigned int irq, struct irq_desc *desc)
{
struct irq_chip *chip = irq_desc_get_chip(desc);
raw_spin_lock(&desc->lock);
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
/*
* If we're currently running this IRQ, or its disabled,
* we shouldn't process the IRQ. Mark it pending, handle
* the necessary masking and go out
*/
if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
if (!irq_check_poll(desc)) {
desc->istate |= IRQS_PENDING;
goto out_eoi;
}
}
kstat_incr_irqs_this_cpu(irq, desc);
do {
if (unlikely(!desc->action))
goto out_eoi;
handle_irq_event(desc);
} while ((desc->istate & IRQS_PENDING) &&
!irqd_irq_disabled(&desc->irq_data));
out_unlock: out_unlock:
chip->irq_eoi(&desc->irq_data);
raw_spin_unlock(&desc->lock); raw_spin_unlock(&desc->lock);
} }
#endif
/** /**
* handle_percpu_irq - Per CPU local irq handler * handle_percpu_irq - Per CPU local irq handler
...@@ -642,8 +693,7 @@ __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained, ...@@ -642,8 +693,7 @@ __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
if (handle == handle_bad_irq) { if (handle == handle_bad_irq) {
if (desc->irq_data.chip != &no_irq_chip) if (desc->irq_data.chip != &no_irq_chip)
mask_ack_irq(desc); mask_ack_irq(desc);
irq_compat_set_disabled(desc); irq_state_set_disabled(desc);
desc->istate |= IRQS_DISABLED;
desc->depth = 1; desc->depth = 1;
} }
desc->handle_irq = handle; desc->handle_irq = handle;
...@@ -684,8 +734,70 @@ void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set) ...@@ -684,8 +734,70 @@ void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
irqd_set(&desc->irq_data, IRQD_PER_CPU); irqd_set(&desc->irq_data, IRQD_PER_CPU);
if (irq_settings_can_move_pcntxt(desc)) if (irq_settings_can_move_pcntxt(desc))
irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT); irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT);
if (irq_settings_is_level(desc))
irqd_set(&desc->irq_data, IRQD_LEVEL);
irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc)); irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc));
irq_put_desc_unlock(desc, flags); irq_put_desc_unlock(desc, flags);
} }
/**
* irq_cpu_online - Invoke all irq_cpu_online functions.
*
* Iterate through all irqs and invoke the chip.irq_cpu_online()
* for each.
*/
void irq_cpu_online(void)
{
struct irq_desc *desc;
struct irq_chip *chip;
unsigned long flags;
unsigned int irq;
for_each_active_irq(irq) {
desc = irq_to_desc(irq);
if (!desc)
continue;
raw_spin_lock_irqsave(&desc->lock, flags);
chip = irq_data_get_irq_chip(&desc->irq_data);
if (chip && chip->irq_cpu_online &&
(!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
!irqd_irq_disabled(&desc->irq_data)))
chip->irq_cpu_online(&desc->irq_data);
raw_spin_unlock_irqrestore(&desc->lock, flags);
}
}
/**
* irq_cpu_offline - Invoke all irq_cpu_offline functions.
*
* Iterate through all irqs and invoke the chip.irq_cpu_offline()
* for each.
*/
void irq_cpu_offline(void)
{
struct irq_desc *desc;
struct irq_chip *chip;
unsigned long flags;
unsigned int irq;
for_each_active_irq(irq) {
desc = irq_to_desc(irq);
if (!desc)
continue;
raw_spin_lock_irqsave(&desc->lock, flags);
chip = irq_data_get_irq_chip(&desc->irq_data);
if (chip && chip->irq_cpu_offline &&
(!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
!irqd_irq_disabled(&desc->irq_data)))
chip->irq_cpu_offline(&desc->irq_data);
raw_spin_unlock_irqrestore(&desc->lock, flags);
}
}
kernel/irq/debug.h
View file @ e5217fb8
...@@ -6,6 +6,8 @@ ...@@ -6,6 +6,8 @@
#define P(f) if (desc->status & f) printk("%14s set\n", #f) #define P(f) if (desc->status & f) printk("%14s set\n", #f)
#define PS(f) if (desc->istate & f) printk("%14s set\n", #f) #define PS(f) if (desc->istate & f) printk("%14s set\n", #f)
/* FIXME */
#define PD(f) do { } while (0)
static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc) static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
{ {
...@@ -28,13 +30,15 @@ static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc) ...@@ -28,13 +30,15 @@ static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
P(IRQ_NOAUTOEN); P(IRQ_NOAUTOEN);
PS(IRQS_AUTODETECT); PS(IRQS_AUTODETECT);
PS(IRQS_INPROGRESS);
PS(IRQS_REPLAY); PS(IRQS_REPLAY);
PS(IRQS_WAITING); PS(IRQS_WAITING);
PS(IRQS_DISABLED);
PS(IRQS_PENDING); PS(IRQS_PENDING);
PS(IRQS_MASKED);
PD(IRQS_INPROGRESS);
PD(IRQS_DISABLED);
PD(IRQS_MASKED);
} }
#undef P #undef P
#undef PS #undef PS
#undef PD
kernel/irq/handle.c
View file @ e5217fb8
...@@ -178,25 +178,13 @@ irqreturn_t handle_irq_event(struct irq_desc *desc) ...@@ -178,25 +178,13 @@ irqreturn_t handle_irq_event(struct irq_desc *desc)
irq_compat_clr_pending(desc); irq_compat_clr_pending(desc);
desc->istate &= ~IRQS_PENDING; desc->istate &= ~IRQS_PENDING;
irq_compat_set_progress(desc); irq_compat_set_progress(desc);
desc->istate |= IRQS_INPROGRESS; irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
raw_spin_unlock(&desc->lock); raw_spin_unlock(&desc->lock);
ret = handle_irq_event_percpu(desc, action); ret = handle_irq_event_percpu(desc, action);
raw_spin_lock(&desc->lock); raw_spin_lock(&desc->lock);
desc->istate &= ~IRQS_INPROGRESS; irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
irq_compat_clr_progress(desc); irq_compat_clr_progress(desc);
return ret; return ret;
} }
/**
* handle_IRQ_event - irq action chain handler
* @irq: the interrupt number
* @action: the interrupt action chain for this irq
*
* Handles the action chain of an irq event
*/
irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
{
return handle_irq_event_percpu(irq_to_desc(irq), action);
}
kernel/irq/internals.h
View file @ e5217fb8
...@@ -44,26 +44,20 @@ enum { ...@@ -44,26 +44,20 @@ enum {
* IRQS_SPURIOUS_DISABLED - was disabled due to spurious interrupt * IRQS_SPURIOUS_DISABLED - was disabled due to spurious interrupt
* detection * detection
* IRQS_POLL_INPROGRESS - polling in progress * IRQS_POLL_INPROGRESS - polling in progress
* IRQS_INPROGRESS - Interrupt in progress
* IRQS_ONESHOT - irq is not unmasked in primary handler * IRQS_ONESHOT - irq is not unmasked in primary handler
* IRQS_REPLAY - irq is replayed * IRQS_REPLAY - irq is replayed
* IRQS_WAITING - irq is waiting * IRQS_WAITING - irq is waiting
* IRQS_DISABLED - irq is disabled
* IRQS_PENDING - irq is pending and replayed later * IRQS_PENDING - irq is pending and replayed later
* IRQS_MASKED - irq is masked
* IRQS_SUSPENDED - irq is suspended * IRQS_SUSPENDED - irq is suspended
*/ */
enum { enum {
IRQS_AUTODETECT = 0x00000001, IRQS_AUTODETECT = 0x00000001,
IRQS_SPURIOUS_DISABLED = 0x00000002, IRQS_SPURIOUS_DISABLED = 0x00000002,
IRQS_POLL_INPROGRESS = 0x00000008, IRQS_POLL_INPROGRESS = 0x00000008,
IRQS_INPROGRESS = 0x00000010,
IRQS_ONESHOT = 0x00000020, IRQS_ONESHOT = 0x00000020,
IRQS_REPLAY = 0x00000040, IRQS_REPLAY = 0x00000040,
IRQS_WAITING = 0x00000080, IRQS_WAITING = 0x00000080,
IRQS_DISABLED = 0x00000100,
IRQS_PENDING = 0x00000200, IRQS_PENDING = 0x00000200,
IRQS_MASKED = 0x00000400,
IRQS_SUSPENDED = 0x00000800, IRQS_SUSPENDED = 0x00000800,
}; };
......
kernel/irq/irqdesc.c
View file @ e5217fb8
...@@ -80,7 +80,7 @@ static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node) ...@@ -80,7 +80,7 @@ static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node)
desc->irq_data.handler_data = NULL; desc->irq_data.handler_data = NULL;
desc->irq_data.msi_desc = NULL; desc->irq_data.msi_desc = NULL;
irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS); irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS);
desc->istate = IRQS_DISABLED; irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
desc->handle_irq = handle_bad_irq; desc->handle_irq = handle_bad_irq;
desc->depth = 1; desc->depth = 1;
desc->irq_count = 0; desc->irq_count = 0;
...@@ -238,7 +238,6 @@ int __init early_irq_init(void) ...@@ -238,7 +238,6 @@ int __init early_irq_init(void)
struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = { struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
[0 ... NR_IRQS-1] = { [0 ... NR_IRQS-1] = {
.istate = IRQS_DISABLED,
.handle_irq = handle_bad_irq, .handle_irq = handle_bad_irq,
.depth = 1, .depth = 1,
.lock = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock), .lock = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),
......
kernel/irq/manage.c
View file @ e5217fb8
...@@ -41,7 +41,7 @@ early_param("threadirqs", setup_forced_irqthreads); ...@@ -41,7 +41,7 @@ early_param("threadirqs", setup_forced_irqthreads);
void synchronize_irq(unsigned int irq) void synchronize_irq(unsigned int irq)
{ {
struct irq_desc *desc = irq_to_desc(irq); struct irq_desc *desc = irq_to_desc(irq);
unsigned int state; bool inprogress;
if (!desc) if (!desc)
return; return;
...@@ -53,16 +53,16 @@ void synchronize_irq(unsigned int irq) ...@@ -53,16 +53,16 @@ void synchronize_irq(unsigned int irq)
* Wait until we're out of the critical section. This might * Wait until we're out of the critical section. This might
* give the wrong answer due to the lack of memory barriers. * give the wrong answer due to the lack of memory barriers.
*/ */
while (desc->istate & IRQS_INPROGRESS) while (irqd_irq_inprogress(&desc->irq_data))
cpu_relax(); cpu_relax();
/* Ok, that indicated we're done: double-check carefully. */ /* Ok, that indicated we're done: double-check carefully. */
raw_spin_lock_irqsave(&desc->lock, flags); raw_spin_lock_irqsave(&desc->lock, flags);
state = desc->istate; inprogress = irqd_irq_inprogress(&desc->irq_data);
raw_spin_unlock_irqrestore(&desc->lock, flags); raw_spin_unlock_irqrestore(&desc->lock, flags);
/* Oops, that failed? */ /* Oops, that failed? */
} while (state & IRQS_INPROGRESS); } while (inprogress);
/* /*
* We made sure that no hardirq handler is running. Now verify * We made sure that no hardirq handler is running. Now verify
...@@ -112,13 +112,13 @@ void irq_set_thread_affinity(struct irq_desc *desc) ...@@ -112,13 +112,13 @@ void irq_set_thread_affinity(struct irq_desc *desc)
} }
#ifdef CONFIG_GENERIC_PENDING_IRQ #ifdef CONFIG_GENERIC_PENDING_IRQ
static inline bool irq_can_move_pcntxt(struct irq_desc *desc) static inline bool irq_can_move_pcntxt(struct irq_data *data)
{ {
return irq_settings_can_move_pcntxt(desc); return irqd_can_move_in_process_context(data);
} }
static inline bool irq_move_pending(struct irq_desc *desc) static inline bool irq_move_pending(struct irq_data *data)
{ {
return irqd_is_setaffinity_pending(&desc->irq_data); return irqd_is_setaffinity_pending(data);
} }
static inline void static inline void
irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
...@@ -131,43 +131,34 @@ irq_get_pending(struct cpumask *mask, struct irq_desc *desc) ...@@ -131,43 +131,34 @@ irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
cpumask_copy(mask, desc->pending_mask); cpumask_copy(mask, desc->pending_mask);
} }
#else #else
static inline bool irq_can_move_pcntxt(struct irq_desc *desc) { return true; } static inline bool irq_can_move_pcntxt(struct irq_data *data) { return true; }
static inline bool irq_move_pending(struct irq_desc *desc) { return false; } static inline bool irq_move_pending(struct irq_desc *data) { return false; }
static inline void static inline void
irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { } irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { }
static inline void static inline void
irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { } irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { }
#endif #endif
/** int __irq_set_affinity_locked(struct irq_data *data, const struct cpumask *mask)
* irq_set_affinity - Set the irq affinity of a given irq
* @irq: Interrupt to set affinity
* @cpumask: cpumask
*
*/
int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
{ {
struct irq_desc *desc = irq_to_desc(irq); struct irq_chip *chip = irq_data_get_irq_chip(data);
struct irq_chip *chip = desc->irq_data.chip; struct irq_desc *desc = irq_data_to_desc(data);
unsigned long flags;
int ret = 0; int ret = 0;
if (!chip->irq_set_affinity) if (!chip || !chip->irq_set_affinity)
return -EINVAL; return -EINVAL;
raw_spin_lock_irqsave(&desc->lock, flags); if (irq_can_move_pcntxt(data)) {
ret = chip->irq_set_affinity(data, mask, false);
if (irq_can_move_pcntxt(desc)) {
ret = chip->irq_set_affinity(&desc->irq_data, mask, false);
switch (ret) { switch (ret) {
case IRQ_SET_MASK_OK: case IRQ_SET_MASK_OK:
cpumask_copy(desc->irq_data.affinity, mask); cpumask_copy(data->affinity, mask);
case IRQ_SET_MASK_OK_NOCOPY: case IRQ_SET_MASK_OK_NOCOPY:
irq_set_thread_affinity(desc); irq_set_thread_affinity(desc);
ret = 0; ret = 0;
} }
} else { } else {
irqd_set_move_pending(&desc->irq_data); irqd_set_move_pending(data);
irq_copy_pending(desc, mask); irq_copy_pending(desc, mask);
} }
...@@ -176,7 +167,28 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *mask) ...@@ -176,7 +167,28 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
schedule_work(&desc->affinity_notify->work); schedule_work(&desc->affinity_notify->work);
} }
irq_compat_set_affinity(desc); irq_compat_set_affinity(desc);
irqd_set(&desc->irq_data, IRQD_AFFINITY_SET); irqd_set(data, IRQD_AFFINITY_SET);
return ret;
}
/**
* irq_set_affinity - Set the irq affinity of a given irq
* @irq: Interrupt to set affinity
* @mask: cpumask
*
*/
int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
{
struct irq_desc *desc = irq_to_desc(irq);
unsigned long flags;
int ret;
if (!desc)
return -EINVAL;
raw_spin_lock_irqsave(&desc->lock, flags);
ret = __irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask);
raw_spin_unlock_irqrestore(&desc->lock, flags); raw_spin_unlock_irqrestore(&desc->lock, flags);
return ret; return ret;
} }
...@@ -206,7 +218,7 @@ static void irq_affinity_notify(struct work_struct *work) ...@@ -206,7 +218,7 @@ static void irq_affinity_notify(struct work_struct *work)
goto out; goto out;
raw_spin_lock_irqsave(&desc->lock, flags); raw_spin_lock_irqsave(&desc->lock, flags);
if (irq_move_pending(desc)) if (irq_move_pending(&desc->irq_data))
irq_get_pending(cpumask, desc); irq_get_pending(cpumask, desc);
else else
cpumask_copy(cpumask, desc->irq_data.affinity); cpumask_copy(cpumask, desc->irq_data.affinity);
...@@ -551,9 +563,9 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq, ...@@ -551,9 +563,9 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
flags &= IRQ_TYPE_SENSE_MASK; flags &= IRQ_TYPE_SENSE_MASK;
if (chip->flags & IRQCHIP_SET_TYPE_MASKED) { if (chip->flags & IRQCHIP_SET_TYPE_MASKED) {
if (!(desc->istate & IRQS_MASKED)) if (!irqd_irq_masked(&desc->irq_data))
mask_irq(desc); mask_irq(desc);
if (!(desc->istate & IRQS_DISABLED)) if (!irqd_irq_disabled(&desc->irq_data))
unmask = 1; unmask = 1;
} }
...@@ -651,7 +663,7 @@ static void irq_finalize_oneshot(struct irq_desc *desc, ...@@ -651,7 +663,7 @@ static void irq_finalize_oneshot(struct irq_desc *desc,
* irq_wake_thread(). See the comment there which explains the * irq_wake_thread(). See the comment there which explains the
* serialization. * serialization.
*/ */
if (unlikely(desc->istate & IRQS_INPROGRESS)) { if (unlikely(irqd_irq_inprogress(&desc->irq_data))) {
raw_spin_unlock_irq(&desc->lock); raw_spin_unlock_irq(&desc->lock);
chip_bus_sync_unlock(desc); chip_bus_sync_unlock(desc);
cpu_relax(); cpu_relax();
...@@ -668,12 +680,10 @@ static void irq_finalize_oneshot(struct irq_desc *desc, ...@@ -668,12 +680,10 @@ static void irq_finalize_oneshot(struct irq_desc *desc,
desc->threads_oneshot &= ~action->thread_mask; desc->threads_oneshot &= ~action->thread_mask;
if (!desc->threads_oneshot && !(desc->istate & IRQS_DISABLED) && if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) &&
(desc->istate & IRQS_MASKED)) { irqd_irq_masked(&desc->irq_data))
irq_compat_clr_masked(desc); unmask_irq(desc);
desc->istate &= ~IRQS_MASKED;
desc->irq_data.chip->irq_unmask(&desc->irq_data);
}
out_unlock: out_unlock:
raw_spin_unlock_irq(&desc->lock); raw_spin_unlock_irq(&desc->lock);
chip_bus_sync_unlock(desc); chip_bus_sync_unlock(desc);
...@@ -767,7 +777,7 @@ static int irq_thread(void *data) ...@@ -767,7 +777,7 @@ static int irq_thread(void *data)
atomic_inc(&desc->threads_active); atomic_inc(&desc->threads_active);
raw_spin_lock_irq(&desc->lock); raw_spin_lock_irq(&desc->lock);
if (unlikely(desc->istate & IRQS_DISABLED)) { if (unlikely(irqd_irq_disabled(&desc->irq_data))) {
/* /*
* CHECKME: We might need a dedicated * CHECKME: We might need a dedicated
* IRQ_THREAD_PENDING flag here, which * IRQ_THREAD_PENDING flag here, which
...@@ -985,8 +995,8 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new) ...@@ -985,8 +995,8 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
} }
desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \ desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
IRQS_INPROGRESS | IRQS_ONESHOT | \ IRQS_ONESHOT | IRQS_WAITING);
IRQS_WAITING); irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
if (new->flags & IRQF_PERCPU) { if (new->flags & IRQF_PERCPU) {
irqd_set(&desc->irq_data, IRQD_PER_CPU); irqd_set(&desc->irq_data, IRQD_PER_CPU);
......
kernel/irq/migration.c
View file @ e5217fb8
...@@ -60,13 +60,12 @@ void move_masked_irq(int irq) ...@@ -60,13 +60,12 @@ void move_masked_irq(int irq)
void irq_move_irq(struct irq_data *idata) void irq_move_irq(struct irq_data *idata)
{ {
struct irq_desc *desc = irq_data_to_desc(idata);
bool masked; bool masked;
if (likely(!irqd_is_setaffinity_pending(idata))) if (likely(!irqd_is_setaffinity_pending(idata)))
return; return;
if (unlikely(desc->istate & IRQS_DISABLED)) if (unlikely(irqd_irq_disabled(idata)))
return; return;
/* /*
...@@ -74,7 +73,7 @@ void irq_move_irq(struct irq_data *idata) ...@@ -74,7 +73,7 @@ void irq_move_irq(struct irq_data *idata)
* threaded interrupt with ONESHOT set, we can end up with an * threaded interrupt with ONESHOT set, we can end up with an
* interrupt storm. * interrupt storm.
*/ */
masked = desc->istate & IRQS_MASKED; masked = irqd_irq_masked(idata);
if (!masked) if (!masked)
idata->chip->irq_mask(idata); idata->chip->irq_mask(idata);
irq_move_masked_irq(idata); irq_move_masked_irq(idata);
......
kernel/irq/spurious.c
View file @ e5217fb8
...@@ -45,12 +45,12 @@ bool irq_wait_for_poll(struct irq_desc *desc) ...@@ -45,12 +45,12 @@ bool irq_wait_for_poll(struct irq_desc *desc)
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
do { do {
raw_spin_unlock(&desc->lock); raw_spin_unlock(&desc->lock);
while (desc->istate & IRQS_INPROGRESS) while (irqd_irq_inprogress(&desc->irq_data))
cpu_relax(); cpu_relax();
raw_spin_lock(&desc->lock); raw_spin_lock(&desc->lock);
} while (desc->istate & IRQS_INPROGRESS); } while (irqd_irq_inprogress(&desc->irq_data));
/* Might have been disabled in meantime */ /* Might have been disabled in meantime */
return !(desc->istate & IRQS_DISABLED) && desc->action; return !irqd_irq_disabled(&desc->irq_data) && desc->action;
#else #else
return false; return false;
#endif #endif
...@@ -75,7 +75,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force) ...@@ -75,7 +75,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
* Do not poll disabled interrupts unless the spurious * Do not poll disabled interrupts unless the spurious
* disabled poller asks explicitely. * disabled poller asks explicitely.
*/ */
if ((desc->istate & IRQS_DISABLED) && !force) if (irqd_irq_disabled(&desc->irq_data) && !force)
goto out; goto out;
/* /*
...@@ -88,7 +88,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force) ...@@ -88,7 +88,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
goto out; goto out;
/* Already running on another processor */ /* Already running on another processor */
if (desc->istate & IRQS_INPROGRESS) { if (irqd_irq_inprogress(&desc->irq_data)) {
/* /*
* Already running: If it is shared get the other * Already running: If it is shared get the other
* CPU to go looking for our mystery interrupt too * CPU to go looking for our mystery interrupt too
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7