Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

IRQ: Maintain regs pointer globally rather than passing to IRQ handlers

Browse source 
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.

The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around.  On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).

Where appropriate, an arch may override the generic storage facility and do
something different with the variable.  On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.

Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions.  Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller.  A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.

I've build this code with allyesconfig for x86_64 and i386.  I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.

This will affect all archs.  Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:

	struct pt_regs *old_regs = set_irq_regs(regs);

And put the old one back at the end:

	set_irq_regs(old_regs);

Don't pass regs through to generic_handle_irq() or __do_IRQ().

In timer_interrupt(), this sort of change will be necessary:

	-	update_process_times(user_mode(regs));
	-	profile_tick(CPU_PROFILING, regs);
	+	update_process_times(user_mode(get_irq_regs()));
	+	profile_tick(CPU_PROFILING);

I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().

Some notes on the interrupt handling in the drivers:

 (*) input_dev() is now gone entirely.  The regs pointer is no longer stored in
     the input_dev struct.

 (*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking.  It does
     something different depending on whether it's been supplied with a regs
     pointer or not.

 (*) Various IRQ handler function pointers have been moved to type
     irq_handler_t.

Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
This commit is contained in:
David Howells 2006-10-05 14:55:46 +01:00 committed by David Howells
parent da482792a6
commit 7d12e780e0
1079 changed files with 2621 additions and 2976 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
arch/frv/kernel/dma.c
View file

@ -121,15 +121,14 @@ unsigned long frv_dma_inprogress;
/* /*
* DMA irq handler - determine channel involved, grab status and call real handler * DMA irq handler - determine channel involved, grab status and call real handler
*/ */
static irqreturn_t dma_irq_handler(int irq, void *_channel, struct pt_regs *regs) static irqreturn_t dma_irq_handler(int irq, void *_channel)
{ {
struct frv_dma_channel *channel = _channel; struct frv_dma_channel *channel = _channel;
frv_clear_dma_inprogress(channel - frv_dma_channels); frv_clear_dma_inprogress(channel - frv_dma_channels);
return channel->handler(channel - frv_dma_channels, return channel->handler(channel - frv_dma_channels,
__get_DMAC(channel->ioaddr, CSTR), __get_DMAC(channel->ioaddr, CSTR),
channel->data, channel->data);
regs);
} /* end dma_irq_handler() */ } /* end dma_irq_handler() */

4
arch/frv/kernel/irq-mb93091.c
View file

@ -80,7 +80,7 @@ static struct irq_chip frv_fpga_pic = {
/* /*
* FPGA PIC interrupt handler * FPGA PIC interrupt handler
*/ */
static irqreturn_t fpga_interrupt(int irq, void *_mask, struct pt_regs *regs) static irqreturn_t fpga_interrupt(int irq, void *_mask)
{ {
uint16_t imr, mask = (unsigned long) _mask; uint16_t imr, mask = (unsigned long) _mask;
@ -95,7 +95,7 @@ static irqreturn_t fpga_interrupt(int irq, void *_mask, struct pt_regs *regs)
irq = 31 - irq; irq = 31 - irq;
mask &= ~(1 << irq); mask &= ~(1 << irq);
generic_handle_irq(IRQ_BASE_FPGA + irq, regs); generic_handle_irq(IRQ_BASE_FPGA + irq);
} }
return IRQ_HANDLED; return IRQ_HANDLED;

4
arch/frv/kernel/irq-mb93093.c
View file

@ -79,7 +79,7 @@ static struct irq_chip frv_fpga_pic = {
/* /*
* FPGA PIC interrupt handler * FPGA PIC interrupt handler
*/ */
static irqreturn_t fpga_interrupt(int irq, void *_mask, struct pt_regs *regs) static irqreturn_t fpga_interrupt(int irq, void *_mask)
{ {
uint16_t imr, mask = (unsigned long) _mask; uint16_t imr, mask = (unsigned long) _mask;
@ -94,7 +94,7 @@ static irqreturn_t fpga_interrupt(int irq, void *_mask, struct pt_regs *regs)
irq = 31 - irq; irq = 31 - irq;
mask &= ~(1 << irq); mask &= ~(1 << irq);
generic_irq_handle(IRQ_BASE_FPGA + irq, regs); generic_irq_handle(IRQ_BASE_FPGA + irq);
} }
return IRQ_HANDLED; return IRQ_HANDLED;

4
arch/frv/kernel/irq-mb93493.c
View file

@ -90,7 +90,7 @@ static struct irq_chip frv_mb93493_pic = {
/* /*
* MB93493 PIC interrupt handler * MB93493 PIC interrupt handler
*/ */
static irqreturn_t mb93493_interrupt(int irq, void *_piqsr, struct pt_regs *regs) static irqreturn_t mb93493_interrupt(int irq, void *_piqsr)
{ {
volatile void *piqsr = _piqsr; volatile void *piqsr = _piqsr;
uint32_t iqsr; uint32_t iqsr;
@ -106,7 +106,7 @@ static irqreturn_t mb93493_interrupt(int irq, void *_piqsr, struct pt_regs *regs
irq = 31 - irq; irq = 31 - irq;
iqsr &= ~(1 << irq); iqsr &= ~(1 << irq);
generic_handle_irq(IRQ_BASE_MB93493 + irq, regs); generic_handle_irq(IRQ_BASE_MB93493 + irq);
} }
return IRQ_HANDLED; return IRQ_HANDLED;

2
arch/frv/kernel/irq.c
View file

@ -143,7 +143,7 @@ static struct irq_chip frv_cpu_pic = {
asmlinkage void do_IRQ(void) asmlinkage void do_IRQ(void)
{ {
irq_enter(); irq_enter();
generic_handle_irq(__get_IRL(), __frame); generic_handle_irq(__get_IRL());
irq_exit(); irq_exit();
} }

8
arch/frv/kernel/time.c
View file

@ -40,7 +40,7 @@ unsigned long __nongprelbss __dsu_clock_speed_HZ;
unsigned long __nongprelbss __serial_clock_speed_HZ; unsigned long __nongprelbss __serial_clock_speed_HZ;
unsigned long __delay_loops_MHz; unsigned long __delay_loops_MHz;
static irqreturn_t timer_interrupt(int irq, void *dummy, struct pt_regs *regs); static irqreturn_t timer_interrupt(int irq, void *dummy);
static struct irqaction timer_irq = { static struct irqaction timer_irq = {
timer_interrupt, IRQF_DISABLED, CPU_MASK_NONE, "timer", NULL, NULL timer_interrupt, IRQF_DISABLED, CPU_MASK_NONE, "timer", NULL, NULL
@ -55,7 +55,7 @@ static inline int set_rtc_mmss(unsigned long nowtime)
* timer_interrupt() needs to keep up the real-time clock, * timer_interrupt() needs to keep up the real-time clock,
* as well as call the "do_timer()" routine every clocktick * as well as call the "do_timer()" routine every clocktick
*/ */
static irqreturn_t timer_interrupt(int irq, void *dummy, struct pt_regs * regs) static irqreturn_t timer_interrupt(int irq, void *dummy)
{ {
/* last time the cmos clock got updated */ /* last time the cmos clock got updated */
static long last_rtc_update = 0; static long last_rtc_update = 0;
@ -70,8 +70,8 @@ static irqreturn_t timer_interrupt(int irq, void *dummy, struct pt_regs * regs)
write_seqlock(&xtime_lock); write_seqlock(&xtime_lock);
do_timer(1); do_timer(1);
update_process_times(user_mode(regs)); update_process_times(user_mode(get_irq_regs()));
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
/* /*
* If we have an externally synchronized Linux clock, then update * If we have an externally synchronized Linux clock, then update

18
arch/i386/kernel/apic.c
View file

@ -1193,11 +1193,11 @@ EXPORT_SYMBOL(switch_ipi_to_APIC_timer);
* value into /proc/profile. * value into /proc/profile.
*/ */
inline void smp_local_timer_interrupt(struct pt_regs * regs) inline void smp_local_timer_interrupt(void)
{ {
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
update_process_times(user_mode_vm(regs)); update_process_times(user_mode_vm(irq_regs));
#endif #endif
/* /*
@ -1223,6 +1223,7 @@ inline void smp_local_timer_interrupt(struct pt_regs * regs)
fastcall void smp_apic_timer_interrupt(struct pt_regs *regs) fastcall void smp_apic_timer_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
int cpu = smp_processor_id(); int cpu = smp_processor_id();
/* /*
@ -1241,12 +1242,13 @@ fastcall void smp_apic_timer_interrupt(struct pt_regs *regs)
* interrupt lock, which is the WrongThing (tm) to do. * interrupt lock, which is the WrongThing (tm) to do.
*/ */
irq_enter(); irq_enter();
smp_local_timer_interrupt(regs); smp_local_timer_interrupt();
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
#ifndef CONFIG_SMP #ifndef CONFIG_SMP
static void up_apic_timer_interrupt_call(struct pt_regs *regs) static void up_apic_timer_interrupt_call(void)
{ {
int cpu = smp_processor_id(); int cpu = smp_processor_id();
@ -1255,11 +1257,11 @@ static void up_apic_timer_interrupt_call(struct pt_regs *regs)
*/ */
per_cpu(irq_stat, cpu).apic_timer_irqs++; per_cpu(irq_stat, cpu).apic_timer_irqs++;
smp_local_timer_interrupt(regs); smp_local_timer_interrupt();
} }
#endif #endif
void smp_send_timer_broadcast_ipi(struct pt_regs *regs) void smp_send_timer_broadcast_ipi(void)
{ {
cpumask_t mask; cpumask_t mask;
@ -1272,7 +1274,7 @@ void smp_send_timer_broadcast_ipi(struct pt_regs *regs)
* We can directly call the apic timer interrupt handler * We can directly call the apic timer interrupt handler
* in UP case. Minus all irq related functions * in UP case. Minus all irq related functions
*/ */
up_apic_timer_interrupt_call(regs); up_apic_timer_interrupt_call();
#endif #endif
} }
} }

4
arch/i386/kernel/i8259.c
View file

@ -335,13 +335,13 @@ void init_8259A(int auto_eoi)
*/ */
static irqreturn_t math_error_irq(int cpl, void *dev_id, struct pt_regs *regs) static irqreturn_t math_error_irq(int cpl, void *dev_id)
{ {
extern void math_error(void __user *); extern void math_error(void __user *);
outb(0,0xF0); outb(0,0xF0);
if (ignore_fpu_irq || !boot_cpu_data.hard_math) if (ignore_fpu_irq || !boot_cpu_data.hard_math)
return IRQ_NONE; return IRQ_NONE;
math_error((void __user *)regs->eip); math_error((void __user *)get_irq_regs()->eip);
return IRQ_HANDLED; return IRQ_HANDLED;
} }

12
arch/i386/kernel/irq.c
View file

@ -53,6 +53,7 @@ static union irq_ctx *softirq_ctx[NR_CPUS] __read_mostly;
*/ */
fastcall unsigned int do_IRQ(struct pt_regs *regs) fastcall unsigned int do_IRQ(struct pt_regs *regs)
{ {
struct pt_regs *old_regs;
/* high bit used in ret_from_ code */ /* high bit used in ret_from_ code */
int irq = ~regs->orig_eax; int irq = ~regs->orig_eax;
struct irq_desc *desc = irq_desc + irq; struct irq_desc *desc = irq_desc + irq;
@ -67,6 +68,7 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
BUG(); BUG();
} }
old_regs = set_irq_regs(regs);
irq_enter(); irq_enter();
#ifdef CONFIG_DEBUG_STACKOVERFLOW #ifdef CONFIG_DEBUG_STACKOVERFLOW
/* Debugging check for stack overflow: is there less than 1KB free? */ /* Debugging check for stack overflow: is there less than 1KB free? */
@ -95,7 +97,7 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
* current stack (which is the irq stack already after all) * current stack (which is the irq stack already after all)
*/ */
if (curctx != irqctx) { if (curctx != irqctx) {
int arg1, arg2, arg3, ebx; int arg1, arg2, ebx;
/* build the stack frame on the IRQ stack */ /* build the stack frame on the IRQ stack */
isp = (u32*) ((char*)irqctx + sizeof(*irqctx)); isp = (u32*) ((char*)irqctx + sizeof(*irqctx));
@ -114,17 +116,17 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
" xchgl %%ebx,%%esp \n" " xchgl %%ebx,%%esp \n"
" call *%%edi \n" " call *%%edi \n"
" movl %%ebx,%%esp \n" " movl %%ebx,%%esp \n"
: "=a" (arg1), "=d" (arg2), "=c" (arg3), "=b" (ebx) : "=a" (arg1), "=d" (arg2), "=b" (ebx)
: "0" (irq), "1" (desc), "2" (regs), "3" (isp), : "0" (irq), "1" (desc), "2" (isp),
"D" (desc->handle_irq) "D" (desc->handle_irq)
: "memory", "cc" : "memory", "cc"
); );
} else } else
#endif #endif
desc->handle_irq(irq, desc, regs); desc->handle_irq(irq, desc);
irq_exit(); irq_exit();
set_irq_regs(old_regs);
return 1; return 1;
} }

6
arch/i386/kernel/smp.c
View file

@ -321,6 +321,7 @@ static inline void leave_mm (unsigned long cpu)
fastcall void smp_invalidate_interrupt(struct pt_regs *regs) fastcall void smp_invalidate_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
unsigned long cpu; unsigned long cpu;
cpu = get_cpu(); cpu = get_cpu();
@ -351,6 +352,7 @@ fastcall void smp_invalidate_interrupt(struct pt_regs *regs)
smp_mb__after_clear_bit(); smp_mb__after_clear_bit();
out: out:
put_cpu_no_resched(); put_cpu_no_resched();
set_irq_regs(old_regs);
} }
static void flush_tlb_others(cpumask_t cpumask, struct mm_struct *mm, static void flush_tlb_others(cpumask_t cpumask, struct mm_struct *mm,
@ -605,11 +607,14 @@ void smp_send_stop(void)
*/ */
fastcall void smp_reschedule_interrupt(struct pt_regs *regs) fastcall void smp_reschedule_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
ack_APIC_irq(); ack_APIC_irq();
set_irq_regs(old_regs);
} }
fastcall void smp_call_function_interrupt(struct pt_regs *regs) fastcall void smp_call_function_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
void (*func) (void *info) = call_data->func; void (*func) (void *info) = call_data->func;
void *info = call_data->info; void *info = call_data->info;
int wait = call_data->wait; int wait = call_data->wait;
@ -632,6 +637,7 @@ fastcall void smp_call_function_interrupt(struct pt_regs *regs)
mb(); mb();
atomic_inc(&call_data->finished); atomic_inc(&call_data->finished);
} }
set_irq_regs(old_regs);
} }
/* /*

6
arch/i386/kernel/time.c
View file

@ -161,7 +161,7 @@ EXPORT_SYMBOL(profile_pc);
* Time Stamp Counter value at the time of the timer interrupt, so that * Time Stamp Counter value at the time of the timer interrupt, so that
* we later on can estimate the time of day more exactly. * we later on can estimate the time of day more exactly.
*/ */
irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) irqreturn_t timer_interrupt(int irq, void *dev_id)
{ {
/* /*
* Here we are in the timer irq handler. We just have irqs locally * Here we are in the timer irq handler. We just have irqs locally
@ -188,7 +188,7 @@ irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
} }
#endif #endif
do_timer_interrupt_hook(regs); do_timer_interrupt_hook();
if (MCA_bus) { if (MCA_bus) {
@ -209,7 +209,7 @@ irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
#ifdef CONFIG_X86_LOCAL_APIC #ifdef CONFIG_X86_LOCAL_APIC
if (using_apic_timer) if (using_apic_timer)
smp_send_timer_broadcast_ipi(regs); smp_send_timer_broadcast_ipi();
#endif #endif
return IRQ_HANDLED; return IRQ_HANDLED;

4
arch/i386/kernel/time_hpet.c
View file

@ -441,7 +441,7 @@ int hpet_rtc_dropped_irq(void)
return 1; return 1;
} }
irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs) irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
{ {
struct rtc_time curr_time; struct rtc_time curr_time;
unsigned long rtc_int_flag = 0; unsigned long rtc_int_flag = 0;
@ -480,7 +480,7 @@ irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
} }
if (call_rtc_interrupt) { if (call_rtc_interrupt) {
rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8)); rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
rtc_interrupt(rtc_int_flag, dev_id, regs); rtc_interrupt(rtc_int_flag, dev_id);
} }
return IRQ_HANDLED; return IRQ_HANDLED;
} }

2
arch/i386/kernel/vm86.c
View file

@ -714,7 +714,7 @@ static int irqbits;
| (1 << SIGUSR1) | (1 << SIGUSR2) | (1 << SIGIO) | (1 << SIGURG) \ | (1 << SIGUSR1) | (1 << SIGUSR2) | (1 << SIGIO) | (1 << SIGURG) \
| (1 << SIGUNUSED) ) | (1 << SIGUNUSED) )
static irqreturn_t irq_handler(int intno, void *dev_id, struct pt_regs * regs) static irqreturn_t irq_handler(int intno, void *dev_id)
{ {
int irq_bit; int irq_bit;
unsigned long flags; unsigned long flags;

4
arch/i386/mach-visws/visws_apic.c
View file

@ -191,7 +191,7 @@ static struct hw_interrupt_type piix4_virtual_irq_type = {
* enable_irq gets the right irq. This 'master' irq is never directly * enable_irq gets the right irq. This 'master' irq is never directly
* manipulated by any driver. * manipulated by any driver.
*/ */
static irqreturn_t piix4_master_intr(int irq, void *dev_id, struct pt_regs * regs) static irqreturn_t piix4_master_intr(int irq, void *dev_id)
{ {
int realirq; int realirq;
irq_desc_t *desc; irq_desc_t *desc;
@ -244,7 +244,7 @@ static irqreturn_t piix4_master_intr(int irq, void *dev_id, struct pt_regs * reg
kstat_cpu(smp_processor_id()).irqs[realirq]++; kstat_cpu(smp_processor_id()).irqs[realirq]++;
if (likely(desc->action != NULL)) if (likely(desc->action != NULL))
handle_IRQ_event(realirq, regs, desc->action); handle_IRQ_event(realirq, desc->action);
if (!(desc->status & IRQ_DISABLED)) if (!(desc->status & IRQ_DISABLED))
enable_8259A_irq(realirq); enable_8259A_irq(realirq);

2
arch/i386/mach-voyager/voyager_basic.c
View file

@ -87,7 +87,7 @@ voyager_detect(struct voyager_bios_info *bios)
} }
void void
voyager_system_interrupt(int cpl, void *dev_id, struct pt_regs *regs) voyager_system_interrupt(int cpl, void *dev_id)
{ {
printk("Voyager: detected system interrupt\n"); printk("Voyager: detected system interrupt\n");
} }

26
arch/i386/mach-voyager/voyager_smp.c
View file

@ -126,10 +126,10 @@ send_QIC_CPI(__u32 cpuset, __u8 cpi)
} }
static inline void static inline void
wrapper_smp_local_timer_interrupt(struct pt_regs *regs) wrapper_smp_local_timer_interrupt(void)
{ {
irq_enter(); irq_enter();
smp_local_timer_interrupt(regs); smp_local_timer_interrupt();
irq_exit(); irq_exit();
} }
@ -1135,7 +1135,9 @@ EXPORT_SYMBOL(smp_call_function);
fastcall void fastcall void
smp_apic_timer_interrupt(struct pt_regs *regs) smp_apic_timer_interrupt(struct pt_regs *regs)
{ {
wrapper_smp_local_timer_interrupt(regs); struct pt_regs *old_regs = set_irq_regs(regs);
wrapper_smp_local_timer_interrupt();
set_irq_regs(old_regs);
} }
/* All of the QUAD interrupt GATES */ /* All of the QUAD interrupt GATES */
@ -1143,7 +1145,9 @@ fastcall void
smp_qic_timer_interrupt(struct pt_regs *regs) smp_qic_timer_interrupt(struct pt_regs *regs)
{ {
ack_QIC_CPI(QIC_TIMER_CPI); ack_QIC_CPI(QIC_TIMER_CPI);
wrapper_smp_local_timer_interrupt(regs); struct pt_regs *old_regs = set_irq_regs(regs);
wrapper_smp_local_timer_interrupt(void);
set_irq_regs(old_regs);
} }
fastcall void fastcall void
@ -1177,6 +1181,7 @@ smp_qic_call_function_interrupt(struct pt_regs *regs)
fastcall void fastcall void
smp_vic_cpi_interrupt(struct pt_regs *regs) smp_vic_cpi_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
__u8 cpu = smp_processor_id(); __u8 cpu = smp_processor_id();
if(is_cpu_quad()) if(is_cpu_quad())
@ -1185,7 +1190,7 @@ smp_vic_cpi_interrupt(struct pt_regs *regs)
ack_VIC_CPI(VIC_CPI_LEVEL0); ack_VIC_CPI(VIC_CPI_LEVEL0);
if(test_and_clear_bit(VIC_TIMER_CPI, &vic_cpi_mailbox[cpu])) if(test_and_clear_bit(VIC_TIMER_CPI, &vic_cpi_mailbox[cpu]))
wrapper_smp_local_timer_interrupt(regs); wrapper_smp_local_timer_interrupt();
if(test_and_clear_bit(VIC_INVALIDATE_CPI, &vic_cpi_mailbox[cpu])) if(test_and_clear_bit(VIC_INVALIDATE_CPI, &vic_cpi_mailbox[cpu]))
smp_invalidate_interrupt(); smp_invalidate_interrupt();
if(test_and_clear_bit(VIC_RESCHEDULE_CPI, &vic_cpi_mailbox[cpu])) if(test_and_clear_bit(VIC_RESCHEDULE_CPI, &vic_cpi_mailbox[cpu]))
@ -1194,6 +1199,7 @@ smp_vic_cpi_interrupt(struct pt_regs *regs)
smp_enable_irq_interrupt(); smp_enable_irq_interrupt();
if(test_and_clear_bit(VIC_CALL_FUNCTION_CPI, &vic_cpi_mailbox[cpu])) if(test_and_clear_bit(VIC_CALL_FUNCTION_CPI, &vic_cpi_mailbox[cpu]))
smp_call_function_interrupt(); smp_call_function_interrupt();
set_irq_regs(old_regs);
} }
static void static void
@ -1266,8 +1272,10 @@ smp_send_stop(void)
void void
smp_vic_timer_interrupt(struct pt_regs *regs) smp_vic_timer_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
send_CPI_allbutself(VIC_TIMER_CPI); send_CPI_allbutself(VIC_TIMER_CPI);
smp_local_timer_interrupt(regs); smp_local_timer_interrupt();
set_irq_regs(old_regs);
} }
/* local (per CPU) timer interrupt. It does both profiling and /* local (per CPU) timer interrupt. It does both profiling and
@ -1279,12 +1287,12 @@ smp_vic_timer_interrupt(struct pt_regs *regs)
* value into /proc/profile. * value into /proc/profile.
*/ */
void void
smp_local_timer_interrupt(struct pt_regs * regs) smp_local_timer_interrupt(void)
{ {
int cpu = smp_processor_id(); int cpu = smp_processor_id();
long weight; long weight;
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
if (--per_cpu(prof_counter, cpu) <= 0) { if (--per_cpu(prof_counter, cpu) <= 0) {
/* /*
* The multiplier may have changed since the last time we got * The multiplier may have changed since the last time we got
@ -1302,7 +1310,7 @@ smp_local_timer_interrupt(struct pt_regs * regs)
per_cpu(prof_counter, cpu); per_cpu(prof_counter, cpu);
} }
update_process_times(user_mode_vm(regs)); update_process_times(user_mode_vm(irq_regs));
} }
if( ((1<<cpu) & voyager_extended_vic_processors) == 0) if( ((1<<cpu) & voyager_extended_vic_processors) == 0)

4
arch/ia64/kernel/irq_ia64.c
View file

@ -138,6 +138,7 @@ void destroy_irq(unsigned int irq)
void void
ia64_handle_irq (ia64_vector vector, struct pt_regs *regs) ia64_handle_irq (ia64_vector vector, struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
unsigned long saved_tpr; unsigned long saved_tpr;
#if IRQ_DEBUG #if IRQ_DEBUG
@ -183,7 +184,7 @@ ia64_handle_irq (ia64_vector vector, struct pt_regs *regs)
ia64_setreg(_IA64_REG_CR_TPR, vector); ia64_setreg(_IA64_REG_CR_TPR, vector);
ia64_srlz_d(); ia64_srlz_d();
__do_IRQ(local_vector_to_irq(vector), regs); __do_IRQ(local_vector_to_irq(vector));
/* /*
* Disable interrupts and send EOI: * Disable interrupts and send EOI:
@ -200,6 +201,7 @@ ia64_handle_irq (ia64_vector vector, struct pt_regs *regs)
* come through until ia64_eoi() has been done. * come through until ia64_eoi() has been done.
*/ */
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
#ifdef CONFIG_HOTPLUG_CPU #ifdef CONFIG_HOTPLUG_CPU

2
arch/ia64/kernel/machvec.c
View file

@ -60,7 +60,7 @@ machvec_setup (char **arg)
EXPORT_SYMBOL(machvec_setup); EXPORT_SYMBOL(machvec_setup);
void void
machvec_timer_interrupt (int irq, void *dev_id, struct pt_regs *regs) machvec_timer_interrupt (int irq, void *dev_id)
{ {
} }
EXPORT_SYMBOL(machvec_timer_interrupt); EXPORT_SYMBOL(machvec_timer_interrupt);

32
arch/ia64/kernel/mca.c
View file

@ -499,7 +499,7 @@ int cpe_vector = -1;
int ia64_cpe_irq = -1; int ia64_cpe_irq = -1;
static irqreturn_t static irqreturn_t
ia64_mca_cpe_int_handler (int cpe_irq, void *arg, struct pt_regs *ptregs) ia64_mca_cpe_int_handler (int cpe_irq, void *arg)
{ {
static unsigned long cpe_history[CPE_HISTORY_LENGTH]; static unsigned long cpe_history[CPE_HISTORY_LENGTH];
static int index; static int index;
@ -744,7 +744,7 @@ ia64_mca_wakeup_all(void)
* Outputs : None * Outputs : None
*/ */
static irqreturn_t static irqreturn_t
ia64_mca_rendez_int_handler(int rendez_irq, void *arg, struct pt_regs *regs) ia64_mca_rendez_int_handler(int rendez_irq, void *arg)
{ {
unsigned long flags; unsigned long flags;
int cpu = smp_processor_id(); int cpu = smp_processor_id();
@ -753,8 +753,8 @@ ia64_mca_rendez_int_handler(int rendez_irq, void *arg, struct pt_regs *regs)
/* Mask all interrupts */ /* Mask all interrupts */
local_irq_save(flags); local_irq_save(flags);
if (notify_die(DIE_MCA_RENDZVOUS_ENTER, "MCA", regs, (long)&nd, 0, 0) if (notify_die(DIE_MCA_RENDZVOUS_ENTER, "MCA", get_irq_regs(),
== NOTIFY_STOP) (long)&nd, 0, 0) == NOTIFY_STOP)
ia64_mca_spin(__FUNCTION__); ia64_mca_spin(__FUNCTION__);
ia64_mc_info.imi_rendez_checkin[cpu] = IA64_MCA_RENDEZ_CHECKIN_DONE; ia64_mc_info.imi_rendez_checkin[cpu] = IA64_MCA_RENDEZ_CHECKIN_DONE;
@ -763,16 +763,16 @@ ia64_mca_rendez_int_handler(int rendez_irq, void *arg, struct pt_regs *regs)
*/ */
ia64_sal_mc_rendez(); ia64_sal_mc_rendez();
if (notify_die(DIE_MCA_RENDZVOUS_PROCESS, "MCA", regs, (long)&nd, 0, 0) if (notify_die(DIE_MCA_RENDZVOUS_PROCESS, "MCA", get_irq_regs(),
== NOTIFY_STOP) (long)&nd, 0, 0) == NOTIFY_STOP)
ia64_mca_spin(__FUNCTION__); ia64_mca_spin(__FUNCTION__);
/* Wait for the monarch cpu to exit. */ /* Wait for the monarch cpu to exit. */
while (monarch_cpu != -1) while (monarch_cpu != -1)
cpu_relax(); /* spin until monarch leaves */ cpu_relax(); /* spin until monarch leaves */
if (notify_die(DIE_MCA_RENDZVOUS_LEAVE, "MCA", regs, (long)&nd, 0, 0) if (notify_die(DIE_MCA_RENDZVOUS_LEAVE, "MCA", get_irq_regs(),
== NOTIFY_STOP) (long)&nd, 0, 0) == NOTIFY_STOP)
ia64_mca_spin(__FUNCTION__); ia64_mca_spin(__FUNCTION__);
/* Enable all interrupts */ /* Enable all interrupts */
@ -791,12 +791,11 @@ ia64_mca_rendez_int_handler(int rendez_irq, void *arg, struct pt_regs *regs)
* *
* Inputs : wakeup_irq (Wakeup-interrupt bit) * Inputs : wakeup_irq (Wakeup-interrupt bit)
* arg (Interrupt handler specific argument) * arg (Interrupt handler specific argument)
* ptregs (Exception frame at the time of the interrupt)
* Outputs : None * Outputs : None
* *
*/ */
static irqreturn_t static irqreturn_t
ia64_mca_wakeup_int_handler(int wakeup_irq, void *arg, struct pt_regs *ptregs) ia64_mca_wakeup_int_handler(int wakeup_irq, void *arg)
{ {
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -1261,13 +1260,12 @@ static DECLARE_WORK(cmc_enable_work, ia64_mca_cmc_vector_enable_keventd, NULL);
* Inputs * Inputs
* interrupt number * interrupt number
* client data arg ptr * client data arg ptr
* saved registers ptr
* *
* Outputs * Outputs
* None * None
*/ */
static irqreturn_t static irqreturn_t
ia64_mca_cmc_int_handler(int cmc_irq, void *arg, struct pt_regs *ptregs) ia64_mca_cmc_int_handler(int cmc_irq, void *arg)
{ {
static unsigned long cmc_history[CMC_HISTORY_LENGTH]; static unsigned long cmc_history[CMC_HISTORY_LENGTH];
static int index; static int index;
@ -1336,12 +1334,11 @@ ia64_mca_cmc_int_handler(int cmc_irq, void *arg, struct pt_regs *ptregs)
* Inputs * Inputs
* interrupt number * interrupt number
* client data arg ptr * client data arg ptr
* saved registers ptr
* Outputs * Outputs
* handled * handled
*/ */
static irqreturn_t static irqreturn_t
ia64_mca_cmc_int_caller(int cmc_irq, void *arg, struct pt_regs *ptregs) ia64_mca_cmc_int_caller(int cmc_irq, void *arg)
{ {
static int start_count = -1; static int start_count = -1;
unsigned int cpuid; unsigned int cpuid;
@ -1352,7 +1349,7 @@ ia64_mca_cmc_int_caller(int cmc_irq, void *arg, struct pt_regs *ptregs)
if (start_count == -1) if (start_count == -1)
start_count = IA64_LOG_COUNT(SAL_INFO_TYPE_CMC); start_count = IA64_LOG_COUNT(SAL_INFO_TYPE_CMC);
ia64_mca_cmc_int_handler(cmc_irq, arg, ptregs); ia64_mca_cmc_int_handler(cmc_irq, arg);
for (++cpuid ; cpuid < NR_CPUS && !cpu_online(cpuid) ; cpuid++); for (++cpuid ; cpuid < NR_CPUS && !cpu_online(cpuid) ; cpuid++);
@ -1403,14 +1400,13 @@ ia64_mca_cmc_poll (unsigned long dummy)
* Inputs * Inputs
* interrupt number * interrupt number
* client data arg ptr * client data arg ptr
* saved registers ptr
* Outputs * Outputs
* handled * handled
*/ */
#ifdef CONFIG_ACPI #ifdef CONFIG_ACPI
static irqreturn_t static irqreturn_t
ia64_mca_cpe_int_caller(int cpe_irq, void *arg, struct pt_regs *ptregs) ia64_mca_cpe_int_caller(int cpe_irq, void *arg)
{ {
static int start_count = -1; static int start_count = -1;
static int poll_time = MIN_CPE_POLL_INTERVAL; static int poll_time = MIN_CPE_POLL_INTERVAL;
@ -1422,7 +1418,7 @@ ia64_mca_cpe_int_caller(int cpe_irq, void *arg, struct pt_regs *ptregs)
if (start_count == -1) if (start_count == -1)
start_count = IA64_LOG_COUNT(SAL_INFO_TYPE_CPE); start_count = IA64_LOG_COUNT(SAL_INFO_TYPE_CPE);
ia64_mca_cpe_int_handler(cpe_irq, arg, ptregs); ia64_mca_cpe_int_handler(cpe_irq, arg);
for (++cpuid ; cpuid < NR_CPUS && !cpu_online(cpuid) ; cpuid++); for (++cpuid ; cpuid < NR_CPUS && !cpu_online(cpuid) ; cpuid++);

8
arch/ia64/kernel/time.c
View file

@ -45,7 +45,7 @@ static struct time_interpolator itc_interpolator = {
}; };
static irqreturn_t static irqreturn_t
timer_interrupt (int irq, void *dev_id, struct pt_regs *regs) timer_interrupt (int irq, void *dev_id)
{ {
unsigned long new_itm; unsigned long new_itm;
@ -53,7 +53,7 @@ timer_interrupt (int irq, void *dev_id, struct pt_regs *regs)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
platform_timer_interrupt(irq, dev_id, regs); platform_timer_interrupt(irq, dev_id);
new_itm = local_cpu_data->itm_next; new_itm = local_cpu_data->itm_next;
@ -61,10 +61,10 @@ timer_interrupt (int irq, void *dev_id, struct pt_regs *regs)
printk(KERN_ERR "Oops: timer tick before it's due (itc=%lx,itm=%lx)\n", printk(KERN_ERR "Oops: timer tick before it's due (itc=%lx,itm=%lx)\n",
ia64_get_itc(), new_itm); ia64_get_itc(), new_itm);
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
while (1) { while (1) {
update_process_times(user_mode(regs)); update_process_times(user_mode(get_irq_regs()));
new_itm += local_cpu_data->itm_delta; new_itm += local_cpu_data->itm_delta;

3
arch/ia64/sn/pci/tioca_provider.c
View file

@ -550,13 +550,12 @@ tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
* tioca_error_intr_handler - SGI TIO CA error interrupt handler * tioca_error_intr_handler - SGI TIO CA error interrupt handler
* @irq: unused * @irq: unused
* @arg: pointer to tioca_common struct for the given CA * @arg: pointer to tioca_common struct for the given CA
* @pt: unused
* *
* Handle a CA error interrupt. Simply a wrapper around a SAL call which * Handle a CA error interrupt. Simply a wrapper around a SAL call which
* defers processing to the SGI prom. * defers processing to the SGI prom.
*/ */
static irqreturn_t static irqreturn_t
tioca_error_intr_handler(int irq, void *arg, struct pt_regs *pt) tioca_error_intr_handler(int irq, void *arg)
{ {
struct tioca_common *soft = arg; struct tioca_common *soft = arg;
struct ia64_sal_retval ret_stuff; struct ia64_sal_retval ret_stuff;

3
arch/ia64/sn/pci/tioce_provider.c
View file

@ -666,12 +666,11 @@ tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma
* tioce_error_intr_handler - SGI TIO CE error interrupt handler * tioce_error_intr_handler - SGI TIO CE error interrupt handler
* @irq: unused * @irq: unused
* @arg: pointer to tioce_common struct for the given CE * @arg: pointer to tioce_common struct for the given CE
* @pt: unused
* *
* Handle a CE error interrupt. Simply a wrapper around a SAL call which * Handle a CE error interrupt. Simply a wrapper around a SAL call which
* defers processing to the SGI prom. * defers processing to the SGI prom.
*/ static irqreturn_t */ static irqreturn_t
tioce_error_intr_handler(int irq, void *arg, struct pt_regs *pt) tioce_error_intr_handler(int irq, void *arg)
{ {
struct tioce_common *soft = arg; struct tioce_common *soft = arg;
struct ia64_sal_retval ret_stuff; struct ia64_sal_retval ret_stuff;

4
arch/mips/kernel/irq.c
View file

@ -55,13 +55,15 @@ unsigned long irq_hwmask[NR_IRQS];
*/ */
asmlinkage unsigned int do_IRQ(unsigned int irq, struct pt_regs *regs) asmlinkage unsigned int do_IRQ(unsigned int irq, struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
irq_enter(); irq_enter();
__DO_IRQ_SMTC_HOOK(); __DO_IRQ_SMTC_HOOK();
__do_IRQ(irq, regs); __do_IRQ(irq);
irq_exit(); irq_exit();
set_irq_regs(old_regs);
return 1; return 1;
} }

24
arch/mips/kernel/time.c
View file

@ -322,18 +322,18 @@ static long last_rtc_update;
* a broadcasted inter-processor interrupt which itself is triggered * a broadcasted inter-processor interrupt which itself is triggered
* by the global timer interrupt. * by the global timer interrupt.
*/ */
void local_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) void local_timer_interrupt(int irq, void *dev_id)
{ {
if (current->pid) if (current->pid)
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
update_process_times(user_mode(regs)); update_process_times(user_mode(get_irq_regs()));
} }
/* /*
* High-level timer interrupt service routines. This function * High-level timer interrupt service routines. This function
* is set as irqaction->handler and is invoked through do_IRQ. * is set as irqaction->handler and is invoked through do_IRQ.
*/ */
irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) irqreturn_t timer_interrupt(int irq, void *dev_id)
{ {
unsigned long j; unsigned long j;
unsigned int count; unsigned int count;
@ -419,23 +419,24 @@ irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
* In SMP mode, local_timer_interrupt() is invoked by appropriate * In SMP mode, local_timer_interrupt() is invoked by appropriate
* low-level local timer interrupt handler. * low-level local timer interrupt handler.
*/ */
local_timer_interrupt(irq, dev_id, regs); local_timer_interrupt(irq, dev_id);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
int null_perf_irq(struct pt_regs *regs) int null_perf_irq(void)
{ {
return 0; return 0;
} }
int (*perf_irq)(struct pt_regs *regs) = null_perf_irq; int (*perf_irq)(void) = null_perf_irq;
EXPORT_SYMBOL(null_perf_irq); EXPORT_SYMBOL(null_perf_irq);
EXPORT_SYMBOL(perf_irq); EXPORT_SYMBOL(perf_irq);
asmlinkage void ll_timer_interrupt(int irq, struct pt_regs *regs) asmlinkage void ll_timer_interrupt(int irq, struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
int r2 = cpu_has_mips_r2; int r2 = cpu_has_mips_r2;
irq_enter(); irq_enter();
@ -448,27 +449,30 @@ asmlinkage void ll_timer_interrupt(int irq, struct pt_regs *regs)
* performance counter interrupt handler anyway. * performance counter interrupt handler anyway.
*/ */
if (!r2 || (read_c0_cause() & (1 << 26))) if (!r2 || (read_c0_cause() & (1 << 26)))
if (perf_irq(regs)) if (perf_irq())
goto out; goto out;
/* we keep interrupt disabled all the time */ /* we keep interrupt disabled all the time */
if (!r2 || (read_c0_cause() & (1 << 30))) if (!r2 || (read_c0_cause() & (1 << 30)))
timer_interrupt(irq, NULL, regs); timer_interrupt(irq, NULL);
out: out:
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
asmlinkage void ll_local_timer_interrupt(int irq, struct pt_regs *regs) asmlinkage void ll_local_timer_interrupt(int irq, struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
irq_enter(); irq_enter();
if (smp_processor_id() != 0) if (smp_processor_id() != 0)
kstat_this_cpu.irqs[irq]++; kstat_this_cpu.irqs[irq]++;
/* we keep interrupt disabled all the time */ /* we keep interrupt disabled all the time */
local_timer_interrupt(irq, NULL, regs); local_timer_interrupt(irq, NULL);
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
/* /*

2
arch/mips/sgi-ip22/ip22-reset.c
View file

@ -169,7 +169,7 @@ static inline void volume_down_button(unsigned long data)
} }
} }
static irqreturn_t panel_int(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t panel_int(int irq, void *dev_id)
{ {
unsigned int buttons; unsigned int buttons;

4
arch/mips/sgi-ip22/ip22-time.c
View file

@ -191,12 +191,14 @@ void indy_8254timer_irq(struct pt_regs *regs)
void indy_r4k_timer_interrupt(struct pt_regs *regs) void indy_r4k_timer_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
int irq = SGI_TIMER_IRQ; int irq = SGI_TIMER_IRQ;
irq_enter(); irq_enter();
kstat_this_cpu.irqs[irq]++; kstat_this_cpu.irqs[irq]++;
timer_interrupt(irq, NULL, regs); timer_interrupt(irq, NULL);
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
void __init plat_timer_setup(struct irqaction *irq) void __init plat_timer_setup(struct irqaction *irq)

6
arch/powerpc/kernel/irq.c
View file

@ -187,6 +187,7 @@ void fixup_irqs(cpumask_t map)
void do_IRQ(struct pt_regs *regs) void do_IRQ(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
unsigned int irq; unsigned int irq;
#ifdef CONFIG_IRQSTACKS #ifdef CONFIG_IRQSTACKS
struct thread_info *curtp, *irqtp; struct thread_info *curtp, *irqtp;
@ -230,18 +231,19 @@ void do_IRQ(struct pt_regs *regs)
handler = &__do_IRQ; handler = &__do_IRQ;
irqtp->task = curtp->task; irqtp->task = curtp->task;
irqtp->flags = 0; irqtp->flags = 0;
call_handle_irq(irq, desc, regs, irqtp, handler); call_handle_irq(irq, desc, irqtp, handler);
irqtp->task = NULL; irqtp->task = NULL;
if (irqtp->flags) if (irqtp->flags)
set_bits(irqtp->flags, &curtp->flags); set_bits(irqtp->flags, &curtp->flags);
} else } else
#endif #endif
generic_handle_irq(irq, regs); generic_handle_irq(irq);
} else if (irq != NO_IRQ_IGNORE) } else if (irq != NO_IRQ_IGNORE)
/* That's not SMP safe ... but who cares ? */ /* That's not SMP safe ... but who cares ? */
ppc_spurious_interrupts++; ppc_spurious_interrupts++;
irq_exit(); irq_exit();
set_irq_regs(old_regs);
#ifdef CONFIG_PPC_ISERIES #ifdef CONFIG_PPC_ISERIES
if (get_lppaca()->int_dword.fields.decr_int) { if (get_lppaca()->int_dword.fields.decr_int) {

6
arch/powerpc/kernel/misc_64.S
View file

@ -52,12 +52,12 @@ _GLOBAL(call_do_softirq)
blr blr
_GLOBAL(call_handle_irq) _GLOBAL(call_handle_irq)
ld r8,0(r7) ld r8,0(r6)
mflr r0 mflr r0
std r0,16(r1) std r0,16(r1)
mtctr r8 mtctr r8
stdu r1,THREAD_SIZE-112(r6) stdu r1,THREAD_SIZE-112(r5)
mr r1,r6 mr r1,r5
bctrl bctrl
ld r1,0(r1) ld r1,0(r1)
ld r0,16(r1) ld r0,16(r1)

6
arch/powerpc/kernel/smp.c
View file

@ -115,7 +115,7 @@ void __devinit smp_generic_kick_cpu(int nr)
} }
#endif #endif
void smp_message_recv(int msg, struct pt_regs *regs) void smp_message_recv(int msg)
{ {
switch(msg) { switch(msg) {
case PPC_MSG_CALL_FUNCTION: case PPC_MSG_CALL_FUNCTION:
@ -127,11 +127,11 @@ void smp_message_recv(int msg, struct pt_regs *regs)
break; break;
case PPC_MSG_DEBUGGER_BREAK: case PPC_MSG_DEBUGGER_BREAK:
if (crash_ipi_function_ptr) { if (crash_ipi_function_ptr) {
crash_ipi_function_ptr(regs); crash_ipi_function_ptr(get_irq_regs());
break; break;
} }
#ifdef CONFIG_DEBUGGER #ifdef CONFIG_DEBUGGER
debugger_ipi(regs); debugger_ipi(get_irq_regs());
break; break;
#endif /* CONFIG_DEBUGGER */ #endif /* CONFIG_DEBUGGER */
/* FALLTHROUGH */ /* FALLTHROUGH */

6
arch/powerpc/kernel/time.c
View file

@ -51,6 +51,7 @@
#include <linux/rtc.h> #include <linux/rtc.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/posix-timers.h> #include <linux/posix-timers.h>
#include <linux/irq.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/processor.h> #include <asm/processor.h>
@ -643,6 +644,7 @@ static void iSeries_tb_recal(void)
*/ */
void timer_interrupt(struct pt_regs * regs) void timer_interrupt(struct pt_regs * regs)
{ {
struct pt_regs *old_regs;
int next_dec; int next_dec;
int cpu = smp_processor_id(); int cpu = smp_processor_id();
unsigned long ticks; unsigned long ticks;
@ -653,9 +655,10 @@ void timer_interrupt(struct pt_regs * regs)
do_IRQ(regs); do_IRQ(regs);
#endif #endif
old_regs = set_irq_regs(regs);
irq_enter(); irq_enter();
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
calculate_steal_time(); calculate_steal_time();
#ifdef CONFIG_PPC_ISERIES #ifdef CONFIG_PPC_ISERIES
@ -715,6 +718,7 @@ void timer_interrupt(struct pt_regs * regs)
#endif #endif
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
void wakeup_decrementer(void) void wakeup_decrementer(void)

4
arch/powerpc/platforms/cell/interrupt.c
View file

@ -190,11 +190,11 @@ struct irq_host *iic_get_irq_host(int node)
EXPORT_SYMBOL_GPL(iic_get_irq_host); EXPORT_SYMBOL_GPL(iic_get_irq_host);
static irqreturn_t iic_ipi_action(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t iic_ipi_action(int irq, void *dev_id)
{ {
int ipi = (int)(long)dev_id; int ipi = (int)(long)dev_id;
smp_message_recv(ipi, regs); smp_message_recv(ipi);
return IRQ_HANDLED; return IRQ_HANDLED;
} }

5
arch/powerpc/platforms/cell/spider-pic.c
View file

@ -213,8 +213,7 @@ static struct irq_host_ops spider_host_ops = {
.xlate = spider_host_xlate, .xlate = spider_host_xlate,
}; };
static void spider_irq_cascade(unsigned int irq, struct irq_desc *desc, static void spider_irq_cascade(unsigned int irq, struct irq_desc *desc)
struct pt_regs *regs)
{ {
struct spider_pic *pic = desc->handler_data; struct spider_pic *pic = desc->handler_data;
unsigned int cs, virq; unsigned int cs, virq;
@ -225,7 +224,7 @@ static void spider_irq_cascade(unsigned int irq, struct irq_desc *desc,
else else
virq = irq_linear_revmap(pic->host, cs); virq = irq_linear_revmap(pic->host, cs);
if (virq != NO_IRQ) if (virq != NO_IRQ)
generic_handle_irq(virq, regs); generic_handle_irq(virq);
desc->chip->eoi(irq); desc->chip->eoi(irq);
} }

2
arch/powerpc/platforms/powermac/low_i2c.c
View file

@ -342,7 +342,7 @@ static void kw_i2c_handle_interrupt(struct pmac_i2c_host_kw *host, u8 isr)
} }
/* Interrupt handler */ /* Interrupt handler */
static irqreturn_t kw_i2c_irq(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t kw_i2c_irq(int irq, void *dev_id)
{ {
struct pmac_i2c_host_kw *host = dev_id; struct pmac_i2c_host_kw *host = dev_id;
unsigned long flags; unsigned long flags;

2
arch/powerpc/platforms/powermac/pfunc_base.c
View file

@ -15,7 +15,7 @@
#define DBG(fmt...) #define DBG(fmt...)
#endif #endif
static irqreturn_t macio_gpio_irq(int irq, void *data, struct pt_regs *regs) static irqreturn_t macio_gpio_irq(int irq, void *data)
{ {
pmf_do_irq(data); pmf_do_irq(data);

7
arch/powerpc/platforms/powermac/pic.c
View file

@ -440,14 +440,13 @@ static void __init pmac_pic_probe_oldstyle(void)
} }
#endif /* CONFIG_PPC32 */ #endif /* CONFIG_PPC32 */
static void pmac_u3_cascade(unsigned int irq, struct irq_desc *desc, static void pmac_u3_cascade(unsigned int irq, struct irq_desc *desc)
struct pt_regs *regs)
{ {
struct mpic *mpic = desc->handler_data; struct mpic *mpic = desc->handler_data;
unsigned int cascade_irq = mpic_get_one_irq(mpic, regs); unsigned int cascade_irq = mpic_get_one_irq(mpic, get_irq_regs());
if (cascade_irq != NO_IRQ) if (cascade_irq != NO_IRQ)
generic_handle_irq(cascade_irq, regs); generic_handle_irq(cascade_irq);
desc->chip->eoi(irq); desc->chip->eoi(irq);
} }

14
arch/powerpc/platforms/pseries/ras.c
View file

@ -65,16 +65,14 @@ static int ras_check_exception_token;
#define EPOW_SENSOR_INDEX 0 #define EPOW_SENSOR_INDEX 0
#define RAS_VECTOR_OFFSET 0x500 #define RAS_VECTOR_OFFSET 0x500
static irqreturn_t ras_epow_interrupt(int irq, void *dev_id, static irqreturn_t ras_epow_interrupt(int irq, void *dev_id);
struct pt_regs * regs); static irqreturn_t ras_error_interrupt(int irq, void *dev_id);
static irqreturn_t ras_error_interrupt(int irq, void *dev_id,
struct pt_regs * regs);
/* #define DEBUG */ /* #define DEBUG */
static void request_ras_irqs(struct device_node *np, static void request_ras_irqs(struct device_node *np,
irqreturn_t (*handler)(int, void *, struct pt_regs *), irq_handler_t handler,
const char *name) const char *name)
{ {
int i, index, count = 0; int i, index, count = 0;
@ -166,8 +164,7 @@ __initcall(init_ras_IRQ);
* to examine the type of power failure and take appropriate action where * to examine the type of power failure and take appropriate action where
* the time horizon permits something useful to be done. * the time horizon permits something useful to be done.
*/ */
static irqreturn_t static irqreturn_t ras_epow_interrupt(int irq, void *dev_id)
ras_epow_interrupt(int irq, void *dev_id, struct pt_regs * regs)
{ {
int status = 0xdeadbeef; int status = 0xdeadbeef;
int state = 0; int state = 0;
@ -210,8 +207,7 @@ ras_epow_interrupt(int irq, void *dev_id, struct pt_regs * regs)
* For nonrecoverable errors, an error is logged and we stop all processing * For nonrecoverable errors, an error is logged and we stop all processing
* as quickly as possible in order to prevent propagation of the failure. * as quickly as possible in order to prevent propagation of the failure.
*/ */
static irqreturn_t static irqreturn_t ras_error_interrupt(int irq, void *dev_id)
ras_error_interrupt(int irq, void *dev_id, struct pt_regs * regs)
{ {
struct rtas_error_log *rtas_elog; struct rtas_error_log *rtas_elog;
int status = 0xdeadbeef; int status = 0xdeadbeef;

7
arch/powerpc/platforms/pseries/setup.c
View file

@ -121,12 +121,11 @@ static void __init fwnmi_init(void)
fwnmi_active = 1; fwnmi_active = 1;
} }
void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc, void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc)
struct pt_regs *regs)
{ {
unsigned int cascade_irq = i8259_irq(regs); unsigned int cascade_irq = i8259_irq(get_irq_regs());
if (cascade_irq != NO_IRQ) if (cascade_irq != NO_IRQ)
generic_handle_irq(cascade_irq, regs); generic_handle_irq(cascade_irq);
desc->chip->eoi(irq); desc->chip->eoi(irq);
} }

18
arch/powerpc/platforms/pseries/xics.c
View file

@ -324,7 +324,7 @@ static unsigned int xics_get_irq_lpar(struct pt_regs *regs)
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
static irqreturn_t xics_ipi_dispatch(int cpu, struct pt_regs *regs) static irqreturn_t xics_ipi_dispatch(int cpu)
{ {
WARN_ON(cpu_is_offline(cpu)); WARN_ON(cpu_is_offline(cpu));
@ -332,47 +332,47 @@ static irqreturn_t xics_ipi_dispatch(int cpu, struct pt_regs *regs)
if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION, if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION,
&xics_ipi_message[cpu].value)) { &xics_ipi_message[cpu].value)) {
mb(); mb();
smp_message_recv(PPC_MSG_CALL_FUNCTION, regs); smp_message_recv(PPC_MSG_CALL_FUNCTION);
} }
if (test_and_clear_bit(PPC_MSG_RESCHEDULE, if (test_and_clear_bit(PPC_MSG_RESCHEDULE,
&xics_ipi_message[cpu].value)) { &xics_ipi_message[cpu].value)) {
mb(); mb();
smp_message_recv(PPC_MSG_RESCHEDULE, regs); smp_message_recv(PPC_MSG_RESCHEDULE);
} }
#if 0 #if 0
if (test_and_clear_bit(PPC_MSG_MIGRATE_TASK, if (test_and_clear_bit(PPC_MSG_MIGRATE_TASK,
&xics_ipi_message[cpu].value)) { &xics_ipi_message[cpu].value)) {
mb(); mb();
smp_message_recv(PPC_MSG_MIGRATE_TASK, regs); smp_message_recv(PPC_MSG_MIGRATE_TASK);
} }
#endif #endif
#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC) #if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
if (test_and_clear_bit(PPC_MSG_DEBUGGER_BREAK, if (test_and_clear_bit(PPC_MSG_DEBUGGER_BREAK,
&xics_ipi_message[cpu].value)) { &xics_ipi_message[cpu].value)) {
mb(); mb();
smp_message_recv(PPC_MSG_DEBUGGER_BREAK, regs); smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
} }
#endif #endif
} }
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t xics_ipi_action_direct(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t xics_ipi_action_direct(int irq, void *dev_id)
{ {
int cpu = smp_processor_id(); int cpu = smp_processor_id();
direct_qirr_info(cpu, 0xff); direct_qirr_info(cpu, 0xff);
return xics_ipi_dispatch(cpu, regs); return xics_ipi_dispatch(cpu);
} }
static irqreturn_t xics_ipi_action_lpar(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t xics_ipi_action_lpar(int irq, void *dev_id)
{ {
int cpu = smp_processor_id(); int cpu = smp_processor_id();
lpar_qirr_info(cpu, 0xff); lpar_qirr_info(cpu, 0xff);
return xics_ipi_dispatch(cpu, regs); return xics_ipi_dispatch(cpu);
} }
void xics_cause_IPI(int cpu) void xics_cause_IPI(int cpu)

3
arch/powerpc/platforms/pseries/xics.h
View file

@ -31,7 +31,6 @@ struct xics_ipi_struct {
extern struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned; extern struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned;
struct irq_desc; struct irq_desc;
extern void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc, extern void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc);
struct pt_regs *regs);
#endif /* _POWERPC_KERNEL_XICS_H */ #endif /* _POWERPC_KERNEL_XICS_H */

4
arch/powerpc/sysdev/mpic.c
View file

@ -489,9 +489,9 @@ static inline void mpic_eoi(struct mpic *mpic)
} }
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
static irqreturn_t mpic_ipi_action(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t mpic_ipi_action(int irq, void *dev_id)
{ {
smp_message_recv(mpic_irq_to_hw(irq) - MPIC_VEC_IPI_0, regs); smp_message_recv(mpic_irq_to_hw(irq) - MPIC_VEC_IPI_0);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
#endif /* CONFIG_SMP */ #endif /* CONFIG_SMP */

6
arch/powerpc/xmon/xmon.c
View file

@ -21,6 +21,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/sysrq.h> #include <linux/sysrq.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/irq.h>
#include <asm/ptrace.h> #include <asm/ptrace.h>
#include <asm/string.h> #include <asm/string.h>
@ -2577,12 +2578,11 @@ void xmon_init(int enable)
} }
#ifdef CONFIG_MAGIC_SYSRQ #ifdef CONFIG_MAGIC_SYSRQ
static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs, static void sysrq_handle_xmon(int key, struct tty_struct *tty)
struct tty_struct *tty)
{ {
/* ensure xmon is enabled */ /* ensure xmon is enabled */
xmon_init(1); xmon_init(1);
debugger(pt_regs); debugger(get_irq_regs());
} }
static struct sysrq_key_op sysrq_xmon_op = static struct sysrq_key_op sysrq_xmon_op =

12
arch/x86_64/kernel/apic.c
View file

@ -885,14 +885,14 @@ void setup_APIC_extened_lvt(unsigned char lvt_off, unsigned char vector,
* value into /proc/profile. * value into /proc/profile.
*/ */
void smp_local_timer_interrupt(struct pt_regs *regs) void smp_local_timer_interrupt(void)
{ {
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
update_process_times(user_mode(regs)); update_process_times(user_mode(get_irq_regs()));
#endif #endif
if (apic_runs_main_timer > 1 && smp_processor_id() == boot_cpu_id) if (apic_runs_main_timer > 1 && smp_processor_id() == boot_cpu_id)
main_timer_handler(regs); main_timer_handler();
/* /*
* We take the 'long' return path, and there every subsystem * We take the 'long' return path, and there every subsystem
* grabs the appropriate locks (kernel lock/ irq lock). * grabs the appropriate locks (kernel lock/ irq lock).
@ -913,7 +913,7 @@ void smp_local_timer_interrupt(struct pt_regs *regs)
* [ if a single-CPU system runs an SMP kernel then we call the local * [ if a single-CPU system runs an SMP kernel then we call the local
* interrupt as well. Thus we cannot inline the local irq ... ] * interrupt as well. Thus we cannot inline the local irq ... ]
*/ */
void smp_apic_timer_interrupt(struct pt_regs *regs) void smp_apic_timer_interrupt(void)
{ {
/* /*
* the NMI deadlock-detector uses this. * the NMI deadlock-detector uses this.
@ -932,7 +932,7 @@ void smp_apic_timer_interrupt(struct pt_regs *regs)
*/ */
exit_idle(); exit_idle();
irq_enter(); irq_enter();
smp_local_timer_interrupt(regs); smp_local_timer_interrupt();
irq_exit(); irq_exit();
} }

5
arch/x86_64/kernel/irq.c
View file

@ -104,6 +104,8 @@ int show_interrupts(struct seq_file *p, void *v)
*/ */
asmlinkage unsigned int do_IRQ(struct pt_regs *regs) asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
{ {
struct pt_regs *old_regs = set_irq_regs(regs);
/* high bit used in ret_from_ code */ /* high bit used in ret_from_ code */
unsigned vector = ~regs->orig_rax; unsigned vector = ~regs->orig_rax;
unsigned irq; unsigned irq;
@ -121,9 +123,10 @@ asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
#ifdef CONFIG_DEBUG_STACKOVERFLOW #ifdef CONFIG_DEBUG_STACKOVERFLOW
stack_overflow_check(regs); stack_overflow_check(regs);
#endif #endif
generic_handle_irq(irq, regs); generic_handle_irq(irq);
irq_exit(); irq_exit();
set_irq_regs(old_regs);
return 1; return 1;
} }

20
arch/x86_64/kernel/time.c
View file

@ -302,20 +302,20 @@ unsigned long long monotonic_clock(void)
} }
EXPORT_SYMBOL(monotonic_clock); EXPORT_SYMBOL(monotonic_clock);
static noinline void handle_lost_ticks(int lost, struct pt_regs *regs) static noinline void handle_lost_ticks(int lost)
{ {
static long lost_count; static long lost_count;
static int warned; static int warned;
if (report_lost_ticks) { if (report_lost_ticks) {
printk(KERN_WARNING "time.c: Lost %d timer tick(s)! ", lost); printk(KERN_WARNING "time.c: Lost %d timer tick(s)! ", lost);
print_symbol("rip %s)\n", regs->rip); print_symbol("rip %s)\n", get_irq_regs()->rip);
} }
if (lost_count == 1000 && !warned) { if (lost_count == 1000 && !warned) {
printk(KERN_WARNING "warning: many lost ticks.\n" printk(KERN_WARNING "warning: many lost ticks.\n"
KERN_WARNING "Your time source seems to be instable or " KERN_WARNING "Your time source seems to be instable or "
"some driver is hogging interupts\n"); "some driver is hogging interupts\n");
print_symbol("rip %s\n", regs->rip); print_symbol("rip %s\n", get_irq_regs()->rip);
if (vxtime.mode == VXTIME_TSC && vxtime.hpet_address) { if (vxtime.mode == VXTIME_TSC && vxtime.hpet_address) {
printk(KERN_WARNING "Falling back to HPET\n"); printk(KERN_WARNING "Falling back to HPET\n");
if (hpet_use_timer) if (hpet_use_timer)
@ -339,7 +339,7 @@ static noinline void handle_lost_ticks(int lost, struct pt_regs *regs)
#endif #endif
} }
void main_timer_handler(struct pt_regs *regs) void main_timer_handler(void)
{ {
static unsigned long rtc_update = 0; static unsigned long rtc_update = 0;
unsigned long tsc; unsigned long tsc;
@ -411,7 +411,7 @@ void main_timer_handler(struct pt_regs *regs)
} }
if (lost > 0) if (lost > 0)
handle_lost_ticks(lost, regs); handle_lost_ticks(lost);
else else
lost = 0; lost = 0;
@ -421,7 +421,7 @@ void main_timer_handler(struct pt_regs *regs)
do_timer(lost + 1); do_timer(lost + 1);
#ifndef CONFIG_SMP #ifndef CONFIG_SMP
update_process_times(user_mode(regs)); update_process_times(user_mode(get_irq_regs()));
#endif #endif
/* /*
@ -431,7 +431,7 @@ void main_timer_handler(struct pt_regs *regs)
*/ */
if (!using_apic_timer) if (!using_apic_timer)
smp_local_timer_interrupt(regs); smp_local_timer_interrupt();
/* /*
* If we have an externally synchronized Linux clock, then update CMOS clock * If we have an externally synchronized Linux clock, then update CMOS clock
@ -450,11 +450,11 @@ void main_timer_handler(struct pt_regs *regs)
write_sequnlock(&xtime_lock); write_sequnlock(&xtime_lock);
} }
static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t timer_interrupt(int irq, void *dev_id)
{ {
if (apic_runs_main_timer > 1) if (apic_runs_main_timer > 1)
return IRQ_HANDLED; return IRQ_HANDLED;
main_timer_handler(regs); main_timer_handler();
if (using_apic_timer) if (using_apic_timer)
smp_send_timer_broadcast_ipi(); smp_send_timer_broadcast_ipi();
return IRQ_HANDLED; return IRQ_HANDLED;
@ -1337,7 +1337,7 @@ irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
} }
if (call_rtc_interrupt) { if (call_rtc_interrupt) {
rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8)); rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
rtc_interrupt(rtc_int_flag, dev_id, regs); rtc_interrupt(rtc_int_flag, dev_id);
} }
return IRQ_HANDLED; return IRQ_HANDLED;
} }

2
drivers/acorn/block/mfmhd.c
View file

@ -938,7 +938,7 @@ static void do_mfm_request(request_queue_t *q)
mfm_request(); mfm_request();
} }
static void mfm_interrupt_handler(int unused, void *dev_id, struct pt_regs *regs) static void mfm_interrupt_handler(int unused, void *dev_id)
{ {
void (*handler) (void) = do_mfm; void (*handler) (void) = do_mfm;

2
drivers/acpi/osl.c
View file

@ -237,7 +237,7 @@ acpi_os_table_override(struct acpi_table_header * existing_table,
return AE_OK; return AE_OK;
} }
static irqreturn_t acpi_irq(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t acpi_irq(int irq, void *dev_id)
{ {
return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE; return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE;
} }

4
drivers/ata/ahci.c
View file

@ -204,7 +204,7 @@ static u32 ahci_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void ahci_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val); static void ahci_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent); static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc); static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *regs); static irqreturn_t ahci_interrupt (int irq, void *dev_instance);
static void ahci_irq_clear(struct ata_port *ap); static void ahci_irq_clear(struct ata_port *ap);
static int ahci_port_start(struct ata_port *ap); static int ahci_port_start(struct ata_port *ap);
static void ahci_port_stop(struct ata_port *ap); static void ahci_port_stop(struct ata_port *ap);
@ -1059,7 +1059,7 @@ static void ahci_irq_clear(struct ata_port *ap)
/* TODO */ /* TODO */
} }
static irqreturn_t ahci_interrupt(int irq, void *dev_instance, struct pt_regs *regs) static irqreturn_t ahci_interrupt(int irq, void *dev_instance)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
struct ahci_host_priv *hpriv; struct ahci_host_priv *hpriv;

3
drivers/ata/libata-core.c
View file

@ -4857,7 +4857,6 @@ inline unsigned int ata_host_intr (struct ata_port *ap,
* ata_interrupt - Default ATA host interrupt handler * ata_interrupt - Default ATA host interrupt handler
* @irq: irq line (unused) * @irq: irq line (unused)
* @dev_instance: pointer to our ata_host information structure * @dev_instance: pointer to our ata_host information structure
* @regs: unused
* *
* Default interrupt handler for PCI IDE devices. Calls * Default interrupt handler for PCI IDE devices. Calls
* ata_host_intr() for each port that is not disabled. * ata_host_intr() for each port that is not disabled.
@ -4869,7 +4868,7 @@ inline unsigned int ata_host_intr (struct ata_port *ap,
* IRQ_NONE or IRQ_HANDLED. * IRQ_NONE or IRQ_HANDLED.
*/ */
irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs) irqreturn_t ata_interrupt (int irq, void *dev_instance)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
unsigned int i; unsigned int i;

5
drivers/ata/pdc_adma.c
View file

@ -124,8 +124,7 @@ struct adma_port_priv {
static int adma_ata_init_one (struct pci_dev *pdev, static int adma_ata_init_one (struct pci_dev *pdev,
const struct pci_device_id *ent); const struct pci_device_id *ent);
static irqreturn_t adma_intr (int irq, void *dev_instance, static irqreturn_t adma_intr (int irq, void *dev_instance);
struct pt_regs *regs);
static int adma_port_start(struct ata_port *ap); static int adma_port_start(struct ata_port *ap);
static void adma_host_stop(struct ata_host *host); static void adma_host_stop(struct ata_host *host);
static void adma_port_stop(struct ata_port *ap); static void adma_port_stop(struct ata_port *ap);
@ -508,7 +507,7 @@ static inline unsigned int adma_intr_mmio(struct ata_host *host)
return handled; return handled;
} }
static irqreturn_t adma_intr(int irq, void *dev_instance, struct pt_regs *regs) static irqreturn_t adma_intr(int irq, void *dev_instance)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
unsigned int handled = 0; unsigned int handled = 0;

6
drivers/ata/sata_mv.c
View file

@ -348,8 +348,7 @@ static void mv_port_stop(struct ata_port *ap);
static void mv_qc_prep(struct ata_queued_cmd *qc); static void mv_qc_prep(struct ata_queued_cmd *qc);
static void mv_qc_prep_iie(struct ata_queued_cmd *qc); static void mv_qc_prep_iie(struct ata_queued_cmd *qc);
static unsigned int mv_qc_issue(struct ata_queued_cmd *qc); static unsigned int mv_qc_issue(struct ata_queued_cmd *qc);
static irqreturn_t mv_interrupt(int irq, void *dev_instance, static irqreturn_t mv_interrupt(int irq, void *dev_instance);
struct pt_regs *regs);
static void mv_eng_timeout(struct ata_port *ap); static void mv_eng_timeout(struct ata_port *ap);
static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent); static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
@ -1448,8 +1447,7 @@ static void mv_host_intr(struct ata_host *host, u32 relevant, unsigned int hc)
* This routine holds the host lock while processing pending * This routine holds the host lock while processing pending
* interrupts. * interrupts.
*/ */
static irqreturn_t mv_interrupt(int irq, void *dev_instance, static irqreturn_t mv_interrupt(int irq, void *dev_instance)
struct pt_regs *regs)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
unsigned int hc, handled = 0, n_hcs; unsigned int hc, handled = 0, n_hcs;

18
drivers/ata/sata_nv.c
View file

@ -82,12 +82,9 @@ enum {
static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent); static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
static void nv_ck804_host_stop(struct ata_host *host); static void nv_ck804_host_stop(struct ata_host *host);
static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance, static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance);
struct pt_regs *regs); static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance);
static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance, static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance);
struct pt_regs *regs);
static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance,
struct pt_regs *regs);
static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg); static u32 nv_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val); static void nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
@ -276,8 +273,7 @@ MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, nv_pci_tbl); MODULE_DEVICE_TABLE(pci, nv_pci_tbl);
MODULE_VERSION(DRV_VERSION); MODULE_VERSION(DRV_VERSION);
static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance, static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
struct pt_regs *regs)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
unsigned int i; unsigned int i;
@ -357,8 +353,7 @@ static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
return IRQ_RETVAL(handled); return IRQ_RETVAL(handled);
} }
static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance, static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance)
struct pt_regs *regs)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
u8 irq_stat; u8 irq_stat;
@ -372,8 +367,7 @@ static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance,
return ret; return ret;
} }
static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance, static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance)
struct pt_regs *regs)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
u8 irq_stat; u8 irq_stat;

4
drivers/ata/sata_promise.c
View file

@ -93,7 +93,7 @@ struct pdc_host_priv {
static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg); static u32 pdc_sata_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val); static void pdc_sata_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent); static int pdc_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
static irqreturn_t pdc_interrupt (int irq, void *dev_instance, struct pt_regs *regs); static irqreturn_t pdc_interrupt (int irq, void *dev_instance);
static void pdc_eng_timeout(struct ata_port *ap); static void pdc_eng_timeout(struct ata_port *ap);
static int pdc_port_start(struct ata_port *ap); static int pdc_port_start(struct ata_port *ap);
static void pdc_port_stop(struct ata_port *ap); static void pdc_port_stop(struct ata_port *ap);
@ -498,7 +498,7 @@ static void pdc_irq_clear(struct ata_port *ap)
readl(mmio + PDC_INT_SEQMASK); readl(mmio + PDC_INT_SEQMASK);
} }
static irqreturn_t pdc_interrupt (int irq, void *dev_instance, struct pt_regs *regs) static irqreturn_t pdc_interrupt (int irq, void *dev_instance)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
struct ata_port *ap; struct ata_port *ap;

4
drivers/ata/sata_qstor.c
View file

@ -114,7 +114,7 @@ struct qs_port_priv {
static u32 qs_scr_read (struct ata_port *ap, unsigned int sc_reg); static u32 qs_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void qs_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val); static void qs_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
static int qs_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent); static int qs_ata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
static irqreturn_t qs_intr (int irq, void *dev_instance, struct pt_regs *regs); static irqreturn_t qs_intr (int irq, void *dev_instance);
static int qs_port_start(struct ata_port *ap); static int qs_port_start(struct ata_port *ap);
static void qs_host_stop(struct ata_host *host); static void qs_host_stop(struct ata_host *host);
static void qs_port_stop(struct ata_port *ap); static void qs_port_stop(struct ata_port *ap);
@ -454,7 +454,7 @@ static inline unsigned int qs_intr_mmio(struct ata_host *host)
return handled; return handled;
} }
static irqreturn_t qs_intr(int irq, void *dev_instance, struct pt_regs *regs) static irqreturn_t qs_intr(int irq, void *dev_instance)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
unsigned int handled = 0; unsigned int handled = 0;

6
drivers/ata/sata_sil.c
View file

@ -116,8 +116,7 @@ static void sil_dev_config(struct ata_port *ap, struct ata_device *dev);
static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg); static u32 sil_scr_read (struct ata_port *ap, unsigned int sc_reg);
static void sil_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val); static void sil_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
static void sil_post_set_mode (struct ata_port *ap); static void sil_post_set_mode (struct ata_port *ap);
static irqreturn_t sil_interrupt(int irq, void *dev_instance, static irqreturn_t sil_interrupt(int irq, void *dev_instance);
struct pt_regs *regs);
static void sil_freeze(struct ata_port *ap); static void sil_freeze(struct ata_port *ap);
static void sil_thaw(struct ata_port *ap); static void sil_thaw(struct ata_port *ap);
@ -437,8 +436,7 @@ static void sil_host_intr(struct ata_port *ap, u32 bmdma2)
ata_port_freeze(ap); ata_port_freeze(ap);
} }
static irqreturn_t sil_interrupt(int irq, void *dev_instance, static irqreturn_t sil_interrupt(int irq, void *dev_instance)
struct pt_regs *regs)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
void __iomem *mmio_base = host->mmio_base; void __iomem *mmio_base = host->mmio_base;

4
drivers/ata/sata_sil24.c
View file

@ -330,7 +330,7 @@ static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
static void sil24_qc_prep(struct ata_queued_cmd *qc); static void sil24_qc_prep(struct ata_queued_cmd *qc);
static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc); static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
static void sil24_irq_clear(struct ata_port *ap); static void sil24_irq_clear(struct ata_port *ap);
static irqreturn_t sil24_interrupt(int irq, void *dev_instance, struct pt_regs *regs); static irqreturn_t sil24_interrupt(int irq, void *dev_instance);
static void sil24_freeze(struct ata_port *ap); static void sil24_freeze(struct ata_port *ap);
static void sil24_thaw(struct ata_port *ap); static void sil24_thaw(struct ata_port *ap);
static void sil24_error_handler(struct ata_port *ap); static void sil24_error_handler(struct ata_port *ap);
@ -870,7 +870,7 @@ static inline void sil24_host_intr(struct ata_port *ap)
slot_stat, ap->active_tag, ap->sactive); slot_stat, ap->active_tag, ap->sactive);
} }
static irqreturn_t sil24_interrupt(int irq, void *dev_instance, struct pt_regs *regs) static irqreturn_t sil24_interrupt(int irq, void *dev_instance)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
struct sil24_host_priv *hpriv = host->private_data; struct sil24_host_priv *hpriv = host->private_data;

4
drivers/ata/sata_sx4.c
View file

@ -152,7 +152,7 @@ struct pdc_host_priv {
static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent); static int pdc_sata_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance, struct pt_regs *regs); static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance);
static void pdc_eng_timeout(struct ata_port *ap); static void pdc_eng_timeout(struct ata_port *ap);
static void pdc_20621_phy_reset (struct ata_port *ap); static void pdc_20621_phy_reset (struct ata_port *ap);
static int pdc_port_start(struct ata_port *ap); static int pdc_port_start(struct ata_port *ap);
@ -788,7 +788,7 @@ static void pdc20621_irq_clear(struct ata_port *ap)
readl(mmio + PDC_20621_SEQMASK); readl(mmio + PDC_20621_SEQMASK);
} }
static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance, struct pt_regs *regs) static irqreturn_t pdc20621_interrupt (int irq, void *dev_instance)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
struct ata_port *ap; struct ata_port *ap;

3
drivers/ata/sata_vsc.c
View file

@ -203,8 +203,7 @@ static void vsc_sata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
* *
* Read the interrupt register and process for the devices that have them pending. * Read the interrupt register and process for the devices that have them pending.
*/ */
static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance, static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance)
struct pt_regs *regs)
{ {
struct ata_host *host = dev_instance; struct ata_host *host = dev_instance;
unsigned int i; unsigned int i;

4
drivers/atm/ambassador.c
View file

@ -861,10 +861,8 @@ static inline void interrupts_off (amb_dev * dev) {
/********** interrupt handling **********/ /********** interrupt handling **********/
static irqreturn_t interrupt_handler(int irq, void *dev_id, static irqreturn_t interrupt_handler(int irq, void *dev_id) {
struct pt_regs *pt_regs) {
amb_dev * dev = (amb_dev *) dev_id; amb_dev * dev = (amb_dev *) dev_id;
(void) pt_regs;
PRINTD (DBG_IRQ|DBG_FLOW, "interrupt_handler: %p", dev_id); PRINTD (DBG_IRQ|DBG_FLOW, "interrupt_handler: %p", dev_id);

2
drivers/atm/eni.c
View file

@ -1488,7 +1488,7 @@ static void bug_int(struct atm_dev *dev,unsigned long reason)
} }
static irqreturn_t eni_int(int irq,void *dev_id,struct pt_regs *regs) static irqreturn_t eni_int(int irq,void *dev_id)
{ {
struct atm_dev *dev; struct atm_dev *dev;
struct eni_dev *eni_dev; struct eni_dev *eni_dev;

2
drivers/atm/firestream.c
View file

@ -1546,7 +1546,7 @@ static void __devexit free_freepool (struct fs_dev *dev, struct freepool *fp)
static irqreturn_t fs_irq (int irq, void *dev_id, struct pt_regs * pt_regs) static irqreturn_t fs_irq (int irq, void *dev_id)
{ {
int i; int i;
u32 status; u32 status;

2
drivers/atm/fore200e.c
View file

@ -1328,7 +1328,7 @@ fore200e_irq(struct fore200e* fore200e)
static irqreturn_t static irqreturn_t
fore200e_interrupt(int irq, void* dev, struct pt_regs* regs) fore200e_interrupt(int irq, void* dev)
{ {
struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev); struct fore200e* fore200e = FORE200E_DEV((struct atm_dev*)dev);

4
drivers/atm/he.c
View file

@ -109,7 +109,7 @@ static int he_open(struct atm_vcc *vcc);
static void he_close(struct atm_vcc *vcc); static void he_close(struct atm_vcc *vcc);
static int he_send(struct atm_vcc *vcc, struct sk_buff *skb); static int he_send(struct atm_vcc *vcc, struct sk_buff *skb);
static int he_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg); static int he_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg);
static irqreturn_t he_irq_handler(int irq, void *dev_id, struct pt_regs *regs); static irqreturn_t he_irq_handler(int irq, void *dev_id);
static void he_tasklet(unsigned long data); static void he_tasklet(unsigned long data);
static int he_proc_read(struct atm_dev *dev,loff_t *pos,char *page); static int he_proc_read(struct atm_dev *dev,loff_t *pos,char *page);
static int he_start(struct atm_dev *dev); static int he_start(struct atm_dev *dev);
@ -2216,7 +2216,7 @@ he_tasklet(unsigned long data)
} }
static irqreturn_t static irqreturn_t
he_irq_handler(int irq, void *dev_id, struct pt_regs *regs) he_irq_handler(int irq, void *dev_id)
{ {
unsigned long flags; unsigned long flags;
struct he_dev *he_dev = (struct he_dev * )dev_id; struct he_dev *he_dev = (struct he_dev * )dev_id;

4
drivers/atm/horizon.c
View file

@ -1382,12 +1382,10 @@ static inline void rx_data_av_handler (hrz_dev * dev) {
/********** interrupt handler **********/ /********** interrupt handler **********/
static irqreturn_t interrupt_handler(int irq, void *dev_id, static irqreturn_t interrupt_handler(int irq, void *dev_id) {
struct pt_regs *pt_regs) {
hrz_dev * dev = (hrz_dev *) dev_id; hrz_dev * dev = (hrz_dev *) dev_id;
u32 int_source; u32 int_source;
unsigned int irq_ok; unsigned int irq_ok;
(void) pt_regs;
PRINTD (DBG_FLOW, "interrupt_handler: %p", dev_id); PRINTD (DBG_FLOW, "interrupt_handler: %p", dev_id);

2
drivers/atm/idt77252.c
View file

@ -2774,7 +2774,7 @@ idt77252_collect_stat(struct idt77252_dev *card)
} }
static irqreturn_t static irqreturn_t
idt77252_interrupt(int irq, void *dev_id, struct pt_regs *ptregs) idt77252_interrupt(int irq, void *dev_id)
{ {
struct idt77252_dev *card = dev_id; struct idt77252_dev *card = dev_id;
u32 stat; u32 stat;

2
drivers/atm/iphase.c
View file

@ -2195,7 +2195,7 @@ static int tx_init(struct atm_dev *dev)
return -ENOMEM; return -ENOMEM;
} }
static irqreturn_t ia_int(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t ia_int(int irq, void *dev_id)
{ {
struct atm_dev *dev; struct atm_dev *dev;
IADEV *iadev; IADEV *iadev;

4
drivers/atm/lanai.c
View file

@ -1890,12 +1890,12 @@ static inline void lanai_int_1(struct lanai_dev *lanai, u32 reason)
reg_write(lanai, ack, IntAck_Reg); reg_write(lanai, ack, IntAck_Reg);
} }
static irqreturn_t lanai_int(int irq, void *devid, struct pt_regs *regs) static irqreturn_t lanai_int(int irq, void *devid)
{ {
struct lanai_dev *lanai = (struct lanai_dev *) devid; struct lanai_dev *lanai = (struct lanai_dev *) devid;
u32 reason; u32 reason;
(void) irq; (void) regs; /* unused variables */ (void) irq; /* unused variables */
#ifdef USE_POWERDOWN #ifdef USE_POWERDOWN
/* /*

4
drivers/atm/nicstar.c
View file

@ -214,7 +214,7 @@ static void __devinit ns_init_card_error(ns_dev *card, int error);
static scq_info *get_scq(int size, u32 scd); static scq_info *get_scq(int size, u32 scd);
static void free_scq(scq_info *scq, struct atm_vcc *vcc); static void free_scq(scq_info *scq, struct atm_vcc *vcc);
static void push_rxbufs(ns_dev *, struct sk_buff *); static void push_rxbufs(ns_dev *, struct sk_buff *);
static irqreturn_t ns_irq_handler(int irq, void *dev_id, struct pt_regs *regs); static irqreturn_t ns_irq_handler(int irq, void *dev_id);
static int ns_open(struct atm_vcc *vcc); static int ns_open(struct atm_vcc *vcc);
static void ns_close(struct atm_vcc *vcc); static void ns_close(struct atm_vcc *vcc);
static void fill_tst(ns_dev *card, int n, vc_map *vc); static void fill_tst(ns_dev *card, int n, vc_map *vc);
@ -1194,7 +1194,7 @@ static void push_rxbufs(ns_dev *card, struct sk_buff *skb)
static irqreturn_t ns_irq_handler(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t ns_irq_handler(int irq, void *dev_id)
{ {
u32 stat_r; u32 stat_r;
ns_dev *card; ns_dev *card;

2
drivers/atm/zatm.c
View file

@ -1012,7 +1012,7 @@ static int start_tx(struct atm_dev *dev)
/*------------------------------- interrupts --------------------------------*/ /*------------------------------- interrupts --------------------------------*/
static irqreturn_t zatm_int(int irq,void *dev_id,struct pt_regs *regs) static irqreturn_t zatm_int(int irq,void *dev_id)
{ {
struct atm_dev *dev; struct atm_dev *dev;
struct zatm_dev *zatm_dev; struct zatm_dev *zatm_dev;

24
drivers/block/DAC960.c
View file

@ -2698,8 +2698,7 @@ DAC960_DetectController(struct pci_dev *PCI_Device,
{ {
struct DAC960_privdata *privdata = struct DAC960_privdata *privdata =
(struct DAC960_privdata *)entry->driver_data; (struct DAC960_privdata *)entry->driver_data;
irqreturn_t (*InterruptHandler)(int, void *, struct pt_regs *) = irq_handler_t InterruptHandler = privdata->InterruptHandler;
privdata->InterruptHandler;
unsigned int MemoryWindowSize = privdata->MemoryWindowSize; unsigned int MemoryWindowSize = privdata->MemoryWindowSize;
DAC960_Controller_T *Controller = NULL; DAC960_Controller_T *Controller = NULL;
unsigned char DeviceFunction = PCI_Device->devfn; unsigned char DeviceFunction = PCI_Device->devfn;
@ -5253,8 +5252,7 @@ static void DAC960_V2_ProcessCompletedCommand(DAC960_Command_T *Command)
*/ */
static irqreturn_t DAC960_GEM_InterruptHandler(int IRQ_Channel, static irqreturn_t DAC960_GEM_InterruptHandler(int IRQ_Channel,
void *DeviceIdentifier, void *DeviceIdentifier)
struct pt_regs *InterruptRegisters)
{ {
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier; DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress; void __iomem *ControllerBaseAddress = Controller->BaseAddress;
@ -5295,8 +5293,7 @@ static irqreturn_t DAC960_GEM_InterruptHandler(int IRQ_Channel,
*/ */
static irqreturn_t DAC960_BA_InterruptHandler(int IRQ_Channel, static irqreturn_t DAC960_BA_InterruptHandler(int IRQ_Channel,
void *DeviceIdentifier, void *DeviceIdentifier)
struct pt_regs *InterruptRegisters)
{ {
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier; DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress; void __iomem *ControllerBaseAddress = Controller->BaseAddress;
@ -5338,8 +5335,7 @@ static irqreturn_t DAC960_BA_InterruptHandler(int IRQ_Channel,
*/ */
static irqreturn_t DAC960_LP_InterruptHandler(int IRQ_Channel, static irqreturn_t DAC960_LP_InterruptHandler(int IRQ_Channel,
void *DeviceIdentifier, void *DeviceIdentifier)
struct pt_regs *InterruptRegisters)
{ {
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier; DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress; void __iomem *ControllerBaseAddress = Controller->BaseAddress;
@ -5381,8 +5377,7 @@ static irqreturn_t DAC960_LP_InterruptHandler(int IRQ_Channel,
*/ */
static irqreturn_t DAC960_LA_InterruptHandler(int IRQ_Channel, static irqreturn_t DAC960_LA_InterruptHandler(int IRQ_Channel,
void *DeviceIdentifier, void *DeviceIdentifier)
struct pt_regs *InterruptRegisters)
{ {
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier; DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress; void __iomem *ControllerBaseAddress = Controller->BaseAddress;
@ -5420,8 +5415,7 @@ static irqreturn_t DAC960_LA_InterruptHandler(int IRQ_Channel,
*/ */
static irqreturn_t DAC960_PG_InterruptHandler(int IRQ_Channel, static irqreturn_t DAC960_PG_InterruptHandler(int IRQ_Channel,
void *DeviceIdentifier, void *DeviceIdentifier)
struct pt_regs *InterruptRegisters)
{ {
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier; DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress; void __iomem *ControllerBaseAddress = Controller->BaseAddress;
@ -5459,8 +5453,7 @@ static irqreturn_t DAC960_PG_InterruptHandler(int IRQ_Channel,
*/ */
static irqreturn_t DAC960_PD_InterruptHandler(int IRQ_Channel, static irqreturn_t DAC960_PD_InterruptHandler(int IRQ_Channel,
void *DeviceIdentifier, void *DeviceIdentifier)
struct pt_regs *InterruptRegisters)
{ {
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier; DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress; void __iomem *ControllerBaseAddress = Controller->BaseAddress;
@ -5498,8 +5491,7 @@ static irqreturn_t DAC960_PD_InterruptHandler(int IRQ_Channel,
*/ */
static irqreturn_t DAC960_P_InterruptHandler(int IRQ_Channel, static irqreturn_t DAC960_P_InterruptHandler(int IRQ_Channel,
void *DeviceIdentifier, void *DeviceIdentifier)
struct pt_regs *InterruptRegisters)
{ {
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier; DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress; void __iomem *ControllerBaseAddress = Controller->BaseAddress;

14
drivers/block/DAC960.h
View file

@ -2175,7 +2175,7 @@ static char
struct DAC960_privdata { struct DAC960_privdata {
DAC960_HardwareType_T HardwareType; DAC960_HardwareType_T HardwareType;
DAC960_FirmwareType_T FirmwareType; DAC960_FirmwareType_T FirmwareType;
irqreturn_t (*InterruptHandler)(int, void *, struct pt_regs *); irq_handler_t InterruptHandler;
unsigned int MemoryWindowSize; unsigned int MemoryWindowSize;
}; };
@ -4412,12 +4412,12 @@ static void DAC960_FinalizeController(DAC960_Controller_T *);
static void DAC960_V1_QueueReadWriteCommand(DAC960_Command_T *); static void DAC960_V1_QueueReadWriteCommand(DAC960_Command_T *);
static void DAC960_V2_QueueReadWriteCommand(DAC960_Command_T *); static void DAC960_V2_QueueReadWriteCommand(DAC960_Command_T *);
static void DAC960_RequestFunction(struct request_queue *); static void DAC960_RequestFunction(struct request_queue *);
static irqreturn_t DAC960_BA_InterruptHandler(int, void *, struct pt_regs *); static irqreturn_t DAC960_BA_InterruptHandler(int, void *);
static irqreturn_t DAC960_LP_InterruptHandler(int, void *, struct pt_regs *); static irqreturn_t DAC960_LP_InterruptHandler(int, void *);
static irqreturn_t DAC960_LA_InterruptHandler(int, void *, struct pt_regs *); static irqreturn_t DAC960_LA_InterruptHandler(int, void *);
static irqreturn_t DAC960_PG_InterruptHandler(int, void *, struct pt_regs *); static irqreturn_t DAC960_PG_InterruptHandler(int, void *);
static irqreturn_t DAC960_PD_InterruptHandler(int, void *, struct pt_regs *); static irqreturn_t DAC960_PD_InterruptHandler(int, void *);
static irqreturn_t DAC960_P_InterruptHandler(int, void *, struct pt_regs *); static irqreturn_t DAC960_P_InterruptHandler(int, void *);
static void DAC960_V1_QueueMonitoringCommand(DAC960_Command_T *); static void DAC960_V1_QueueMonitoringCommand(DAC960_Command_T *);
static void DAC960_V2_QueueMonitoringCommand(DAC960_Command_T *); static void DAC960_V2_QueueMonitoringCommand(DAC960_Command_T *);
static void DAC960_MonitoringTimerFunction(unsigned long); static void DAC960_MonitoringTimerFunction(unsigned long);

4
drivers/block/acsi.c
View file

@ -346,7 +346,7 @@ static int acsicmd_dma( const char *cmd, char *buffer, int blocks, int
rwflag, int enable); rwflag, int enable);
static int acsi_reqsense( char *buffer, int targ, int lun); static int acsi_reqsense( char *buffer, int targ, int lun);
static void acsi_print_error(const unsigned char *errblk, struct acsi_info_struct *aip); static void acsi_print_error(const unsigned char *errblk, struct acsi_info_struct *aip);
static irqreturn_t acsi_interrupt (int irq, void *data, struct pt_regs *fp); static irqreturn_t acsi_interrupt (int irq, void *data);
static void unexpected_acsi_interrupt( void ); static void unexpected_acsi_interrupt( void );
static void bad_rw_intr( void ); static void bad_rw_intr( void );
static void read_intr( void ); static void read_intr( void );
@ -726,7 +726,7 @@ static void acsi_print_error(const unsigned char *errblk, struct acsi_info_struc
* *
*******************************************************************/ *******************************************************************/
static irqreturn_t acsi_interrupt(int irq, void *data, struct pt_regs *fp ) static irqreturn_t acsi_interrupt(int irq, void *data )
{ void (*acsi_irq_handler)(void) = do_acsi; { void (*acsi_irq_handler)(void) = do_acsi;

4
drivers/block/acsi_slm.c
View file

@ -246,7 +246,7 @@ static int slm_getstats( char *buffer, int device );
static ssize_t slm_read( struct file* file, char *buf, size_t count, loff_t static ssize_t slm_read( struct file* file, char *buf, size_t count, loff_t
*ppos ); *ppos );
static void start_print( int device ); static void start_print( int device );
static irqreturn_t slm_interrupt(int irc, void *data, struct pt_regs *fp); static irqreturn_t slm_interrupt(int irc, void *data);
static void slm_test_ready( unsigned long dummy ); static void slm_test_ready( unsigned long dummy );
static void set_dma_addr( unsigned long paddr ); static void set_dma_addr( unsigned long paddr );
static unsigned long get_dma_addr( void ); static unsigned long get_dma_addr( void );
@ -452,7 +452,7 @@ static void start_print( int device )
/* Only called when an error happened or at the end of a page */ /* Only called when an error happened or at the end of a page */
static irqreturn_t slm_interrupt(int irc, void *data, struct pt_regs *fp) static irqreturn_t slm_interrupt(int irc, void *data)
{ unsigned long addr; { unsigned long addr;
int stat; int stat;

4
drivers/block/amiflop.c
View file

@ -209,7 +209,7 @@ static int fd_device[4] = { 0, 0, 0, 0 };
/* Milliseconds timer */ /* Milliseconds timer */
static irqreturn_t ms_isr(int irq, void *dummy, struct pt_regs *fp) static irqreturn_t ms_isr(int irq, void *dummy)
{ {
ms_busy = -1; ms_busy = -1;
wake_up(&ms_wait); wake_up(&ms_wait);
@ -560,7 +560,7 @@ static unsigned long fd_get_drive_id(int drive)
return (id); return (id);
} }
static irqreturn_t fd_block_done(int irq, void *dummy, struct pt_regs *fp) static irqreturn_t fd_block_done(int irq, void *dummy)
{ {
if (block_flag) if (block_flag)
custom.dsklen = 0x4000; custom.dsklen = 0x4000;

4
drivers/block/ataflop.c
View file

@ -342,7 +342,7 @@ static void fd_select_drive( int drive );
static void fd_deselect( void ); static void fd_deselect( void );
static void fd_motor_off_timer( unsigned long dummy ); static void fd_motor_off_timer( unsigned long dummy );
static void check_change( unsigned long dummy ); static void check_change( unsigned long dummy );
static irqreturn_t floppy_irq (int irq, void *dummy, struct pt_regs *fp); static irqreturn_t floppy_irq (int irq, void *dummy);
static void fd_error( void ); static void fd_error( void );
static int do_format(int drive, int type, struct atari_format_descr *desc); static int do_format(int drive, int type, struct atari_format_descr *desc);
static void do_fd_action( int drive ); static void do_fd_action( int drive );
@ -573,7 +573,7 @@ static inline void copy_buffer(void *from, void *to)
static void (*FloppyIRQHandler)( int status ) = NULL; static void (*FloppyIRQHandler)( int status ) = NULL;
static irqreturn_t floppy_irq (int irq, void *dummy, struct pt_regs *fp) static irqreturn_t floppy_irq (int irq, void *dummy)
{ {
unsigned char status; unsigned char status;
void (*handler)( int ); void (*handler)( int );

6
drivers/block/cciss.c
View file

@ -130,7 +130,7 @@ static struct board_type products[] = {
static ctlr_info_t *hba[MAX_CTLR]; static ctlr_info_t *hba[MAX_CTLR];
static void do_cciss_request(request_queue_t *q); static void do_cciss_request(request_queue_t *q);
static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs); static irqreturn_t do_cciss_intr(int irq, void *dev_id);
static int cciss_open(struct inode *inode, struct file *filep); static int cciss_open(struct inode *inode, struct file *filep);
static int cciss_release(struct inode *inode, struct file *filep); static int cciss_release(struct inode *inode, struct file *filep);
static int cciss_ioctl(struct inode *inode, struct file *filep, static int cciss_ioctl(struct inode *inode, struct file *filep,
@ -2300,7 +2300,7 @@ static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use
#ifdef CONFIG_CISS_SCSI_TAPE #ifdef CONFIG_CISS_SCSI_TAPE
/* if we saved some commands for later, process them now. */ /* if we saved some commands for later, process them now. */
if (info_p->scsi_rejects.ncompletions > 0) if (info_p->scsi_rejects.ncompletions > 0)
do_cciss_intr(0, info_p, NULL); do_cciss_intr(0, info_p);
#endif #endif
cmd_free(info_p, c, 1); cmd_free(info_p, c, 1);
return status; return status;
@ -2652,7 +2652,7 @@ static inline long interrupt_not_for_us(ctlr_info_t *h)
#endif #endif
} }
static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t do_cciss_intr(int irq, void *dev_id)
{ {
ctlr_info_t *h = dev_id; ctlr_info_t *h = dev_id;
CommandList_struct *c; CommandList_struct *c;

4
drivers/block/cpqarray.c
View file

@ -169,7 +169,7 @@ static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c);
static inline void complete_buffers(struct bio *bio, int ok); static inline void complete_buffers(struct bio *bio, int ok);
static inline void complete_command(cmdlist_t *cmd, int timeout); static inline void complete_command(cmdlist_t *cmd, int timeout);
static irqreturn_t do_ida_intr(int irq, void *dev_id, struct pt_regs * regs); static irqreturn_t do_ida_intr(int irq, void *dev_id);
static void ida_timer(unsigned long tdata); static void ida_timer(unsigned long tdata);
static int ida_revalidate(struct gendisk *disk); static int ida_revalidate(struct gendisk *disk);
static int revalidate_allvol(ctlr_info_t *host); static int revalidate_allvol(ctlr_info_t *host);
@ -1042,7 +1042,7 @@ static inline void complete_command(cmdlist_t *cmd, int timeout)
* Find the command on the completion queue, remove it, tell the OS and * Find the command on the completion queue, remove it, tell the OS and
* try to queue up more IO * try to queue up more IO
*/ */
static irqreturn_t do_ida_intr(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t do_ida_intr(int irq, void *dev_id)
{ {
ctlr_info_t *h = dev_id; ctlr_info_t *h = dev_id;
cmdlist_t *c; cmdlist_t *c;

4
drivers/block/floppy.c
View file

@ -221,7 +221,7 @@ static DEFINE_SPINLOCK(floppy_lock);
static struct completion device_release; static struct completion device_release;
static unsigned short virtual_dma_port = 0x3f0; static unsigned short virtual_dma_port = 0x3f0;
irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs); irqreturn_t floppy_interrupt(int irq, void *dev_id);
static int set_dor(int fdc, char mask, char data); static int set_dor(int fdc, char mask, char data);
#define K_64 0x10000 /* 64KB */ #define K_64 0x10000 /* 64KB */
@ -1726,7 +1726,7 @@ static void print_result(char *message, int inr)
} }
/* interrupt handler. Note that this can be called externally on the Sparc */ /* interrupt handler. Note that this can be called externally on the Sparc */
irqreturn_t floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs) irqreturn_t floppy_interrupt(int irq, void *dev_id)
{ {
void (*handler) (void) = do_floppy; void (*handler) (void) = do_floppy;
int do_print; int do_print;

6
drivers/block/ps2esdi.c
View file

@ -75,8 +75,7 @@ static int ps2esdi_out_cmd_blk(u_short * cmd_blk);
static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode); static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode);
static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id, static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id);
struct pt_regs *regs);
static void (*current_int_handler) (u_int) = NULL; static void (*current_int_handler) (u_int) = NULL;
static void ps2esdi_normal_interrupt_handler(u_int); static void ps2esdi_normal_interrupt_handler(u_int);
static void ps2esdi_initial_reset_int_handler(u_int); static void ps2esdi_initial_reset_int_handler(u_int);
@ -687,8 +686,7 @@ static void ps2esdi_prep_dma(char *buffer, u_short length, u_char dma_xmode)
static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id, static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id)
struct pt_regs *regs)
{ {
u_int int_ret_code; u_int int_ret_code;

8
drivers/block/swim3.c
View file

@ -238,8 +238,8 @@ static void scan_timeout(unsigned long data);
static void seek_timeout(unsigned long data); static void seek_timeout(unsigned long data);
static void settle_timeout(unsigned long data); static void settle_timeout(unsigned long data);
static void xfer_timeout(unsigned long data); static void xfer_timeout(unsigned long data);
static irqreturn_t swim3_interrupt(int irq, void *dev_id, struct pt_regs *regs); static irqreturn_t swim3_interrupt(int irq, void *dev_id);
/*static void fd_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs);*/ /*static void fd_dma_interrupt(int irq, void *dev_id);*/
static int grab_drive(struct floppy_state *fs, enum swim_state state, static int grab_drive(struct floppy_state *fs, enum swim_state state,
int interruptible); int interruptible);
static void release_drive(struct floppy_state *fs); static void release_drive(struct floppy_state *fs);
@ -624,7 +624,7 @@ static void xfer_timeout(unsigned long data)
start_request(fs); start_request(fs);
} }
static irqreturn_t swim3_interrupt(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t swim3_interrupt(int irq, void *dev_id)
{ {
struct floppy_state *fs = (struct floppy_state *) dev_id; struct floppy_state *fs = (struct floppy_state *) dev_id;
struct swim3 __iomem *sw = fs->swim3; struct swim3 __iomem *sw = fs->swim3;
@ -777,7 +777,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
} }
/* /*
static void fd_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs) static void fd_dma_interrupt(int irq, void *dev_id)
{ {
} }
*/ */

4
drivers/block/swim_iop.c
View file

@ -94,7 +94,7 @@ static char *drive_names[7] = {
int swimiop_init(void); int swimiop_init(void);
static void swimiop_init_request(struct swim_iop_req *); static void swimiop_init_request(struct swim_iop_req *);
static int swimiop_send_request(struct swim_iop_req *); static int swimiop_send_request(struct swim_iop_req *);
static void swimiop_receive(struct iop_msg *, struct pt_regs *); static void swimiop_receive(struct iop_msg *);
static void swimiop_status_update(int, struct swim_drvstatus *); static void swimiop_status_update(int, struct swim_drvstatus *);
static int swimiop_eject(struct floppy_state *fs); static int swimiop_eject(struct floppy_state *fs);
@ -257,7 +257,7 @@ static int swimiop_send_request(struct swim_iop_req *req)
* 2. An unsolicited message was received from the IOP. * 2. An unsolicited message was received from the IOP.
*/ */
void swimiop_receive(struct iop_msg *msg, struct pt_regs *regs) void swimiop_receive(struct iop_msg *msg)
{ {
struct swim_iop_req *req; struct swim_iop_req *req;
struct swimmsg_status *sm; struct swimmsg_status *sm;

2
drivers/block/sx8.c
View file

@ -1200,7 +1200,7 @@ static inline void carm_handle_responses(struct carm_host *host)
host->resp_idx += work; host->resp_idx += work;
} }
static irqreturn_t carm_interrupt(int irq, void *__host, struct pt_regs *regs) static irqreturn_t carm_interrupt(int irq, void *__host)
{ {
struct carm_host *host = __host; struct carm_host *host = __host;
void __iomem *mmio; void __iomem *mmio;

6
drivers/block/ub.c
View file

@ -362,7 +362,7 @@ static void ub_end_rq(struct request *rq, unsigned int status);
static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun, static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
struct ub_request *urq, struct ub_scsi_cmd *cmd); struct ub_request *urq, struct ub_scsi_cmd *cmd);
static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd); static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
static void ub_urb_complete(struct urb *urb, struct pt_regs *pt); static void ub_urb_complete(struct urb *urb);
static void ub_scsi_action(unsigned long _dev); static void ub_scsi_action(unsigned long _dev);
static void ub_scsi_dispatch(struct ub_dev *sc); static void ub_scsi_dispatch(struct ub_dev *sc);
static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd); static void ub_scsi_urb_compl(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
@ -959,7 +959,7 @@ static void ub_urb_timeout(unsigned long arg)
* the sc->lock taken) and from an interrupt (while we do NOT have * the sc->lock taken) and from an interrupt (while we do NOT have
* the sc->lock taken). Therefore, bounce this off to a tasklet. * the sc->lock taken). Therefore, bounce this off to a tasklet.
*/ */
static void ub_urb_complete(struct urb *urb, struct pt_regs *pt) static void ub_urb_complete(struct urb *urb)
{ {
struct ub_dev *sc = urb->context; struct ub_dev *sc = urb->context;
@ -1923,7 +1923,7 @@ static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
/* /*
*/ */
static void ub_probe_urb_complete(struct urb *urb, struct pt_regs *pt) static void ub_probe_urb_complete(struct urb *urb)
{ {
struct completion *cop = urb->context; struct completion *cop = urb->context;
complete(cop); complete(cop);

2
drivers/block/umem.c
View file

@ -571,7 +571,7 @@ static int mm_make_request(request_queue_t *q, struct bio *bio)
-- mm_interrupt -- mm_interrupt
----------------------------------------------------------------------------------- -----------------------------------------------------------------------------------
*/ */
static irqreturn_t mm_interrupt(int irq, void *__card, struct pt_regs *regs) static irqreturn_t mm_interrupt(int irq, void *__card)
{ {
struct cardinfo *card = (struct cardinfo *) __card; struct cardinfo *card = (struct cardinfo *) __card;
unsigned int dma_status; unsigned int dma_status;

3
drivers/block/xd.c
View file

@ -462,8 +462,7 @@ static void xd_recalibrate (u_char drive)
} }
/* xd_interrupt_handler: interrupt service routine */ /* xd_interrupt_handler: interrupt service routine */
static irqreturn_t xd_interrupt_handler(int irq, void *dev_id, static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
struct pt_regs *regs)
{ {
if (inb(XD_STATUS) & STAT_INTERRUPT) { /* check if it was our device */ if (inb(XD_STATUS) & STAT_INTERRUPT) { /* check if it was our device */
#ifdef DEBUG_OTHER #ifdef DEBUG_OTHER

3
drivers/block/xd.h
View file

@ -109,8 +109,7 @@ static int xd_ioctl (struct inode *inode,struct file *file,unsigned int cmd,unsi
static int xd_readwrite (u_char operation,XD_INFO *disk,char *buffer,u_int block,u_int count); static int xd_readwrite (u_char operation,XD_INFO *disk,char *buffer,u_int block,u_int count);
static void xd_recalibrate (u_char drive); static void xd_recalibrate (u_char drive);
static irqreturn_t xd_interrupt_handler(int irq, void *dev_id, static irqreturn_t xd_interrupt_handler(int irq, void *dev_id);
struct pt_regs *regs);
static u_char xd_setup_dma (u_char opcode,u_char *buffer,u_int count); static u_char xd_setup_dma (u_char opcode,u_char *buffer,u_int count);
static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control); static u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control);
static void xd_watchdog (unsigned long unused); static void xd_watchdog (unsigned long unused);

2
drivers/bluetooth/bcm203x.c
View file

@ -82,7 +82,7 @@ struct bcm203x_data {
unsigned int fw_sent; unsigned int fw_sent;
}; };
static void bcm203x_complete(struct urb *urb, struct pt_regs *regs) static void bcm203x_complete(struct urb *urb)
{ {
struct bcm203x_data *data = urb->context; struct bcm203x_data *data = urb->context;
struct usb_device *udev = urb->dev; struct usb_device *udev = urb->dev;

8
drivers/bluetooth/bfusb.c
View file

@ -95,8 +95,8 @@ struct bfusb_data_scb {
struct urb *urb; struct urb *urb;
}; };
static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs); static void bfusb_tx_complete(struct urb *urb);
static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs); static void bfusb_rx_complete(struct urb *urb);
static struct urb *bfusb_get_completed(struct bfusb_data *data) static struct urb *bfusb_get_completed(struct bfusb_data *data)
{ {
@ -190,7 +190,7 @@ static void bfusb_tx_wakeup(struct bfusb_data *data)
clear_bit(BFUSB_TX_PROCESS, &data->state); clear_bit(BFUSB_TX_PROCESS, &data->state);
} }
static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs) static void bfusb_tx_complete(struct urb *urb)
{ {
struct sk_buff *skb = (struct sk_buff *) urb->context; struct sk_buff *skb = (struct sk_buff *) urb->context;
struct bfusb_data *data = (struct bfusb_data *) skb->dev; struct bfusb_data *data = (struct bfusb_data *) skb->dev;
@ -349,7 +349,7 @@ static inline int bfusb_recv_block(struct bfusb_data *data, int hdr, unsigned ch
return 0; return 0;
} }
static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs) static void bfusb_rx_complete(struct urb *urb)
{ {
struct sk_buff *skb = (struct sk_buff *) urb->context; struct sk_buff *skb = (struct sk_buff *) urb->context;
struct bfusb_data *data = (struct bfusb_data *) skb->dev; struct bfusb_data *data = (struct bfusb_data *) skb->dev;

2
drivers/bluetooth/bluecard_cs.c
View file

@ -497,7 +497,7 @@ static void bluecard_receive(bluecard_info_t *info, unsigned int offset)
} }
static irqreturn_t bluecard_interrupt(int irq, void *dev_inst, struct pt_regs *regs) static irqreturn_t bluecard_interrupt(int irq, void *dev_inst)
{ {
bluecard_info_t *info = dev_inst; bluecard_info_t *info = dev_inst;
unsigned int iobase; unsigned int iobase;

2
drivers/bluetooth/bpa10x.c
View file

@ -263,7 +263,7 @@ static void bpa10x_wakeup(struct bpa10x_data *data)
} }
} }
static void bpa10x_complete(struct urb *urb, struct pt_regs *regs) static void bpa10x_complete(struct urb *urb)
{ {
struct bpa10x_data *data = urb->context; struct bpa10x_data *data = urb->context;
unsigned char *buf = urb->transfer_buffer; unsigned char *buf = urb->transfer_buffer;

2
drivers/bluetooth/bt3c_cs.c
View file

@ -338,7 +338,7 @@ static void bt3c_receive(bt3c_info_t *info)
} }
static irqreturn_t bt3c_interrupt(int irq, void *dev_inst, struct pt_regs *regs) static irqreturn_t bt3c_interrupt(int irq, void *dev_inst)
{ {
bt3c_info_t *info = dev_inst; bt3c_info_t *info = dev_inst;
unsigned int iobase; unsigned int iobase;

2
drivers/bluetooth/btuart_cs.c
View file

@ -288,7 +288,7 @@ static void btuart_receive(btuart_info_t *info)
} }
static irqreturn_t btuart_interrupt(int irq, void *dev_inst, struct pt_regs *regs) static irqreturn_t btuart_interrupt(int irq, void *dev_inst)
{ {
btuart_info_t *info = dev_inst; btuart_info_t *info = dev_inst;
unsigned int iobase; unsigned int iobase;

2
drivers/bluetooth/dtl1_cs.c
View file

@ -291,7 +291,7 @@ static void dtl1_receive(dtl1_info_t *info)
} }
static irqreturn_t dtl1_interrupt(int irq, void *dev_inst, struct pt_regs *regs) static irqreturn_t dtl1_interrupt(int irq, void *dev_inst)
{ {
dtl1_info_t *info = dev_inst; dtl1_info_t *info = dev_inst;
unsigned int iobase; unsigned int iobase;

8
drivers/bluetooth/hci_usb.c
View file

@ -176,8 +176,8 @@ static struct _urb *_urb_dequeue(struct _urb_queue *q)
return _urb; return _urb;
} }
static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs); static void hci_usb_rx_complete(struct urb *urb);
static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs); static void hci_usb_tx_complete(struct urb *urb);
#define __pending_tx(husb, type) (&husb->pending_tx[type-1]) #define __pending_tx(husb, type) (&husb->pending_tx[type-1])
#define __pending_q(husb, type) (&husb->pending_q[type-1]) #define __pending_q(husb, type) (&husb->pending_q[type-1])
@ -732,7 +732,7 @@ static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int c
return 0; return 0;
} }
static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs) static void hci_usb_rx_complete(struct urb *urb)
{ {
struct _urb *_urb = container_of(urb, struct _urb, urb); struct _urb *_urb = container_of(urb, struct _urb, urb);
struct hci_usb *husb = (void *) urb->context; struct hci_usb *husb = (void *) urb->context;
@ -786,7 +786,7 @@ static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs)
read_unlock(&husb->completion_lock); read_unlock(&husb->completion_lock);
} }
static void hci_usb_tx_complete(struct urb *urb, struct pt_regs *regs) static void hci_usb_tx_complete(struct urb *urb)
{ {
struct _urb *_urb = container_of(urb, struct _urb, urb); struct _urb *_urb = container_of(urb, struct _urb, urb);
struct hci_usb *husb = (void *) urb->context; struct hci_usb *husb = (void *) urb->context;

2
drivers/cdrom/cdu31a.c
View file

@ -513,7 +513,7 @@ static inline void write_cmd(unsigned char cmd)
outb(cmd, sony_cd_cmd_reg); outb(cmd, sony_cd_cmd_reg);
} }
static irqreturn_t cdu31a_interrupt(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t cdu31a_interrupt(int irq, void *dev_id)
{ {
unsigned char val; unsigned char val;

2
drivers/cdrom/cm206.c
View file

@ -359,7 +359,7 @@ static struct tasklet_struct cm206_tasklet;
as there seems so reason for this to happen. as there seems so reason for this to happen.
*/ */
static irqreturn_t cm206_interrupt(int sig, void *dev_id, struct pt_regs *regs) static irqreturn_t cm206_interrupt(int sig, void *dev_id)
{ {
volatile ush fool; volatile ush fool;
cd->intr_ds = inw(r_data_status); /* resets data_ready, data_error, cd->intr_ds = inw(r_data_status); /* resets data_ready, data_error,

2
drivers/cdrom/mcdx.c
View file

@ -845,7 +845,7 @@ static void mcdx_delay(struct s_drive_stuff *stuff, long jifs)
} }
} }
static irqreturn_t mcdx_intr(int irq, void *dev_id, struct pt_regs *regs) static irqreturn_t mcdx_intr(int irq, void *dev_id)
{ {
struct s_drive_stuff *stuffp = dev_id; struct s_drive_stuff *stuffp = dev_id;
unsigned char b; unsigned char b;

2
drivers/cdrom/sonycd535.c
View file

@ -322,7 +322,7 @@ disable_interrupts(void)
} }
static irqreturn_t static irqreturn_t
cdu535_interrupt(int irq, void *dev_id, struct pt_regs *regs) cdu535_interrupt(int irq, void *dev_id)
{ {
disable_interrupts(); disable_interrupts();
if (waitqueue_active(&cdu535_irq_wait)) { if (waitqueue_active(&cdu535_irq_wait)) {

6
drivers/char/amiserial.c
View file

@ -447,7 +447,7 @@ static void check_modem_status(struct async_struct *info)
} }
} }
static irqreturn_t ser_vbl_int( int irq, void *data, struct pt_regs *regs) static irqreturn_t ser_vbl_int( int irq, void *data)
{ {
/* vbl is just a periodic interrupt we tie into to update modem status */ /* vbl is just a periodic interrupt we tie into to update modem status */
struct async_struct * info = IRQ_ports; struct async_struct * info = IRQ_ports;
@ -460,7 +460,7 @@ static irqreturn_t ser_vbl_int( int irq, void *data, struct pt_regs *regs)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t ser_rx_int(int irq, void *dev_id, struct pt_regs * regs) static irqreturn_t ser_rx_int(int irq, void *dev_id)
{ {
struct async_struct * info; struct async_struct * info;
@ -480,7 +480,7 @@ static irqreturn_t ser_rx_int(int irq, void *dev_id, struct pt_regs * regs)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t ser_tx_int(int irq, void *dev_id, struct pt_regs * regs) static irqreturn_t ser_tx_int(int irq, void *dev_id)
{ {
struct async_struct * info; struct async_struct * info;

4
drivers/char/applicom.c
View file

@ -110,7 +110,7 @@ static ssize_t ac_read (struct file *, char __user *, size_t, loff_t *);
static ssize_t ac_write (struct file *, const char __user *, size_t, loff_t *); static ssize_t ac_write (struct file *, const char __user *, size_t, loff_t *);
static int ac_ioctl(struct inode *, struct file *, unsigned int, static int ac_ioctl(struct inode *, struct file *, unsigned int,
unsigned long); unsigned long);
static irqreturn_t ac_interrupt(int, void *, struct pt_regs *); static irqreturn_t ac_interrupt(int, void *);
static const struct file_operations ac_fops = { static const struct file_operations ac_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
@ -617,7 +617,7 @@ static ssize_t ac_read (struct file *filp, char __user *buf, size_t count, loff_
} }
} }
static irqreturn_t ac_interrupt(int vec, void *dev_instance, struct pt_regs *regs) static irqreturn_t ac_interrupt(int vec, void *dev_instance)
{ {
unsigned int i; unsigned int i;
unsigned int FlagInt; unsigned int FlagInt;

4
drivers/char/cyclades.c
View file

@ -1057,7 +1057,7 @@ detect_isa_irq(void __iomem *address)
received, out buffer empty, modem change, etc. received, out buffer empty, modem change, etc.
*/ */
static irqreturn_t static irqreturn_t
cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs) cyy_interrupt(int irq, void *dev_id)
{ {
struct tty_struct *tty; struct tty_struct *tty;
int status; int status;
@ -1802,7 +1802,7 @@ cyz_handle_cmd(struct cyclades_card *cinfo)
#ifdef CONFIG_CYZ_INTR #ifdef CONFIG_CYZ_INTR
static irqreturn_t static irqreturn_t
cyz_interrupt(int irq, void *dev_id, struct pt_regs *regs) cyz_interrupt(int irq, void *dev_id)
{ {
struct cyclades_card *cinfo; struct cyclades_card *cinfo;

Some files were not shown because too many files have changed in this diff Show more