hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mattst88/alpha-2.6 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mattst88/alpha-2.6:
  alpha: Enable GENERIC_HARDIRQS_NO_DEPRECATED
  alpha: irq: Convert affinity to use irq_data
  alpha: irq: Remove pointless irq status manipulation
  alpha: titan: Convert irq_chip functions
  alpha: takara: Convert irq_chip functions
  alpha: sable: Convert irq_chip functions
  alpha: rx164: Convert irq_chip functions
  alpha: noritake: Convert irq_chip functions
  alpha: rawhide: Convert irq_chip functions
  alpha: mikasa: Convert irq_chip functions
  alpha: marvel: Convert irq_chip functions
  alpha: eiger: Convert irq_chip functions
  alpha: eb64p: Convert irq_chip functions
  alpha: dp264: Convert irq_chip functions
  alpha: cabriolet: Convert irq_chip functions
  alpha: i8259, alcor, jensen wildfire: Convert irq_chip
  alpha: srm: Convert irq_chip functions
  alpha: Pyxis convert irq_chip functions
  Fix typo in call to irq_to_desc()
This commit is contained in:
Linus Torvalds 2011-03-02 20:01:31 -08:00
parent 06f9a73ff9 10e53f5834
commit 7a16d387dd
22 changed files with 224 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
arch/alpha/Kconfig
View File

@ -11,6 +11,7 @@ config ALPHA
select HAVE_GENERIC_HARDIRQS select HAVE_GENERIC_HARDIRQS
select GENERIC_IRQ_PROBE select GENERIC_IRQ_PROBE
select AUTO_IRQ_AFFINITY if SMP select AUTO_IRQ_AFFINITY if SMP
select GENERIC_HARDIRQS_NO_DEPRECATED
help help
The Alpha is a 64-bit general-purpose processor designed and The Alpha is a 64-bit general-purpose processor designed and
marketed by the Digital Equipment Corporation of blessed memory, marketed by the Digital Equipment Corporation of blessed memory,

13
arch/alpha/kernel/irq.c
View File

@ -44,11 +44,16 @@ static char irq_user_affinity[NR_IRQS];
int irq_select_affinity(unsigned int irq) int irq_select_affinity(unsigned int irq)
{ {
struct irq_desc *desc = irq_to_desc[irq]; struct irq_data *data = irq_get_irq_data(irq);
struct irq_chip *chip;
static int last_cpu; static int last_cpu;
int cpu = last_cpu + 1; int cpu = last_cpu + 1;
if (!desc || !get_irq_desc_chip(desc)->set_affinity || irq_user_affinity[irq]) if (!data)
return 1;
chip = irq_data_get_irq_chip(data);
if (!chip->irq_set_affinity || irq_user_affinity[irq])
return 1; return 1;
while (!cpu_possible(cpu) || while (!cpu_possible(cpu) ||
@ -56,8 +61,8 @@ int irq_select_affinity(unsigned int irq)
cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0); cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0);
last_cpu = cpu; last_cpu = cpu;
cpumask_copy(desc->affinity, cpumask_of(cpu)); cpumask_copy(data->affinity, cpumask_of(cpu));
get_irq_desc_chip(desc)->set_affinity(irq, cpumask_of(cpu)); chip->irq_set_affinity(data, cpumask_of(cpu), false);
return 0; return 0;
} }
#endif /* CONFIG_SMP */ #endif /* CONFIG_SMP */

11
arch/alpha/kernel/irq_alpha.c
View File

@ -228,14 +228,9 @@ struct irqaction timer_irqaction = {
void __init void __init
init_rtc_irq(void) init_rtc_irq(void)
{ {
struct irq_desc *desc = irq_to_desc(RTC_IRQ); set_irq_chip_and_handler_name(RTC_IRQ, &no_irq_chip,
handle_simple_irq, "RTC");
if (desc) { setup_irq(RTC_IRQ, &timer_irqaction);
desc->status |= IRQ_DISABLED;
set_irq_chip_and_handler_name(RTC_IRQ, &no_irq_chip,
handle_simple_irq, "RTC");
setup_irq(RTC_IRQ, &timer_irqaction);
}
} }
/* Dummy irqactions. */ /* Dummy irqactions. */

18
arch/alpha/kernel/irq_i8259.c
View File

@ -33,10 +33,10 @@ i8259_update_irq_hw(unsigned int irq, unsigned long mask)
} }
inline void inline void
i8259a_enable_irq(unsigned int irq) i8259a_enable_irq(struct irq_data *d)
{ {
spin_lock(&i8259_irq_lock); spin_lock(&i8259_irq_lock);
i8259_update_irq_hw(irq, cached_irq_mask &= ~(1 << irq)); i8259_update_irq_hw(d->irq, cached_irq_mask &= ~(1 << d->irq));
spin_unlock(&i8259_irq_lock); spin_unlock(&i8259_irq_lock);
} }
@ -47,16 +47,18 @@ __i8259a_disable_irq(unsigned int irq)
} }
void void
i8259a_disable_irq(unsigned int irq) i8259a_disable_irq(struct irq_data *d)
{ {
spin_lock(&i8259_irq_lock); spin_lock(&i8259_irq_lock);
__i8259a_disable_irq(irq); __i8259a_disable_irq(d->irq);
spin_unlock(&i8259_irq_lock); spin_unlock(&i8259_irq_lock);
} }
void void
i8259a_mask_and_ack_irq(unsigned int irq) i8259a_mask_and_ack_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
spin_lock(&i8259_irq_lock); spin_lock(&i8259_irq_lock);
__i8259a_disable_irq(irq); __i8259a_disable_irq(irq);
@ -71,9 +73,9 @@ i8259a_mask_and_ack_irq(unsigned int irq)
struct irq_chip i8259a_irq_type = { struct irq_chip i8259a_irq_type = {
.name = "XT-PIC", .name = "XT-PIC",
.unmask = i8259a_enable_irq, .irq_unmask = i8259a_enable_irq,
.mask = i8259a_disable_irq, .irq_mask = i8259a_disable_irq,
.mask_ack = i8259a_mask_and_ack_irq, .irq_mask_ack = i8259a_mask_and_ack_irq,
}; };
void __init void __init

8
arch/alpha/kernel/irq_impl.h
View File

@ -31,11 +31,9 @@ extern void init_rtc_irq(void);
extern void common_init_isa_dma(void); extern void common_init_isa_dma(void);
extern void i8259a_enable_irq(unsigned int); extern void i8259a_enable_irq(struct irq_data *d);
extern void i8259a_disable_irq(unsigned int); extern void i8259a_disable_irq(struct irq_data *d);
extern void i8259a_mask_and_ack_irq(unsigned int); extern void i8259a_mask_and_ack_irq(struct irq_data *d);
extern unsigned int i8259a_startup_irq(unsigned int);
extern void i8259a_end_irq(unsigned int);
extern struct irq_chip i8259a_irq_type; extern struct irq_chip i8259a_irq_type;
extern void init_i8259a_irqs(void); extern void init_i8259a_irqs(void);

20
arch/alpha/kernel/irq_pyxis.c
View File

@ -29,21 +29,21 @@ pyxis_update_irq_hw(unsigned long mask)
} }
static inline void static inline void
pyxis_enable_irq(unsigned int irq) pyxis_enable_irq(struct irq_data *d)
{ {
pyxis_update_irq_hw(cached_irq_mask |= 1UL << (irq - 16)); pyxis_update_irq_hw(cached_irq_mask |= 1UL << (d->irq - 16));
} }
static void static void
pyxis_disable_irq(unsigned int irq) pyxis_disable_irq(struct irq_data *d)
{ {
pyxis_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16))); pyxis_update_irq_hw(cached_irq_mask &= ~(1UL << (d->irq - 16)));
} }
static void static void
pyxis_mask_and_ack_irq(unsigned int irq) pyxis_mask_and_ack_irq(struct irq_data *d)
{ {
unsigned long bit = 1UL << (irq - 16); unsigned long bit = 1UL << (d->irq - 16);
unsigned long mask = cached_irq_mask &= ~bit; unsigned long mask = cached_irq_mask &= ~bit;
/* Disable the interrupt. */ /* Disable the interrupt. */
@ -58,9 +58,9 @@ pyxis_mask_and_ack_irq(unsigned int irq)
static struct irq_chip pyxis_irq_type = { static struct irq_chip pyxis_irq_type = {
.name = "PYXIS", .name = "PYXIS",
.mask_ack = pyxis_mask_and_ack_irq, .irq_mask_ack = pyxis_mask_and_ack_irq,
.mask = pyxis_disable_irq, .irq_mask = pyxis_disable_irq,
.unmask = pyxis_enable_irq, .irq_unmask = pyxis_enable_irq,
}; };
void void
@ -103,7 +103,7 @@ init_pyxis_irqs(unsigned long ignore_mask)
if ((ignore_mask >> i) & 1) if ((ignore_mask >> i) & 1)
continue; continue;
set_irq_chip_and_handler(i, &pyxis_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &pyxis_irq_type, handle_level_irq);
irq_to_desc(i)->status |= IRQ_LEVEL; irq_set_status_flags(i, IRQ_LEVEL);
} }
setup_irq(16+7, &isa_cascade_irqaction); setup_irq(16+7, &isa_cascade_irqaction);

16
arch/alpha/kernel/irq_srm.c
View File

@ -18,27 +18,27 @@
DEFINE_SPINLOCK(srm_irq_lock); DEFINE_SPINLOCK(srm_irq_lock);
static inline void static inline void
srm_enable_irq(unsigned int irq) srm_enable_irq(struct irq_data *d)
{ {
spin_lock(&srm_irq_lock); spin_lock(&srm_irq_lock);
cserve_ena(irq - 16); cserve_ena(d->irq - 16);
spin_unlock(&srm_irq_lock); spin_unlock(&srm_irq_lock);
} }
static void static void
srm_disable_irq(unsigned int irq) srm_disable_irq(struct irq_data *d)
{ {
spin_lock(&srm_irq_lock); spin_lock(&srm_irq_lock);
cserve_dis(irq - 16); cserve_dis(d->irq - 16);
spin_unlock(&srm_irq_lock); spin_unlock(&srm_irq_lock);
} }
/* Handle interrupts from the SRM, assuming no additional weirdness. */ /* Handle interrupts from the SRM, assuming no additional weirdness. */
static struct irq_chip srm_irq_type = { static struct irq_chip srm_irq_type = {
.name = "SRM", .name = "SRM",
.unmask = srm_enable_irq, .irq_unmask = srm_enable_irq,
.mask = srm_disable_irq, .irq_mask = srm_disable_irq,
.mask_ack = srm_disable_irq, .irq_mask_ack = srm_disable_irq,
}; };
void __init void __init
@ -52,7 +52,7 @@ init_srm_irqs(long max, unsigned long ignore_mask)
if (i < 64 && ((ignore_mask >> i) & 1)) if (i < 64 && ((ignore_mask >> i) & 1))
continue; continue;
set_irq_chip_and_handler(i, &srm_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &srm_irq_type, handle_level_irq);
irq_to_desc(i)->status |= IRQ_LEVEL; irq_set_status_flags(i, IRQ_LEVEL);
} }
} }

28
arch/alpha/kernel/sys_alcor.c
View File

@ -44,31 +44,31 @@ alcor_update_irq_hw(unsigned long mask)
} }
static inline void static inline void
alcor_enable_irq(unsigned int irq) alcor_enable_irq(struct irq_data *d)
{ {
alcor_update_irq_hw(cached_irq_mask |= 1UL << (irq - 16)); alcor_update_irq_hw(cached_irq_mask |= 1UL << (d->irq - 16));
} }
static void static void
alcor_disable_irq(unsigned int irq) alcor_disable_irq(struct irq_data *d)
{ {
alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16))); alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (d->irq - 16)));
} }
static void static void
alcor_mask_and_ack_irq(unsigned int irq) alcor_mask_and_ack_irq(struct irq_data *d)
{ {
alcor_disable_irq(irq); alcor_disable_irq(d);
/* On ALCOR/XLT, need to dismiss interrupt via GRU. */ /* On ALCOR/XLT, need to dismiss interrupt via GRU. */
*(vuip)GRU_INT_CLEAR = 1 << (irq - 16); mb(); *(vuip)GRU_INT_CLEAR = 1 << (d->irq - 16); mb();
*(vuip)GRU_INT_CLEAR = 0; mb(); *(vuip)GRU_INT_CLEAR = 0; mb();
} }
static void static void
alcor_isa_mask_and_ack_irq(unsigned int irq) alcor_isa_mask_and_ack_irq(struct irq_data *d)
{ {
i8259a_mask_and_ack_irq(irq); i8259a_mask_and_ack_irq(d);
/* On ALCOR/XLT, need to dismiss interrupt via GRU. */ /* On ALCOR/XLT, need to dismiss interrupt via GRU. */
*(vuip)GRU_INT_CLEAR = 0x80000000; mb(); *(vuip)GRU_INT_CLEAR = 0x80000000; mb();
@ -77,9 +77,9 @@ alcor_isa_mask_and_ack_irq(unsigned int irq)
static struct irq_chip alcor_irq_type = { static struct irq_chip alcor_irq_type = {
.name = "ALCOR", .name = "ALCOR",
.unmask = alcor_enable_irq, .irq_unmask = alcor_enable_irq,
.mask = alcor_disable_irq, .irq_mask = alcor_disable_irq,
.mask_ack = alcor_mask_and_ack_irq, .irq_mask_ack = alcor_mask_and_ack_irq,
}; };
static void static void
@ -126,9 +126,9 @@ alcor_init_irq(void)
if (i >= 16+20 && i <= 16+30) if (i >= 16+20 && i <= 16+30)
continue; continue;
set_irq_chip_and_handler(i, &alcor_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &alcor_irq_type, handle_level_irq);
irq_to_desc(i)->status |= IRQ_LEVEL; irq_set_status_flags(i, IRQ_LEVEL);
} }
i8259a_irq_type.ack = alcor_isa_mask_and_ack_irq; i8259a_irq_type.irq_ack = alcor_isa_mask_and_ack_irq;
init_i8259a_irqs(); init_i8259a_irqs();
common_init_isa_dma(); common_init_isa_dma();

16
arch/alpha/kernel/sys_cabriolet.c
View File

@ -46,22 +46,22 @@ cabriolet_update_irq_hw(unsigned int irq, unsigned long mask)
} }
static inline void static inline void
cabriolet_enable_irq(unsigned int irq) cabriolet_enable_irq(struct irq_data *d)
{ {
cabriolet_update_irq_hw(irq, cached_irq_mask &= ~(1UL << irq)); cabriolet_update_irq_hw(d->irq, cached_irq_mask &= ~(1UL << d->irq));
} }
static void static void
cabriolet_disable_irq(unsigned int irq) cabriolet_disable_irq(struct irq_data *d)
{ {
cabriolet_update_irq_hw(irq, cached_irq_mask |= 1UL << irq); cabriolet_update_irq_hw(d->irq, cached_irq_mask |= 1UL << d->irq);
} }
static struct irq_chip cabriolet_irq_type = { static struct irq_chip cabriolet_irq_type = {
.name = "CABRIOLET", .name = "CABRIOLET",
.unmask = cabriolet_enable_irq, .irq_unmask = cabriolet_enable_irq,
.mask = cabriolet_disable_irq, .irq_mask = cabriolet_disable_irq,
.mask_ack = cabriolet_disable_irq, .irq_mask_ack = cabriolet_disable_irq,
}; };
static void static void
@ -107,7 +107,7 @@ common_init_irq(void (*srm_dev_int)(unsigned long v))
for (i = 16; i < 35; ++i) { for (i = 16; i < 35; ++i) {
set_irq_chip_and_handler(i, &cabriolet_irq_type, set_irq_chip_and_handler(i, &cabriolet_irq_type,
handle_level_irq); handle_level_irq);
irq_to_desc(i)->status |= IRQ_LEVEL; irq_set_status_flags(i, IRQ_LEVEL);
} }
} }

52
arch/alpha/kernel/sys_dp264.c
View File

@ -98,37 +98,37 @@ tsunami_update_irq_hw(unsigned long mask)
} }
static void static void
dp264_enable_irq(unsigned int irq) dp264_enable_irq(struct irq_data *d)
{ {
spin_lock(&dp264_irq_lock); spin_lock(&dp264_irq_lock);
cached_irq_mask |= 1UL << irq; cached_irq_mask |= 1UL << d->irq;
tsunami_update_irq_hw(cached_irq_mask); tsunami_update_irq_hw(cached_irq_mask);
spin_unlock(&dp264_irq_lock); spin_unlock(&dp264_irq_lock);
} }
static void static void
dp264_disable_irq(unsigned int irq) dp264_disable_irq(struct irq_data *d)
{ {
spin_lock(&dp264_irq_lock); spin_lock(&dp264_irq_lock);
cached_irq_mask &= ~(1UL << irq); cached_irq_mask &= ~(1UL << d->irq);
tsunami_update_irq_hw(cached_irq_mask); tsunami_update_irq_hw(cached_irq_mask);
spin_unlock(&dp264_irq_lock); spin_unlock(&dp264_irq_lock);
} }
static void static void
clipper_enable_irq(unsigned int irq) clipper_enable_irq(struct irq_data *d)
{ {
spin_lock(&dp264_irq_lock); spin_lock(&dp264_irq_lock);
cached_irq_mask |= 1UL << (irq - 16); cached_irq_mask |= 1UL << (d->irq - 16);
tsunami_update_irq_hw(cached_irq_mask); tsunami_update_irq_hw(cached_irq_mask);
spin_unlock(&dp264_irq_lock); spin_unlock(&dp264_irq_lock);
} }
static void static void
clipper_disable_irq(unsigned int irq) clipper_disable_irq(struct irq_data *d)
{ {
spin_lock(&dp264_irq_lock); spin_lock(&dp264_irq_lock);
cached_irq_mask &= ~(1UL << (irq - 16)); cached_irq_mask &= ~(1UL << (d->irq - 16));
tsunami_update_irq_hw(cached_irq_mask); tsunami_update_irq_hw(cached_irq_mask);
spin_unlock(&dp264_irq_lock); spin_unlock(&dp264_irq_lock);
} }
@ -149,10 +149,11 @@ cpu_set_irq_affinity(unsigned int irq, cpumask_t affinity)
} }
static int static int
dp264_set_affinity(unsigned int irq, const struct cpumask *affinity) dp264_set_affinity(struct irq_data *d, const struct cpumask *affinity,
{ bool force)
{
spin_lock(&dp264_irq_lock); spin_lock(&dp264_irq_lock);
cpu_set_irq_affinity(irq, *affinity); cpu_set_irq_affinity(d->irq, *affinity);
tsunami_update_irq_hw(cached_irq_mask); tsunami_update_irq_hw(cached_irq_mask);
spin_unlock(&dp264_irq_lock); spin_unlock(&dp264_irq_lock);
@ -160,10 +161,11 @@ dp264_set_affinity(unsigned int irq, const struct cpumask *affinity)
} }
static int static int
clipper_set_affinity(unsigned int irq, const struct cpumask *affinity) clipper_set_affinity(struct irq_data *d, const struct cpumask *affinity,
{ bool force)
{
spin_lock(&dp264_irq_lock); spin_lock(&dp264_irq_lock);
cpu_set_irq_affinity(irq - 16, *affinity); cpu_set_irq_affinity(d->irq - 16, *affinity);
tsunami_update_irq_hw(cached_irq_mask); tsunami_update_irq_hw(cached_irq_mask);
spin_unlock(&dp264_irq_lock); spin_unlock(&dp264_irq_lock);
@ -171,19 +173,19 @@ clipper_set_affinity(unsigned int irq, const struct cpumask *affinity)
} }
static struct irq_chip dp264_irq_type = { static struct irq_chip dp264_irq_type = {
.name = "DP264", .name = "DP264",
.unmask = dp264_enable_irq, .irq_unmask = dp264_enable_irq,
.mask = dp264_disable_irq, .irq_mask = dp264_disable_irq,
.mask_ack = dp264_disable_irq, .irq_mask_ack = dp264_disable_irq,
.set_affinity = dp264_set_affinity, .irq_set_affinity = dp264_set_affinity,
}; };
static struct irq_chip clipper_irq_type = { static struct irq_chip clipper_irq_type = {
.name = "CLIPPER", .name = "CLIPPER",
.unmask = clipper_enable_irq, .irq_unmask = clipper_enable_irq,
.mask = clipper_disable_irq, .irq_mask = clipper_disable_irq,
.mask_ack = clipper_disable_irq, .irq_mask_ack = clipper_disable_irq,
.set_affinity = clipper_set_affinity, .irq_set_affinity = clipper_set_affinity,
}; };
static void static void
@ -268,8 +270,8 @@ init_tsunami_irqs(struct irq_chip * ops, int imin, int imax)
{ {
long i; long i;
for (i = imin; i <= imax; ++i) { for (i = imin; i <= imax; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, ops, handle_level_irq); set_irq_chip_and_handler(i, ops, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
} }

18
arch/alpha/kernel/sys_eb64p.c
View File

@ -44,22 +44,22 @@ eb64p_update_irq_hw(unsigned int irq, unsigned long mask)
} }
static inline void static inline void
eb64p_enable_irq(unsigned int irq) eb64p_enable_irq(struct irq_data *d)
{ {
eb64p_update_irq_hw(irq, cached_irq_mask &= ~(1 << irq)); eb64p_update_irq_hw(d->irq, cached_irq_mask &= ~(1 << d->irq));
} }
static void static void
eb64p_disable_irq(unsigned int irq) eb64p_disable_irq(struct irq_data *d)
{ {
eb64p_update_irq_hw(irq, cached_irq_mask |= 1 << irq); eb64p_update_irq_hw(d->irq, cached_irq_mask |= 1 << d->irq);
} }
static struct irq_chip eb64p_irq_type = { static struct irq_chip eb64p_irq_type = {
.name = "EB64P", .name = "EB64P",
.unmask = eb64p_enable_irq, .irq_unmask = eb64p_enable_irq,
.mask = eb64p_disable_irq, .irq_mask = eb64p_disable_irq,
.mask_ack = eb64p_disable_irq, .irq_mask_ack = eb64p_disable_irq,
}; };
static void static void
@ -118,9 +118,9 @@ eb64p_init_irq(void)
init_i8259a_irqs(); init_i8259a_irqs();
for (i = 16; i < 32; ++i) { for (i = 16; i < 32; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &eb64p_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &eb64p_irq_type, handle_level_irq);
} irq_set_status_flags(i, IRQ_LEVEL);
}
common_init_isa_dma(); common_init_isa_dma();
setup_irq(16+5, &isa_cascade_irqaction); setup_irq(16+5, &isa_cascade_irqaction);

14
arch/alpha/kernel/sys_eiger.c
View File

@ -51,16 +51,18 @@ eiger_update_irq_hw(unsigned long irq, unsigned long mask)
} }
static inline void static inline void
eiger_enable_irq(unsigned int irq) eiger_enable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
unsigned long mask; unsigned long mask;
mask = (cached_irq_mask[irq >= 64] &= ~(1UL << (irq & 63))); mask = (cached_irq_mask[irq >= 64] &= ~(1UL << (irq & 63)));
eiger_update_irq_hw(irq, mask); eiger_update_irq_hw(irq, mask);
} }
static void static void
eiger_disable_irq(unsigned int irq) eiger_disable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
unsigned long mask; unsigned long mask;
mask = (cached_irq_mask[irq >= 64] |= 1UL << (irq & 63)); mask = (cached_irq_mask[irq >= 64] |= 1UL << (irq & 63));
eiger_update_irq_hw(irq, mask); eiger_update_irq_hw(irq, mask);
@ -68,9 +70,9 @@ eiger_disable_irq(unsigned int irq)
static struct irq_chip eiger_irq_type = { static struct irq_chip eiger_irq_type = {
.name = "EIGER", .name = "EIGER",
.unmask = eiger_enable_irq, .irq_unmask = eiger_enable_irq,
.mask = eiger_disable_irq, .irq_mask = eiger_disable_irq,
.mask_ack = eiger_disable_irq, .irq_mask_ack = eiger_disable_irq,
}; };
static void static void
@ -136,8 +138,8 @@ eiger_init_irq(void)
init_i8259a_irqs(); init_i8259a_irqs();
for (i = 16; i < 128; ++i) { for (i = 16; i < 128; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &eiger_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &eiger_irq_type, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
} }

24
arch/alpha/kernel/sys_jensen.c
View File

@ -63,34 +63,34 @@
*/ */
static void static void
jensen_local_enable(unsigned int irq) jensen_local_enable(struct irq_data *d)
{ {
/* the parport is really hw IRQ 1, silly Jensen. */ /* the parport is really hw IRQ 1, silly Jensen. */
if (irq == 7) if (d->irq == 7)
i8259a_enable_irq(1); i8259a_enable_irq(d);
} }
static void static void
jensen_local_disable(unsigned int irq) jensen_local_disable(struct irq_data *d)
{ {
/* the parport is really hw IRQ 1, silly Jensen. */ /* the parport is really hw IRQ 1, silly Jensen. */
if (irq == 7) if (d->irq == 7)
i8259a_disable_irq(1); i8259a_disable_irq(d);
} }
static void static void
jensen_local_mask_ack(unsigned int irq) jensen_local_mask_ack(struct irq_data *d)
{ {
/* the parport is really hw IRQ 1, silly Jensen. */ /* the parport is really hw IRQ 1, silly Jensen. */
if (irq == 7) if (d->irq == 7)
i8259a_mask_and_ack_irq(1); i8259a_mask_and_ack_irq(d);
} }
static struct irq_chip jensen_local_irq_type = { static struct irq_chip jensen_local_irq_type = {
.name = "LOCAL", .name = "LOCAL",
.unmask = jensen_local_enable, .irq_unmask = jensen_local_enable,
.mask = jensen_local_disable, .irq_mask = jensen_local_disable,
.mask_ack = jensen_local_mask_ack, .irq_mask_ack = jensen_local_mask_ack,
}; };
static void static void

42
arch/alpha/kernel/sys_marvel.c
View File

@ -104,9 +104,10 @@ io7_get_irq_ctl(unsigned int irq, struct io7 **pio7)
} }
static void static void
io7_enable_irq(unsigned int irq) io7_enable_irq(struct irq_data *d)
{ {
volatile unsigned long *ctl; volatile unsigned long *ctl;
unsigned int irq = d->irq;
struct io7 *io7; struct io7 *io7;
ctl = io7_get_irq_ctl(irq, &io7); ctl = io7_get_irq_ctl(irq, &io7);
@ -115,7 +116,7 @@ io7_enable_irq(unsigned int irq)
__func__, irq); __func__, irq);
return; return;
} }
spin_lock(&io7->irq_lock); spin_lock(&io7->irq_lock);
*ctl |= 1UL << 24; *ctl |= 1UL << 24;
mb(); mb();
@ -124,9 +125,10 @@ io7_enable_irq(unsigned int irq)
} }
static void static void
io7_disable_irq(unsigned int irq) io7_disable_irq(struct irq_data *d)
{ {
volatile unsigned long *ctl; volatile unsigned long *ctl;
unsigned int irq = d->irq;
struct io7 *io7; struct io7 *io7;
ctl = io7_get_irq_ctl(irq, &io7); ctl = io7_get_irq_ctl(irq, &io7);
@ -135,7 +137,7 @@ io7_disable_irq(unsigned int irq)
__func__, irq); __func__, irq);
return; return;
} }
spin_lock(&io7->irq_lock); spin_lock(&io7->irq_lock);
*ctl &= ~(1UL << 24); *ctl &= ~(1UL << 24);
mb(); mb();
@ -144,35 +146,29 @@ io7_disable_irq(unsigned int irq)
} }
static void static void
marvel_irq_noop(unsigned int irq) marvel_irq_noop(struct irq_data *d)
{ {
return; return;
}
static unsigned int
marvel_irq_noop_return(unsigned int irq)
{
return 0;
} }
static struct irq_chip marvel_legacy_irq_type = { static struct irq_chip marvel_legacy_irq_type = {
.name = "LEGACY", .name = "LEGACY",
.mask = marvel_irq_noop, .irq_mask = marvel_irq_noop,
.unmask = marvel_irq_noop, .irq_unmask = marvel_irq_noop,
}; };
static struct irq_chip io7_lsi_irq_type = { static struct irq_chip io7_lsi_irq_type = {
.name = "LSI", .name = "LSI",
.unmask = io7_enable_irq, .irq_unmask = io7_enable_irq,
.mask = io7_disable_irq, .irq_mask = io7_disable_irq,
.mask_ack = io7_disable_irq, .irq_mask_ack = io7_disable_irq,
}; };
static struct irq_chip io7_msi_irq_type = { static struct irq_chip io7_msi_irq_type = {
.name = "MSI", .name = "MSI",
.unmask = io7_enable_irq, .irq_unmask = io7_enable_irq,
.mask = io7_disable_irq, .irq_mask = io7_disable_irq,
.ack = marvel_irq_noop, .irq_ack = marvel_irq_noop,
}; };
static void static void
@ -280,8 +276,8 @@ init_io7_irqs(struct io7 *io7,
/* Set up the lsi irqs. */ /* Set up the lsi irqs. */
for (i = 0; i < 128; ++i) { for (i = 0; i < 128; ++i) {
irq_to_desc(base + i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(base + i, lsi_ops, handle_level_irq); set_irq_chip_and_handler(base + i, lsi_ops, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
/* Disable the implemented irqs in hardware. */ /* Disable the implemented irqs in hardware. */
@ -294,8 +290,8 @@ init_io7_irqs(struct io7 *io7,
/* Set up the msi irqs. */ /* Set up the msi irqs. */
for (i = 128; i < (128 + 512); ++i) { for (i = 128; i < (128 + 512); ++i) {
irq_to_desc(base + i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(base + i, msi_ops, handle_level_irq); set_irq_chip_and_handler(base + i, msi_ops, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
for (i = 0; i < 16; ++i) for (i = 0; i < 16; ++i)

16
arch/alpha/kernel/sys_mikasa.c
View File

@ -43,22 +43,22 @@ mikasa_update_irq_hw(int mask)
} }
static inline void static inline void
mikasa_enable_irq(unsigned int irq) mikasa_enable_irq(struct irq_data *d)
{ {
mikasa_update_irq_hw(cached_irq_mask |= 1 << (irq - 16)); mikasa_update_irq_hw(cached_irq_mask |= 1 << (d->irq - 16));
} }
static void static void
mikasa_disable_irq(unsigned int irq) mikasa_disable_irq(struct irq_data *d)
{ {
mikasa_update_irq_hw(cached_irq_mask &= ~(1 << (irq - 16))); mikasa_update_irq_hw(cached_irq_mask &= ~(1 << (d->irq - 16)));
} }
static struct irq_chip mikasa_irq_type = { static struct irq_chip mikasa_irq_type = {
.name = "MIKASA", .name = "MIKASA",
.unmask = mikasa_enable_irq, .irq_unmask = mikasa_enable_irq,
.mask = mikasa_disable_irq, .irq_mask = mikasa_disable_irq,
.mask_ack = mikasa_disable_irq, .irq_mask_ack = mikasa_disable_irq,
}; };
static void static void
@ -98,8 +98,8 @@ mikasa_init_irq(void)
mikasa_update_irq_hw(0); mikasa_update_irq_hw(0);
for (i = 16; i < 32; ++i) { for (i = 16; i < 32; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &mikasa_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &mikasa_irq_type, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
init_i8259a_irqs(); init_i8259a_irqs();

16
arch/alpha/kernel/sys_noritake.c
View File

@ -48,22 +48,22 @@ noritake_update_irq_hw(int irq, int mask)
} }
static void static void
noritake_enable_irq(unsigned int irq) noritake_enable_irq(struct irq_data *d)
{ {
noritake_update_irq_hw(irq, cached_irq_mask |= 1 << (irq - 16)); noritake_update_irq_hw(d->irq, cached_irq_mask |= 1 << (d->irq - 16));
} }
static void static void
noritake_disable_irq(unsigned int irq) noritake_disable_irq(struct irq_data *d)
{ {
noritake_update_irq_hw(irq, cached_irq_mask &= ~(1 << (irq - 16))); noritake_update_irq_hw(d->irq, cached_irq_mask &= ~(1 << (d->irq - 16)));
} }
static struct irq_chip noritake_irq_type = { static struct irq_chip noritake_irq_type = {
.name = "NORITAKE", .name = "NORITAKE",
.unmask = noritake_enable_irq, .irq_unmask = noritake_enable_irq,
.mask = noritake_disable_irq, .irq_mask = noritake_disable_irq,
.mask_ack = noritake_disable_irq, .irq_mask_ack = noritake_disable_irq,
}; };
static void static void
@ -127,8 +127,8 @@ noritake_init_irq(void)
outw(0, 0x54c); outw(0, 0x54c);
for (i = 16; i < 48; ++i) { for (i = 16; i < 48; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &noritake_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &noritake_irq_type, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
init_i8259a_irqs(); init_i8259a_irqs();

17
arch/alpha/kernel/sys_rawhide.c
View File

@ -56,9 +56,10 @@ rawhide_update_irq_hw(int hose, int mask)
(((h) < MCPCIA_MAX_HOSES) && (cached_irq_masks[(h)] != 0)) (((h) < MCPCIA_MAX_HOSES) && (cached_irq_masks[(h)] != 0))
static inline void static inline void
rawhide_enable_irq(unsigned int irq) rawhide_enable_irq(struct irq_data *d)
{ {
unsigned int mask, hose; unsigned int mask, hose;
unsigned int irq = d->irq;
irq -= 16; irq -= 16;
hose = irq / 24; hose = irq / 24;
@ -76,9 +77,10 @@ rawhide_enable_irq(unsigned int irq)
} }
static void static void
rawhide_disable_irq(unsigned int irq) rawhide_disable_irq(struct irq_data *d)
{ {
unsigned int mask, hose; unsigned int mask, hose;
unsigned int irq = d->irq;
irq -= 16; irq -= 16;
hose = irq / 24; hose = irq / 24;
@ -96,9 +98,10 @@ rawhide_disable_irq(unsigned int irq)
} }
static void static void
rawhide_mask_and_ack_irq(unsigned int irq) rawhide_mask_and_ack_irq(struct irq_data *d)
{ {
unsigned int mask, mask1, hose; unsigned int mask, mask1, hose;
unsigned int irq = d->irq;
irq -= 16; irq -= 16;
hose = irq / 24; hose = irq / 24;
@ -123,9 +126,9 @@ rawhide_mask_and_ack_irq(unsigned int irq)
static struct irq_chip rawhide_irq_type = { static struct irq_chip rawhide_irq_type = {
.name = "RAWHIDE", .name = "RAWHIDE",
.unmask = rawhide_enable_irq, .irq_unmask = rawhide_enable_irq,
.mask = rawhide_disable_irq, .irq_mask = rawhide_disable_irq,
.mask_ack = rawhide_mask_and_ack_irq, .irq_mask_ack = rawhide_mask_and_ack_irq,
}; };
static void static void
@ -177,8 +180,8 @@ rawhide_init_irq(void)
} }
for (i = 16; i < 128; ++i) { for (i = 16; i < 128; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &rawhide_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &rawhide_irq_type, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
init_i8259a_irqs(); init_i8259a_irqs();

16
arch/alpha/kernel/sys_rx164.c
View File

@ -47,22 +47,22 @@ rx164_update_irq_hw(unsigned long mask)
} }
static inline void static inline void
rx164_enable_irq(unsigned int irq) rx164_enable_irq(struct irq_data *d)
{ {
rx164_update_irq_hw(cached_irq_mask |= 1UL << (irq - 16)); rx164_update_irq_hw(cached_irq_mask |= 1UL << (d->irq - 16));
} }
static void static void
rx164_disable_irq(unsigned int irq) rx164_disable_irq(struct irq_data *d)
{ {
rx164_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16))); rx164_update_irq_hw(cached_irq_mask &= ~(1UL << (d->irq - 16)));
} }
static struct irq_chip rx164_irq_type = { static struct irq_chip rx164_irq_type = {
.name = "RX164", .name = "RX164",
.unmask = rx164_enable_irq, .irq_unmask = rx164_enable_irq,
.mask = rx164_disable_irq, .irq_mask = rx164_disable_irq,
.mask_ack = rx164_disable_irq, .irq_mask_ack = rx164_disable_irq,
}; };
static void static void
@ -99,8 +99,8 @@ rx164_init_irq(void)
rx164_update_irq_hw(0); rx164_update_irq_hw(0);
for (i = 16; i < 40; ++i) { for (i = 16; i < 40; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &rx164_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &rx164_irq_type, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
init_i8259a_irqs(); init_i8259a_irqs();

20
arch/alpha/kernel/sys_sable.c
View File

@ -443,11 +443,11 @@ lynx_swizzle(struct pci_dev *dev, u8 *pinp)
/* GENERIC irq routines */ /* GENERIC irq routines */
static inline void static inline void
sable_lynx_enable_irq(unsigned int irq) sable_lynx_enable_irq(struct irq_data *d)
{ {
unsigned long bit, mask; unsigned long bit, mask;
bit = sable_lynx_irq_swizzle->irq_to_mask[irq]; bit = sable_lynx_irq_swizzle->irq_to_mask[d->irq];
spin_lock(&sable_lynx_irq_lock); spin_lock(&sable_lynx_irq_lock);
mask = sable_lynx_irq_swizzle->shadow_mask &= ~(1UL << bit); mask = sable_lynx_irq_swizzle->shadow_mask &= ~(1UL << bit);
sable_lynx_irq_swizzle->update_irq_hw(bit, mask); sable_lynx_irq_swizzle->update_irq_hw(bit, mask);
@ -459,11 +459,11 @@ sable_lynx_enable_irq(unsigned int irq)
} }
static void static void
sable_lynx_disable_irq(unsigned int irq) sable_lynx_disable_irq(struct irq_data *d)
{ {
unsigned long bit, mask; unsigned long bit, mask;
bit = sable_lynx_irq_swizzle->irq_to_mask[irq]; bit = sable_lynx_irq_swizzle->irq_to_mask[d->irq];
spin_lock(&sable_lynx_irq_lock); spin_lock(&sable_lynx_irq_lock);
mask = sable_lynx_irq_swizzle->shadow_mask |= 1UL << bit; mask = sable_lynx_irq_swizzle->shadow_mask |= 1UL << bit;
sable_lynx_irq_swizzle->update_irq_hw(bit, mask); sable_lynx_irq_swizzle->update_irq_hw(bit, mask);
@ -475,11 +475,11 @@ sable_lynx_disable_irq(unsigned int irq)
} }
static void static void
sable_lynx_mask_and_ack_irq(unsigned int irq) sable_lynx_mask_and_ack_irq(struct irq_data *d)
{ {
unsigned long bit, mask; unsigned long bit, mask;
bit = sable_lynx_irq_swizzle->irq_to_mask[irq]; bit = sable_lynx_irq_swizzle->irq_to_mask[d->irq];
spin_lock(&sable_lynx_irq_lock); spin_lock(&sable_lynx_irq_lock);
mask = sable_lynx_irq_swizzle->shadow_mask |= 1UL << bit; mask = sable_lynx_irq_swizzle->shadow_mask |= 1UL << bit;
sable_lynx_irq_swizzle->update_irq_hw(bit, mask); sable_lynx_irq_swizzle->update_irq_hw(bit, mask);
@ -489,9 +489,9 @@ sable_lynx_mask_and_ack_irq(unsigned int irq)
static struct irq_chip sable_lynx_irq_type = { static struct irq_chip sable_lynx_irq_type = {
.name = "SABLE/LYNX", .name = "SABLE/LYNX",
.unmask = sable_lynx_enable_irq, .irq_unmask = sable_lynx_enable_irq,
.mask = sable_lynx_disable_irq, .irq_mask = sable_lynx_disable_irq,
.mask_ack = sable_lynx_mask_and_ack_irq, .irq_mask_ack = sable_lynx_mask_and_ack_irq,
}; };
static void static void
@ -518,9 +518,9 @@ sable_lynx_init_irq(int nr_of_irqs)
long i; long i;
for (i = 0; i < nr_of_irqs; ++i) { for (i = 0; i < nr_of_irqs; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &sable_lynx_irq_type, set_irq_chip_and_handler(i, &sable_lynx_irq_type,
handle_level_irq); handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
common_init_isa_dma(); common_init_isa_dma();

14
arch/alpha/kernel/sys_takara.c
View File

@ -45,16 +45,18 @@ takara_update_irq_hw(unsigned long irq, unsigned long mask)
} }
static inline void static inline void
takara_enable_irq(unsigned int irq) takara_enable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
unsigned long mask; unsigned long mask;
mask = (cached_irq_mask[irq >= 64] &= ~(1UL << (irq & 63))); mask = (cached_irq_mask[irq >= 64] &= ~(1UL << (irq & 63)));
takara_update_irq_hw(irq, mask); takara_update_irq_hw(irq, mask);
} }
static void static void
takara_disable_irq(unsigned int irq) takara_disable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
unsigned long mask; unsigned long mask;
mask = (cached_irq_mask[irq >= 64] |= 1UL << (irq & 63)); mask = (cached_irq_mask[irq >= 64] |= 1UL << (irq & 63));
takara_update_irq_hw(irq, mask); takara_update_irq_hw(irq, mask);
@ -62,9 +64,9 @@ takara_disable_irq(unsigned int irq)
static struct irq_chip takara_irq_type = { static struct irq_chip takara_irq_type = {
.name = "TAKARA", .name = "TAKARA",
.unmask = takara_enable_irq, .irq_unmask = takara_enable_irq,
.mask = takara_disable_irq, .irq_mask = takara_disable_irq,
.mask_ack = takara_disable_irq, .irq_mask_ack = takara_disable_irq,
}; };
static void static void
@ -136,8 +138,8 @@ takara_init_irq(void)
takara_update_irq_hw(i, -1); takara_update_irq_hw(i, -1);
for (i = 16; i < 128; ++i) { for (i = 16; i < 128; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, &takara_irq_type, handle_level_irq); set_irq_chip_and_handler(i, &takara_irq_type, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
common_init_isa_dma(); common_init_isa_dma();

21
arch/alpha/kernel/sys_titan.c
View File

@ -112,8 +112,9 @@ titan_update_irq_hw(unsigned long mask)
} }
static inline void static inline void
titan_enable_irq(unsigned int irq) titan_enable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
spin_lock(&titan_irq_lock); spin_lock(&titan_irq_lock);
titan_cached_irq_mask |= 1UL << (irq - 16); titan_cached_irq_mask |= 1UL << (irq - 16);
titan_update_irq_hw(titan_cached_irq_mask); titan_update_irq_hw(titan_cached_irq_mask);
@ -121,8 +122,9 @@ titan_enable_irq(unsigned int irq)
} }
static inline void static inline void
titan_disable_irq(unsigned int irq) titan_disable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
spin_lock(&titan_irq_lock); spin_lock(&titan_irq_lock);
titan_cached_irq_mask &= ~(1UL << (irq - 16)); titan_cached_irq_mask &= ~(1UL << (irq - 16));
titan_update_irq_hw(titan_cached_irq_mask); titan_update_irq_hw(titan_cached_irq_mask);
@ -144,7 +146,8 @@ titan_cpu_set_irq_affinity(unsigned int irq, cpumask_t affinity)
} }
static int static int
titan_set_irq_affinity(unsigned int irq, const struct cpumask *affinity) titan_set_irq_affinity(struct irq_data *d, const struct cpumask *affinity,
bool force)
{ {
spin_lock(&titan_irq_lock); spin_lock(&titan_irq_lock);
titan_cpu_set_irq_affinity(irq - 16, *affinity); titan_cpu_set_irq_affinity(irq - 16, *affinity);
@ -175,17 +178,17 @@ init_titan_irqs(struct irq_chip * ops, int imin, int imax)
{ {
long i; long i;
for (i = imin; i <= imax; ++i) { for (i = imin; i <= imax; ++i) {
irq_to_desc(i)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i, ops, handle_level_irq); set_irq_chip_and_handler(i, ops, handle_level_irq);
irq_set_status_flags(i, IRQ_LEVEL);
} }
} }
static struct irq_chip titan_irq_type = { static struct irq_chip titan_irq_type = {
.name = "TITAN", .name = "TITAN",
.unmask = titan_enable_irq, .irq_unmask = titan_enable_irq,
.mask = titan_disable_irq, .irq_mask = titan_disable_irq,
.mask_ack = titan_disable_irq, .irq_mask_ack = titan_disable_irq,
.set_affinity = titan_set_irq_affinity, .irq_set_affinity = titan_set_irq_affinity,
}; };
static irqreturn_t static irqreturn_t

32
arch/alpha/kernel/sys_wildfire.c
View File

@ -104,10 +104,12 @@ wildfire_init_irq_hw(void)
} }
static void static void
wildfire_enable_irq(unsigned int irq) wildfire_enable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
if (irq < 16) if (irq < 16)
i8259a_enable_irq(irq); i8259a_enable_irq(d);
spin_lock(&wildfire_irq_lock); spin_lock(&wildfire_irq_lock);
set_bit(irq, &cached_irq_mask); set_bit(irq, &cached_irq_mask);
@ -116,10 +118,12 @@ wildfire_enable_irq(unsigned int irq)
} }
static void static void
wildfire_disable_irq(unsigned int irq) wildfire_disable_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
if (irq < 16) if (irq < 16)
i8259a_disable_irq(irq); i8259a_disable_irq(d);
spin_lock(&wildfire_irq_lock); spin_lock(&wildfire_irq_lock);
clear_bit(irq, &cached_irq_mask); clear_bit(irq, &cached_irq_mask);
@ -128,10 +132,12 @@ wildfire_disable_irq(unsigned int irq)
} }
static void static void
wildfire_mask_and_ack_irq(unsigned int irq) wildfire_mask_and_ack_irq(struct irq_data *d)
{ {
unsigned int irq = d->irq;
if (irq < 16) if (irq < 16)
i8259a_mask_and_ack_irq(irq); i8259a_mask_and_ack_irq(d);
spin_lock(&wildfire_irq_lock); spin_lock(&wildfire_irq_lock);
clear_bit(irq, &cached_irq_mask); clear_bit(irq, &cached_irq_mask);
@ -141,9 +147,9 @@ wildfire_mask_and_ack_irq(unsigned int irq)
static struct irq_chip wildfire_irq_type = { static struct irq_chip wildfire_irq_type = {
.name = "WILDFIRE", .name = "WILDFIRE",
.unmask = wildfire_enable_irq, .irq_unmask = wildfire_enable_irq,
.mask = wildfire_disable_irq, .irq_mask = wildfire_disable_irq,
.mask_ack = wildfire_mask_and_ack_irq, .irq_mask_ack = wildfire_mask_and_ack_irq,
}; };
static void __init static void __init
@ -177,21 +183,21 @@ wildfire_init_irq_per_pca(int qbbno, int pcano)
for (i = 0; i < 16; ++i) { for (i = 0; i < 16; ++i) {
if (i == 2) if (i == 2)
continue; continue;
irq_to_desc(i+irq_bias)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type, set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type,
handle_level_irq); handle_level_irq);
irq_set_status_flags(i + irq_bias, IRQ_LEVEL);
} }
irq_to_desc(36+irq_bias)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(36+irq_bias, &wildfire_irq_type, set_irq_chip_and_handler(36+irq_bias, &wildfire_irq_type,
handle_level_irq); handle_level_irq);
irq_set_status_flags(36 + irq_bias, IRQ_LEVEL);
for (i = 40; i < 64; ++i) { for (i = 40; i < 64; ++i) {
irq_to_desc(i+irq_bias)->status |= IRQ_LEVEL;
set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type, set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type,
handle_level_irq); handle_level_irq);
irq_set_status_flags(i + irq_bias, IRQ_LEVEL);
} }
setup_irq(32+irq_bias, &isa_enable); setup_irq(32+irq_bias, &isa_enable);
} }
static void __init static void __init