lkml.org 
[lkml]   [2010]   [Mar]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Subject[PATCH] irq: Start the transition of irq_chip methods taking a desc
From
Date

With SPARSE_IRQ irq_to_desc becomes an unnecessary lookup operation on
the fast path of dispatching irqs to their handlers. We can avoid
this cost by passing an irq_desc pointer instead of using an integer
irq token to the irq_chip methods.

A single patch to convert all of the architectures is an unreviewable
2000+ line patch. A gradual transition scenario with two sets of
irq_chip methods in irq_chip is an unmanageable mess in kernel/irq.

So instead I define some macros so the generic irq code in kernel/irq/
can compile either way based on a boolean Kconfig variable
CONFIG_CHIP_PARAM_DESC. This allows us to convert one architecture at
a time, reducing the follow on patches to manageable proportions. It
is a little bit ugly but it is much better than the alternatives, and
as soon as we finish the transition we can kill the macros.

I introduce the macros CHIP_ARG, CHIP_VAR, and CHIP_PARAM where
appropriate. I change a few declarations of irq as int to unsigned
int. I normalize the variables names in the functions that call
chip methods to ensure that I have the variables irq and desc present
allowing CHIP_ARG to work properly. Most importantly none of the irq
logic changes with this patch.

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
---
arch/Kconfig | 3 ++
include/linux/irq.h | 58 ++++++++++++++++++++++++++++-------------------
kernel/irq/autoprobe.c | 39 ++++++++++++++++---------------
kernel/irq/chip.c | 44 ++++++++++++++++++------------------
kernel/irq/handle.c | 18 +++++++-------
kernel/irq/internals.h | 4 +-
kernel/irq/manage.c | 20 ++++++++--------
kernel/irq/migration.c | 10 ++++----
kernel/irq/pm.c | 6 ++--
kernel/irq/resend.c | 4 +-
kernel/irq/spurious.c | 4 +-
11 files changed, 112 insertions(+), 98 deletions(-)
diff --git a/arch/Kconfig b/arch/Kconfig
index e5eb133..173e018 100644
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -2,6 +2,9 @@
# General architecture dependent options
#

+config CHIP_PARAM_DESC
+ def_bool n
+
config OPROFILE
tristate "OProfile system profiling"
depends on PROFILING
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 707ab12..dcee995 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -83,6 +83,16 @@ typedef void (*irq_flow_handler_t)(unsigned int irq,
struct proc_dir_entry;
struct msi_desc;

+#ifdef CONFIG_CHIP_PARAM_DESC
+#define CHIP_PARAM struct irq_desc *desc
+#define CHIP_VAR do {} while(0)
+#define CHIP_ARG desc
+#else
+#define CHIP_PARAM unsigned int irq
+#define CHIP_VAR struct irq_desc *desc = irq_to_desc(irq)
+#define CHIP_ARG irq
+#endif
+
/**
* struct irq_chip - hardware interrupt chip descriptor
*
@@ -110,30 +120,30 @@ struct msi_desc;
*/
struct irq_chip {
const char *name;
- unsigned int (*startup)(unsigned int irq);
- void (*shutdown)(unsigned int irq);
- void (*enable)(unsigned int irq);
- void (*disable)(unsigned int irq);
-
- void (*ack)(unsigned int irq);
- void (*mask)(unsigned int irq);
- void (*mask_ack)(unsigned int irq);
- void (*unmask)(unsigned int irq);
- void (*eoi)(unsigned int irq);
-
- void (*end)(unsigned int irq);
- int (*set_affinity)(unsigned int irq,
+ unsigned int (*startup)(CHIP_PARAM);
+ void (*shutdown)(CHIP_PARAM);
+ void (*enable)(CHIP_PARAM);
+ void (*disable)(CHIP_PARAM);
+
+ void (*ack)(CHIP_PARAM);
+ void (*mask)(CHIP_PARAM);
+ void (*mask_ack)(CHIP_PARAM);
+ void (*unmask)(CHIP_PARAM);
+ void (*eoi)(CHIP_PARAM);
+
+ void (*end)(CHIP_PARAM);
+ int (*set_affinity)(CHIP_PARAM,
const struct cpumask *dest);
- int (*retrigger)(unsigned int irq);
- int (*set_type)(unsigned int irq, unsigned int flow_type);
- int (*set_wake)(unsigned int irq, unsigned int on);
+ int (*retrigger)(CHIP_PARAM);
+ int (*set_type)(CHIP_PARAM, unsigned int flow_type);
+ int (*set_wake)(CHIP_PARAM, unsigned int on);

- void (*bus_lock)(unsigned int irq);
- void (*bus_sync_unlock)(unsigned int irq);
+ void (*bus_lock)(CHIP_PARAM);
+ void (*bus_sync_unlock)(CHIP_PARAM);

/* Currently used only by UML, might disappear one day.*/
#ifdef CONFIG_IRQ_RELEASE_METHOD
- void (*release)(unsigned int irq, void *dev_id);
+ void (*release)(CHIP_PARAM, void *dev_id);
#endif
/*
* For compatibility, ->typename is copied into ->name.
@@ -241,20 +251,20 @@ extern void remove_irq(unsigned int irq, struct irqaction *act);

#ifdef CONFIG_GENERIC_PENDING_IRQ

-void move_native_irq(int irq);
-void move_masked_irq(int irq);
+void move_native_irq(unsigned int irq);
+void move_masked_irq(unsigned int irq);

#else /* CONFIG_GENERIC_PENDING_IRQ */

-static inline void move_irq(int irq)
+static inline void move_irq(unsigned int irq)
{
}

-static inline void move_native_irq(int irq)
+static inline void move_native_irq(unsigned int irq)
{
}

-static inline void move_masked_irq(int irq)
+static inline void move_masked_irq(unsigned int irq)
{
}

diff --git a/kernel/irq/autoprobe.c b/kernel/irq/autoprobe.c
index 2295a31..2a8702f 100644
--- a/kernel/irq/autoprobe.c
+++ b/kernel/irq/autoprobe.c
@@ -33,7 +33,7 @@ unsigned long probe_irq_on(void)
struct irq_desc *desc;
unsigned long mask = 0;
unsigned int status;
- int i;
+ unsigned int irq;

/*
* quiesce the kernel, or at least the asynchronous portion
@@ -44,7 +44,7 @@ unsigned long probe_irq_on(void)
* something may have generated an irq long ago and we want to
* flush such a longstanding irq before considering it as spurious.
*/
- for_each_irq_desc_reverse(i, desc) {
+ for_each_irq_desc_reverse(irq, desc) {
raw_spin_lock_irq(&desc->lock);
if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
/*
@@ -58,8 +58,8 @@ unsigned long probe_irq_on(void)
* progress:
*/
if (desc->chip->set_type)
- desc->chip->set_type(i, IRQ_TYPE_PROBE);
- desc->chip->startup(i);
+ desc->chip->set_type(CHIP_ARG, IRQ_TYPE_PROBE);
+ desc->chip->startup(CHIP_ARG);
}
raw_spin_unlock_irq(&desc->lock);
}
@@ -72,11 +72,11 @@ unsigned long probe_irq_on(void)
* (we must startup again here because if a longstanding irq
* happened in the previous stage, it may have masked itself)
*/
- for_each_irq_desc_reverse(i, desc) {
+ for_each_irq_desc_reverse(irq, desc) {
raw_spin_lock_irq(&desc->lock);
if (!desc->action && !(desc->status & IRQ_NOPROBE)) {
desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
- if (desc->chip->startup(i))
+ if (desc->chip->startup(CHIP_ARG))
desc->status |= IRQ_PENDING;
}
raw_spin_unlock_irq(&desc->lock);
@@ -90,7 +90,7 @@ unsigned long probe_irq_on(void)
/*
* Now filter out any obviously spurious interrupts
*/
- for_each_irq_desc(i, desc) {
+ for_each_irq_desc(irq, desc) {
raw_spin_lock_irq(&desc->lock);
status = desc->status;

@@ -98,10 +98,10 @@ unsigned long probe_irq_on(void)
/* It triggered already - consider it spurious. */
if (!(status & IRQ_WAITING)) {
desc->status = status & ~IRQ_AUTODETECT;
- desc->chip->shutdown(i);
+ desc->chip->shutdown(CHIP_ARG);
} else
- if (i < 32)
- mask |= 1 << i;
+ if (irq < 32)
+ mask |= 1 << irq;
}
raw_spin_unlock_irq(&desc->lock);
}
@@ -126,18 +126,18 @@ unsigned int probe_irq_mask(unsigned long val)
{
unsigned int status, mask = 0;
struct irq_desc *desc;
- int i;
+ unsigned int irq;

- for_each_irq_desc(i, desc) {
+ for_each_irq_desc(irq, desc) {
raw_spin_lock_irq(&desc->lock);
status = desc->status;

if (status & IRQ_AUTODETECT) {
- if (i < 16 && !(status & IRQ_WAITING))
- mask |= 1 << i;
+ if (irq < 16 && !(status & IRQ_WAITING))
+ mask |= 1 << irq;

desc->status = status & ~IRQ_AUTODETECT;
- desc->chip->shutdown(i);
+ desc->chip->shutdown(CHIP_ARG);
}
raw_spin_unlock_irq(&desc->lock);
}
@@ -166,22 +166,23 @@ EXPORT_SYMBOL(probe_irq_mask);
*/
int probe_irq_off(unsigned long val)
{
- int i, irq_found = 0, nr_of_irqs = 0;
+ int irq_found = 0, nr_of_irqs = 0;
struct irq_desc *desc;
unsigned int status;
+ unsigned int irq;

- for_each_irq_desc(i, desc) {
+ for_each_irq_desc(irq, desc) {
raw_spin_lock_irq(&desc->lock);
status = desc->status;

if (status & IRQ_AUTODETECT) {
if (!(status & IRQ_WAITING)) {
if (!nr_of_irqs)
- irq_found = i;
+ irq_found = irq;
nr_of_irqs++;
}
desc->status = status & ~IRQ_AUTODETECT;
- desc->chip->shutdown(i);
+ desc->chip->shutdown(CHIP_ARG);
}
raw_spin_unlock_irq(&desc->lock);
}
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 42ec11b..5d205e5 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -287,40 +287,40 @@ EXPORT_SYMBOL_GPL(set_irq_nested_thread);
/*
* default enable function
*/
-static void default_enable(unsigned int irq)
+static void default_enable(CHIP_PARAM)
{
- struct irq_desc *desc = irq_to_desc(irq);
+ CHIP_VAR;

- desc->chip->unmask(irq);
+ desc->chip->unmask(CHIP_ARG);
desc->status &= ~IRQ_MASKED;
}

/*
* default disable function
*/
-static void default_disable(unsigned int irq)
+static void default_disable(CHIP_PARAM)
{
}

/*
* default startup function
*/
-static unsigned int default_startup(unsigned int irq)
+static unsigned int default_startup(CHIP_PARAM)
{
- struct irq_desc *desc = irq_to_desc(irq);
+ CHIP_VAR;

- desc->chip->enable(irq);
+ desc->chip->enable(CHIP_ARG);
return 0;
}

/*
* default shutdown function
*/
-static void default_shutdown(unsigned int irq)
+static void default_shutdown(CHIP_PARAM)
{
- struct irq_desc *desc = irq_to_desc(irq);
+ CHIP_VAR;

- desc->chip->mask(irq);
+ desc->chip->mask(CHIP_ARG);
desc->status |= IRQ_MASKED;
}

@@ -353,11 +353,11 @@ void irq_chip_set_defaults(struct irq_chip *chip)
static inline void mask_ack_irq(struct irq_desc *desc, int irq)
{
if (desc->chip->mask_ack)
- desc->chip->mask_ack(irq);
+ desc->chip->mask_ack(CHIP_ARG);
else {
- desc->chip->mask(irq);
+ desc->chip->mask(CHIP_ARG);
if (desc->chip->ack)
- desc->chip->ack(irq);
+ desc->chip->ack(CHIP_ARG);
}
}

@@ -487,7 +487,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
if (unlikely(desc->status & IRQ_ONESHOT))
desc->status |= IRQ_MASKED;
else if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
- desc->chip->unmask(irq);
+ desc->chip->unmask(CHIP_ARG);
out_unlock:
raw_spin_unlock(&desc->lock);
}
@@ -525,7 +525,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
desc->status |= IRQ_PENDING;
if (desc->chip->mask)
- desc->chip->mask(irq);
+ desc->chip->mask(CHIP_ARG);
goto out;
}

@@ -540,7 +540,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
raw_spin_lock(&desc->lock);
desc->status &= ~IRQ_INPROGRESS;
out:
- desc->chip->eoi(irq);
+ desc->chip->eoi(CHIP_ARG);

raw_spin_unlock(&desc->lock);
}
@@ -583,7 +583,7 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)

/* Start handling the irq */
if (desc->chip->ack)
- desc->chip->ack(irq);
+ desc->chip->ack(CHIP_ARG);

/* Mark the IRQ currently in progress.*/
desc->status |= IRQ_INPROGRESS;
@@ -593,7 +593,7 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
irqreturn_t action_ret;

if (unlikely(!action)) {
- desc->chip->mask(irq);
+ desc->chip->mask(CHIP_ARG);
goto out_unlock;
}

@@ -605,7 +605,7 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
if (unlikely((desc->status &
(IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
(IRQ_PENDING | IRQ_MASKED))) {
- desc->chip->unmask(irq);
+ desc->chip->unmask(CHIP_ARG);
desc->status &= ~IRQ_MASKED;
}

@@ -638,14 +638,14 @@ handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
kstat_incr_irqs_this_cpu(irq, desc);

if (desc->chip->ack)
- desc->chip->ack(irq);
+ desc->chip->ack(CHIP_ARG);

action_ret = handle_IRQ_event(irq, desc->action);
if (!noirqdebug)
note_interrupt(irq, desc, action_ret);

if (desc->chip->eoi)
- desc->chip->eoi(irq);
+ desc->chip->eoi(CHIP_ARG);
}

void
@@ -693,7 +693,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
desc->status &= ~IRQ_DISABLED;
desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
desc->depth = 0;
- desc->chip->startup(irq);
+ desc->chip->startup(CHIP_ARG);
}
raw_spin_unlock_irqrestore(&desc->lock, flags);
chip_bus_sync_unlock(irq, desc);
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 76d5a67..cd42452 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -292,22 +292,22 @@ void clear_kstat_irqs(struct irq_desc *desc)
* What should we do if we get a hw irq event on an illegal vector?
* Each architecture has to answer this themself.
*/
-static void ack_bad(unsigned int irq)
+static void ack_bad(CHIP_PARAM)
{
- struct irq_desc *desc = irq_to_desc(irq);
+ CHIP_VAR;

- print_irq_desc(irq, desc);
- ack_bad_irq(irq);
+ print_irq_desc(desc->irq, desc);
+ ack_bad_irq(desc->irq);
}

/*
* NOP functions
*/
-static void noop(unsigned int irq)
+static void noop(CHIP_PARAM)
{
}

-static unsigned int noop_ret(unsigned int irq)
+static unsigned int noop_ret(CHIP_PARAM)
{
return 0;
}
@@ -467,13 +467,13 @@ unsigned int __do_IRQ(unsigned int irq)
if (!noirqdebug)
note_interrupt(irq, desc, action_ret);
}
- desc->chip->end(irq);
+ desc->chip->end(CHIP_ARG);
return 1;
}

raw_spin_lock(&desc->lock);
if (desc->chip->ack)
- desc->chip->ack(irq);
+ desc->chip->ack(CHIP_ARG);
/*
* REPLAY is when Linux resends an IRQ that was dropped earlier
* WAITING is used by probe to mark irqs that are being tested
@@ -533,7 +533,7 @@ out:
* The ->end() handler has to deal with interrupts which got
* disabled while the handler was running.
*/
- desc->chip->end(irq);
+ desc->chip->end(CHIP_ARG);
raw_spin_unlock(&desc->lock);

return 1;
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index c63f3bc..2a9ec5e 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -44,13 +44,13 @@ extern void irq_set_thread_affinity(struct irq_desc *desc);
static inline void chip_bus_lock(unsigned int irq, struct irq_desc *desc)
{
if (unlikely(desc->chip->bus_lock))
- desc->chip->bus_lock(irq);
+ desc->chip->bus_lock(CHIP_ARG);
}

static inline void chip_bus_sync_unlock(unsigned int irq, struct irq_desc *desc)
{
if (unlikely(desc->chip->bus_sync_unlock))
- desc->chip->bus_sync_unlock(irq);
+ desc->chip->bus_sync_unlock(CHIP_ARG);
}

/*
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index eb6078c..214e0e1 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -118,7 +118,7 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)

#ifdef CONFIG_GENERIC_PENDING_IRQ
if (desc->status & IRQ_MOVE_PCNTXT) {
- if (!desc->chip->set_affinity(irq, cpumask)) {
+ if (!desc->chip->set_affinity(CHIP_ARG, cpumask)) {
cpumask_copy(desc->affinity, cpumask);
irq_set_thread_affinity(desc);
}
@@ -161,7 +161,7 @@ static int setup_affinity(unsigned int irq, struct irq_desc *desc)

cpumask_and(desc->affinity, cpu_online_mask, irq_default_affinity);
set_affinity:
- desc->chip->set_affinity(irq, desc->affinity);
+ desc->chip->set_affinity(CHIP_ARG, desc->affinity);

return 0;
}
@@ -207,7 +207,7 @@ void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)

if (!desc->depth++) {
desc->status |= IRQ_DISABLED;
- desc->chip->disable(irq);
+ desc->chip->disable(CHIP_ARG);
}
}

@@ -321,7 +321,7 @@ static int set_irq_wake_real(unsigned int irq, unsigned int on)
int ret = -ENXIO;

if (desc->chip->set_wake)
- ret = desc->chip->set_wake(irq, on);
+ ret = desc->chip->set_wake(CHIP_ARG, on);

return ret;
}
@@ -425,7 +425,7 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
}

/* caller masked out all except trigger mode flags */
- ret = chip->set_type(irq, flags);
+ ret = chip->set_type(CHIP_ARG, flags);

if (ret)
pr_err("setting trigger mode %d for irq %u failed (%pF)\n",
@@ -487,7 +487,7 @@ static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
raw_spin_lock_irq(&desc->lock);
if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
desc->status &= ~IRQ_MASKED;
- desc->chip->unmask(irq);
+ desc->chip->unmask(CHIP_ARG);
}
raw_spin_unlock_irq(&desc->lock);
chip_bus_sync_unlock(irq, desc);
@@ -738,7 +738,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
if (!(desc->status & IRQ_NOAUTOEN)) {
desc->depth = 0;
desc->status &= ~IRQ_DISABLED;
- desc->chip->startup(irq);
+ desc->chip->startup(CHIP_ARG);
} else
/* Undo nested disables: */
desc->depth = 1;
@@ -872,16 +872,16 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
/* Currently used only by UML, might disappear one day: */
#ifdef CONFIG_IRQ_RELEASE_METHOD
if (desc->chip->release)
- desc->chip->release(irq, dev_id);
+ desc->chip->release(CHIP_ARG, dev_id);
#endif

/* If this was the last handler, shut down the IRQ line: */
if (!desc->action) {
desc->status |= IRQ_DISABLED;
if (desc->chip->shutdown)
- desc->chip->shutdown(irq);
+ desc->chip->shutdown(CHIP_ARG);
else
- desc->chip->disable(irq);
+ desc->chip->disable(CHIP_ARG);
}

raw_spin_unlock_irqrestore(&desc->lock, flags);
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index 2419622..5821159 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -4,7 +4,7 @@

#include "internals.h"

-void move_masked_irq(int irq)
+void move_masked_irq(unsigned int irq)
{
struct irq_desc *desc = irq_to_desc(irq);

@@ -43,7 +43,7 @@ void move_masked_irq(int irq)
*/
if (likely(cpumask_any_and(desc->pending_mask, cpu_online_mask)
< nr_cpu_ids))
- if (!desc->chip->set_affinity(irq, desc->pending_mask)) {
+ if (!desc->chip->set_affinity(CHIP_ARG, desc->pending_mask)) {
cpumask_copy(desc->affinity, desc->pending_mask);
irq_set_thread_affinity(desc);
}
@@ -51,7 +51,7 @@ void move_masked_irq(int irq)
cpumask_clear(desc->pending_mask);
}

-void move_native_irq(int irq)
+void move_native_irq(unsigned int irq)
{
struct irq_desc *desc = irq_to_desc(irq);

@@ -61,8 +61,8 @@ void move_native_irq(int irq)
if (unlikely(desc->status & IRQ_DISABLED))
return;

- desc->chip->mask(irq);
+ desc->chip->mask(CHIP_ARG);
move_masked_irq(irq);
- desc->chip->unmask(irq);
+ desc->chip->unmask(CHIP_ARG);
}

diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
index 0d4005d..94767d1 100644
--- a/kernel/irq/pm.c
+++ b/kernel/irq/pm.c
@@ -23,7 +23,7 @@
void suspend_device_irqs(void)
{
struct irq_desc *desc;
- int irq;
+ unsigned int irq;

for_each_irq_desc(irq, desc) {
unsigned long flags;
@@ -48,7 +48,7 @@ EXPORT_SYMBOL_GPL(suspend_device_irqs);
void resume_device_irqs(void)
{
struct irq_desc *desc;
- int irq;
+ unsigned int irq;

for_each_irq_desc(irq, desc) {
unsigned long flags;
@@ -69,7 +69,7 @@ EXPORT_SYMBOL_GPL(resume_device_irqs);
int check_wakeup_irqs(void)
{
struct irq_desc *desc;
- int irq;
+ unsigned int irq;

for_each_irq_desc(irq, desc)
if ((desc->status & IRQ_WAKEUP) && (desc->status & IRQ_PENDING))
diff --git a/kernel/irq/resend.c b/kernel/irq/resend.c
index 090c376..f28fe97 100644
--- a/kernel/irq/resend.c
+++ b/kernel/irq/resend.c
@@ -60,7 +60,7 @@ void check_irq_resend(struct irq_desc *desc, unsigned int irq)
/*
* Make sure the interrupt is enabled, before resending it:
*/
- desc->chip->enable(irq);
+ desc->chip->enable(CHIP_ARG);

/*
* We do not resend level type interrupts. Level type
@@ -70,7 +70,7 @@ void check_irq_resend(struct irq_desc *desc, unsigned int irq)
if ((status & (IRQ_LEVEL | IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
desc->status = (status & ~IRQ_PENDING) | IRQ_REPLAY;

- if (!desc->chip->retrigger || !desc->chip->retrigger(irq)) {
+ if (!desc->chip->retrigger || !desc->chip->retrigger(CHIP_ARG)) {
#ifdef CONFIG_HARDIRQS_SW_RESEND
/* Set it pending and activate the softirq: */
set_bit(irq, irqs_resend);
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index 89fb90a..6cc2cb9 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -79,7 +79,7 @@ static int try_one_irq(int irq, struct irq_desc *desc)
* IRQ controller clean up too
*/
if (work && desc->chip && desc->chip->end)
- desc->chip->end(irq);
+ desc->chip->end(CHIP_ARG);
raw_spin_unlock(&desc->lock);

return ok;
@@ -254,7 +254,7 @@ void note_interrupt(unsigned int irq, struct irq_desc *desc,
printk(KERN_EMERG "Disabling IRQ #%d\n", irq);
desc->status |= IRQ_DISABLED | IRQ_SPURIOUS_DISABLED;
desc->depth++;
- desc->chip->disable(irq);
+ desc->chip->disable(CHIP_ARG);

mod_timer(&poll_spurious_irq_timer,
jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
--
1.6.5.2.143.g8cc62


\
 
 \ /
  Last update: 2010-03-21 14:15    [W:0.168 / U:0.388 seconds]
©2003-2014 Jasper Spaans. Advertise on this site