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

Merge git://git.infradead.org/~dhowells/irq-2.6 

* git://git.infradead.org/~dhowells/irq-2.6:
  IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
  IRQ: Typedef the IRQ handler function type
  IRQ: Typedef the IRQ flow handler function type
This commit is contained in:
Linus Torvalds 2006-10-05 16:32:01 -07:00
parent c1a26e7d40 7d12e780e0
commit 44aefd2706
1080 changed files with 2638 additions and 3006 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
*/
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;
frv_clear_dma_inprogress(channel - frv_dma_channels);
return channel->handler(channel - frv_dma_channels,
__get_DMAC(channel->ioaddr, CSTR),
channel->data,
regs);
channel->data);
} /* 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
*/
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;
@ -95,7 +95,7 @@ static irqreturn_t fpga_interrupt(int irq, void *_mask, struct pt_regs *regs)
irq = 31 - irq;
mask &= ~(1 << irq);
generic_handle_irq(IRQ_BASE_FPGA + irq, regs);
generic_handle_irq(IRQ_BASE_FPGA + irq);
}
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
*/
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;
@ -94,7 +94,7 @@ static irqreturn_t fpga_interrupt(int irq, void *_mask, struct pt_regs *regs)
irq = 31 - irq;
mask &= ~(1 << irq);
generic_irq_handle(IRQ_BASE_FPGA + irq, regs);
generic_irq_handle(IRQ_BASE_FPGA + irq);
}
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
*/
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;
uint32_t iqsr;
@ -106,7 +106,7 @@ static irqreturn_t mb93493_interrupt(int irq, void *_piqsr, struct pt_regs *regs
irq = 31 - irq;
iqsr &= ~(1 << irq);
generic_handle_irq(IRQ_BASE_MB93493 + irq, regs);
generic_handle_irq(IRQ_BASE_MB93493 + irq);
}
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)
{
irq_enter();
generic_handle_irq(__get_IRL(), __frame);
generic_handle_irq(__get_IRL());
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 __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 = {
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,
* 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 */
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);
do_timer(1);
update_process_times(user_mode(regs));
profile_tick(CPU_PROFILING, regs);
update_process_times(user_mode(get_irq_regs()));
profile_tick(CPU_PROFILING);
/*
* 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.
*/
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
update_process_times(user_mode_vm(regs));
update_process_times(user_mode_vm(irq_regs));
#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)
{
struct pt_regs *old_regs = set_irq_regs(regs);
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.
*/
irq_enter();
smp_local_timer_interrupt(regs);
smp_local_timer_interrupt();
irq_exit();
set_irq_regs(old_regs);
}
#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();
@ -1255,11 +1257,11 @@ static void up_apic_timer_interrupt_call(struct pt_regs *regs)
*/
per_cpu(irq_stat, cpu).apic_timer_irqs++;
smp_local_timer_interrupt(regs);
smp_local_timer_interrupt();
}
#endif
void smp_send_timer_broadcast_ipi(struct pt_regs *regs)
void smp_send_timer_broadcast_ipi(void)
{
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
* in UP case. Minus all irq related functions
*/
up_apic_timer_interrupt_call(regs);
up_apic_timer_interrupt_call();
#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 *);
outb(0,0xF0);
if (ignore_fpu_irq || !boot_cpu_data.hard_math)
return IRQ_NONE;
math_error((void __user *)regs->eip);
math_error((void __user *)get_irq_regs()->eip);
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)
{
struct pt_regs *old_regs;
/* high bit used in ret_from_ code */
int irq = ~regs->orig_eax;
struct irq_desc *desc = irq_desc + irq;
@ -67,6 +68,7 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
BUG();
}
old_regs = set_irq_regs(regs);
irq_enter();
#ifdef CONFIG_DEBUG_STACKOVERFLOW
/* 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)
*/
if (curctx != irqctx) {
int arg1, arg2, arg3, ebx;
int arg1, arg2, ebx;
/* build the stack frame on the IRQ stack */
isp = (u32*) ((char*)irqctx + sizeof(*irqctx));
@ -114,17 +116,17 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
" xchgl %%ebx,%%esp \n"
" call *%%edi \n"
" movl %%ebx,%%esp \n"
: "=a" (arg1), "=d" (arg2), "=c" (arg3), "=b" (ebx)
: "0" (irq), "1" (desc), "2" (regs), "3" (isp),
: "=a" (arg1), "=d" (arg2), "=b" (ebx)
: "0" (irq), "1" (desc), "2" (isp),
"D" (desc->handle_irq)
: "memory", "cc"
);
} else
#endif
desc->handle_irq(irq, desc, regs);
desc->handle_irq(irq, desc);
irq_exit();
set_irq_regs(old_regs);
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)
{
struct pt_regs *old_regs = set_irq_regs(regs);
unsigned long cpu;
cpu = get_cpu();
@ -351,6 +352,7 @@ fastcall void smp_invalidate_interrupt(struct pt_regs *regs)
smp_mb__after_clear_bit();
out:
put_cpu_no_resched();
set_irq_regs(old_regs);
}
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)
{
struct pt_regs *old_regs = set_irq_regs(regs);
ack_APIC_irq();
set_irq_regs(old_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 *info = call_data->info;
int wait = call_data->wait;
@ -632,6 +637,7 @@ fastcall void smp_call_function_interrupt(struct pt_regs *regs)
mb();
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
* 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
@ -188,7 +188,7 @@ irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
}
#endif
do_timer_interrupt_hook(regs);
do_timer_interrupt_hook();
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
if (using_apic_timer)
smp_send_timer_broadcast_ipi(regs);
smp_send_timer_broadcast_ipi();
#endif
return IRQ_HANDLED;

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

@ -441,7 +441,7 @@ int hpet_rtc_dropped_irq(void)
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;
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) {
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;
}

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

@ -714,7 +714,7 @@ static int irqbits;
| (1 << SIGUSR1) | (1 << SIGUSR2) | (1 << SIGIO) | (1 << SIGURG) \
| (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;
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
* 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;
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]++;
if (likely(desc->action != NULL))
handle_IRQ_event(realirq, regs, desc->action);
handle_IRQ_event(realirq, desc->action);
if (!(desc->status & IRQ_DISABLED))
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
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");
}

28
arch/i386/mach-voyager/voyager_smp.c
View File

@ -126,10 +126,10 @@ send_QIC_CPI(__u32 cpuset, __u8 cpi)
}
static inline void
wrapper_smp_local_timer_interrupt(struct pt_regs *regs)
wrapper_smp_local_timer_interrupt(void)
{
irq_enter();
smp_local_timer_interrupt(regs);
smp_local_timer_interrupt();
irq_exit();
}
@ -786,7 +786,7 @@ fastcall void
smp_vic_sys_interrupt(struct pt_regs *regs)
{
ack_CPI(VIC_SYS_INT);
printk("Voyager SYSTEM INTERRUPT\n");
printk("Voyager SYSTEM INTERRUPT\n");
}
/* Handle a voyager CMN_INT; These interrupts occur either because of
@ -1135,7 +1135,9 @@ EXPORT_SYMBOL(smp_call_function);
fastcall void
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 */
@ -1143,7 +1145,9 @@ fastcall void
smp_qic_timer_interrupt(struct pt_regs *regs)
{
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
@ -1177,6 +1181,7 @@ smp_qic_call_function_interrupt(struct pt_regs *regs)
fastcall void
smp_vic_cpi_interrupt(struct pt_regs *regs)
{
struct pt_regs *old_regs = set_irq_regs(regs);
__u8 cpu = smp_processor_id();
if(is_cpu_quad())
@ -1185,7 +1190,7 @@ smp_vic_cpi_interrupt(struct pt_regs *regs)
ack_VIC_CPI(VIC_CPI_LEVEL0);
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]))
smp_invalidate_interrupt();
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();
if(test_and_clear_bit(VIC_CALL_FUNCTION_CPI, &vic_cpi_mailbox[cpu]))
smp_call_function_interrupt();
set_irq_regs(old_regs);
}
static void
@ -1266,8 +1272,10 @@ smp_send_stop(void)
void
smp_vic_timer_interrupt(struct pt_regs *regs)
{
struct pt_regs *old_regs = set_irq_regs(regs);
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
@ -1279,12 +1287,12 @@ smp_vic_timer_interrupt(struct pt_regs *regs)
* value into /proc/profile.
*/
void
smp_local_timer_interrupt(struct pt_regs * regs)
smp_local_timer_interrupt(void)
{
int cpu = smp_processor_id();
long weight;
profile_tick(CPU_PROFILING, regs);
profile_tick(CPU_PROFILING);
if (--per_cpu(prof_counter, cpu) <= 0) {
/*
* 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);
}
update_process_times(user_mode_vm(regs));
update_process_times(user_mode_vm(irq_regs));
}
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
ia64_handle_irq (ia64_vector vector, struct pt_regs *regs)
{
struct pt_regs *old_regs = set_irq_regs(regs);
unsigned long saved_tpr;
#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_srlz_d();
__do_IRQ(local_vector_to_irq(vector), regs);
__do_IRQ(local_vector_to_irq(vector));
/*
* 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.
*/
irq_exit();
set_irq_regs(old_regs);
}
#ifdef CONFIG_HOTPLUG_CPU

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

@ -60,7 +60,7 @@ machvec_setup (char **arg)
EXPORT_SYMBOL(machvec_setup);
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);

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

@ -499,7 +499,7 @@ int cpe_vector = -1;
int ia64_cpe_irq = -1;
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 int index;
@ -744,7 +744,7 @@ ia64_mca_wakeup_all(void)
* Outputs : None
*/
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;
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 */
local_irq_save(flags);
if (notify_die(DIE_MCA_RENDZVOUS_ENTER, "MCA", regs, (long)&nd, 0, 0)
== NOTIFY_STOP)
if (notify_die(DIE_MCA_RENDZVOUS_ENTER, "MCA", get_irq_regs(),
(long)&nd, 0, 0) == NOTIFY_STOP)
ia64_mca_spin(__FUNCTION__);
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();
if (notify_die(DIE_MCA_RENDZVOUS_PROCESS, "MCA", regs, (long)&nd, 0, 0)
== NOTIFY_STOP)
if (notify_die(DIE_MCA_RENDZVOUS_PROCESS, "MCA", get_irq_regs(),
(long)&nd, 0, 0) == NOTIFY_STOP)
ia64_mca_spin(__FUNCTION__);
/* Wait for the monarch cpu to exit. */
while (monarch_cpu != -1)
cpu_relax(); /* spin until monarch leaves */
if (notify_die(DIE_MCA_RENDZVOUS_LEAVE, "MCA", regs, (long)&nd, 0, 0)
== NOTIFY_STOP)
if (notify_die(DIE_MCA_RENDZVOUS_LEAVE, "MCA", get_irq_regs(),
(long)&nd, 0, 0) == NOTIFY_STOP)
ia64_mca_spin(__FUNCTION__);
/* 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)
* arg (Interrupt handler specific argument)
* ptregs (Exception frame at the time of the interrupt)
* Outputs : None
*
*/
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;
}
@ -1261,13 +1260,12 @@ static DECLARE_WORK(cmc_enable_work, ia64_mca_cmc_vector_enable_keventd, NULL);
* Inputs
* interrupt number
* client data arg ptr
* saved registers ptr
*
* Outputs
* None
*/
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 int index;
@ -1336,12 +1334,11 @@ out:
* Inputs
* interrupt number
* client data arg ptr
* saved registers ptr
* Outputs
* handled
*/
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;
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)
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++);
@ -1403,14 +1400,13 @@ ia64_mca_cmc_poll (unsigned long dummy)
* Inputs
* interrupt number
* client data arg ptr
* saved registers ptr
* Outputs
* handled
*/
#ifdef CONFIG_ACPI
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 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)
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++);

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

@ -45,7 +45,7 @@ static struct time_interpolator itc_interpolator = {
};
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;
@ -53,7 +53,7 @@ timer_interrupt (int irq, void *dev_id, struct pt_regs *regs)
return IRQ_HANDLED;
}
platform_timer_interrupt(irq, dev_id, regs);
platform_timer_interrupt(irq, dev_id);
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",
ia64_get_itc(), new_itm);
profile_tick(CPU_PROFILING, regs);
profile_tick(CPU_PROFILING);
while (1) {
update_process_times(user_mode(regs));
update_process_times(user_mode(get_irq_regs()));
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
* @irq: unused
* @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
* defers processing to the SGI prom.
*/
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 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
* @irq: unused
* @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
* defers processing to the SGI prom.
*/ 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 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)
{
struct pt_regs *old_regs = set_irq_regs(regs);
irq_enter();
__DO_IRQ_SMTC_HOOK();
__do_IRQ(irq, regs);
__do_IRQ(irq);
irq_exit();
set_irq_regs(old_regs);
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
* 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)
profile_tick(CPU_PROFILING, regs);
update_process_times(user_mode(regs));
profile_tick(CPU_PROFILING);
update_process_times(user_mode(get_irq_regs()));
}
/*
* High-level timer interrupt service routines. This function
* 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 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
* low-level local timer interrupt handler.
*/
local_timer_interrupt(irq, dev_id, regs);
local_timer_interrupt(irq, dev_id);
return IRQ_HANDLED;
}
int null_perf_irq(struct pt_regs *regs)
int null_perf_irq(void)
{
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(perf_irq);
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;
irq_enter();
@ -448,27 +449,30 @@ asmlinkage void ll_timer_interrupt(int irq, struct pt_regs *regs)
* performance counter interrupt handler anyway.
*/
if (!r2 || (read_c0_cause() & (1 << 26)))
if (perf_irq(regs))
if (perf_irq())
goto out;
/* we keep interrupt disabled all the time */
if (!r2 || (read_c0_cause() & (1 << 30)))
timer_interrupt(irq, NULL, regs);
timer_interrupt(irq, NULL);
out:
irq_exit();
set_irq_regs(old_regs);
}
asmlinkage void ll_local_timer_interrupt(int irq, struct pt_regs *regs)
{
struct pt_regs *old_regs = set_irq_regs(regs);
irq_enter();
if (smp_processor_id() != 0)
kstat_this_cpu.irqs[irq]++;
/* we keep interrupt disabled all the time */
local_timer_interrupt(irq, NULL, regs);
local_timer_interrupt(irq, NULL);
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;

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)
{
struct pt_regs *old_regs = set_irq_regs(regs);
int irq = SGI_TIMER_IRQ;
irq_enter();
kstat_this_cpu.irqs[irq]++;
timer_interrupt(irq, NULL, regs);
timer_interrupt(irq, NULL);
irq_exit();
set_irq_regs(old_regs);
}
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)
{
struct pt_regs *old_regs = set_irq_regs(regs);
unsigned int irq;
#ifdef CONFIG_IRQSTACKS
struct thread_info *curtp, *irqtp;
@ -230,18 +231,19 @@ void do_IRQ(struct pt_regs *regs)
handler = &__do_IRQ;
irqtp->task = curtp->task;
irqtp->flags = 0;
call_handle_irq(irq, desc, regs, irqtp, handler);
call_handle_irq(irq, desc, irqtp, handler);
irqtp->task = NULL;
if (irqtp->flags)
set_bits(irqtp->flags, &curtp->flags);
} else
#endif
generic_handle_irq(irq, regs);
generic_handle_irq(irq);
} else if (irq != NO_IRQ_IGNORE)
/* That's not SMP safe ... but who cares ? */
ppc_spurious_interrupts++;
irq_exit();
set_irq_regs(old_regs);
#ifdef CONFIG_PPC_ISERIES
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
_GLOBAL(call_handle_irq)
ld r8,0(r7)
ld r8,0(r6)
mflr r0
std r0,16(r1)
mtctr r8
stdu r1,THREAD_SIZE-112(r6)
mr r1,r6
stdu r1,THREAD_SIZE-112(r5)
mr r1,r5
bctrl
ld r1,0(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
void smp_message_recv(int msg, struct pt_regs *regs)
void smp_message_recv(int msg)
{
switch(msg) {
case PPC_MSG_CALL_FUNCTION:
@ -127,11 +127,11 @@ void smp_message_recv(int msg, struct pt_regs *regs)
break;
case PPC_MSG_DEBUGGER_BREAK:
if (crash_ipi_function_ptr) {
crash_ipi_function_ptr(regs);
crash_ipi_function_ptr(get_irq_regs());
break;
}
#ifdef CONFIG_DEBUGGER
debugger_ipi(regs);
debugger_ipi(get_irq_regs());
break;
#endif /* CONFIG_DEBUGGER */
/* FALLTHROUGH */

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

@ -51,6 +51,7 @@
#include <linux/rtc.h>
#include <linux/jiffies.h>
#include <linux/posix-timers.h>
#include <linux/irq.h>
#include <asm/io.h>
#include <asm/processor.h>
@ -643,6 +644,7 @@ static void iSeries_tb_recal(void)
*/
void timer_interrupt(struct pt_regs * regs)
{
struct pt_regs *old_regs;
int next_dec;
int cpu = smp_processor_id();
unsigned long ticks;
@ -653,9 +655,10 @@ void timer_interrupt(struct pt_regs * regs)
do_IRQ(regs);
#endif
old_regs = set_irq_regs(regs);
irq_enter();
profile_tick(CPU_PROFILING, regs);
profile_tick(CPU_PROFILING);
calculate_steal_time();
#ifdef CONFIG_PPC_ISERIES
@ -715,6 +718,7 @@ void timer_interrupt(struct pt_regs * regs)
#endif
irq_exit();
set_irq_regs(old_regs);
}
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);
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;
smp_message_recv(ipi, regs);
smp_message_recv(ipi);
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,
};
static void spider_irq_cascade(unsigned int irq, struct irq_desc *desc,
struct pt_regs *regs)
static void spider_irq_cascade(unsigned int irq, struct irq_desc *desc)
{
struct spider_pic *pic = desc->handler_data;
unsigned int cs, virq;
@ -225,7 +224,7 @@ static void spider_irq_cascade(unsigned int irq, struct irq_desc *desc,
else
virq = irq_linear_revmap(pic->host, cs);
if (virq != NO_IRQ)
generic_handle_irq(virq, regs);
generic_handle_irq(virq);
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 */
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;
unsigned long flags;

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

@ -15,7 +15,7 @@
#define DBG(fmt...)
#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);

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

@ -440,14 +440,13 @@ static void __init pmac_pic_probe_oldstyle(void)
}
#endif /* CONFIG_PPC32 */
static void pmac_u3_cascade(unsigned int irq, struct irq_desc *desc,
struct pt_regs *regs)
static void pmac_u3_cascade(unsigned int irq, struct irq_desc *desc)
{
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)
generic_handle_irq(cascade_irq, regs);
generic_handle_irq(cascade_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 RAS_VECTOR_OFFSET 0x500
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,
struct pt_regs * regs);
static irqreturn_t ras_epow_interrupt(int irq, void *dev_id);
static irqreturn_t ras_error_interrupt(int irq, void *dev_id);
/* #define DEBUG */
static void request_ras_irqs(struct device_node *np,
irqreturn_t (*handler)(int, void *, struct pt_regs *),
irq_handler_t handler,
const char *name)
{
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
* the time horizon permits something useful to be done.
*/
static irqreturn_t
ras_epow_interrupt(int irq, void *dev_id, struct pt_regs * regs)
static irqreturn_t ras_epow_interrupt(int irq, void *dev_id)
{
int status = 0xdeadbeef;
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
* as quickly as possible in order to prevent propagation of the failure.
*/
static irqreturn_t
ras_error_interrupt(int irq, void *dev_id, struct pt_regs * regs)
static irqreturn_t ras_error_interrupt(int irq, void *dev_id)
{
struct rtas_error_log *rtas_elog;
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;
}
void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc,
struct pt_regs *regs)
void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc)
{
unsigned int cascade_irq = i8259_irq(regs);
unsigned int cascade_irq = i8259_irq(get_irq_regs());
if (cascade_irq != NO_IRQ)
generic_handle_irq(cascade_irq, regs);
generic_handle_irq(cascade_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
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));
@ -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,
&xics_ipi_message[cpu].value)) {
mb();
smp_message_recv(PPC_MSG_CALL_FUNCTION, regs);
smp_message_recv(PPC_MSG_CALL_FUNCTION);
}
if (test_and_clear_bit(PPC_MSG_RESCHEDULE,
&xics_ipi_message[cpu].value)) {
mb();
smp_message_recv(PPC_MSG_RESCHEDULE, regs);
smp_message_recv(PPC_MSG_RESCHEDULE);
}
#if 0
if (test_and_clear_bit(PPC_MSG_MIGRATE_TASK,
&xics_ipi_message[cpu].value)) {
mb();
smp_message_recv(PPC_MSG_MIGRATE_TASK, regs);
smp_message_recv(PPC_MSG_MIGRATE_TASK);
}
#endif
#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
if (test_and_clear_bit(PPC_MSG_DEBUGGER_BREAK,
&xics_ipi_message[cpu].value)) {
mb();
smp_message_recv(PPC_MSG_DEBUGGER_BREAK, regs);
smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
}
#endif
}
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();
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();
lpar_qirr_info(cpu, 0xff);
return xics_ipi_dispatch(cpu, regs);
return xics_ipi_dispatch(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;
struct irq_desc;
extern void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc,
struct pt_regs *regs);
extern void pseries_8259_cascade(unsigned int irq, struct irq_desc *desc);
#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
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;
}
#endif /* CONFIG_SMP */

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

@ -21,6 +21,7 @@
#include <linux/module.h>
#include <linux/sysrq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <asm/ptrace.h>
#include <asm/string.h>
@ -2577,12 +2578,11 @@ void xmon_init(int enable)
}
#ifdef CONFIG_MAGIC_SYSRQ
static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs,
struct tty_struct *tty)
static void sysrq_handle_xmon(int key, struct tty_struct *tty)
{
/* ensure xmon is enabled */
xmon_init(1);
debugger(pt_regs);
debugger(get_irq_regs());
}
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.
*/
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
update_process_times(user_mode(regs));
update_process_times(user_mode(get_irq_regs()));
#endif
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
* 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
* 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.
@ -932,7 +932,7 @@ void smp_apic_timer_interrupt(struct pt_regs *regs)
*/
exit_idle();
irq_enter();
smp_local_timer_interrupt(regs);
smp_local_timer_interrupt();
irq_exit();
}

7
arch/x86_64/kernel/irq.c
View File

@ -103,7 +103,9 @@ skip:
* handlers).
*/
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 */
unsigned vector = ~regs->orig_rax;
unsigned irq;
@ -121,9 +123,10 @@ asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
#ifdef CONFIG_DEBUG_STACKOVERFLOW
stack_overflow_check(regs);
#endif
generic_handle_irq(irq, regs);
generic_handle_irq(irq);
irq_exit();
set_irq_regs(old_regs);
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);
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 int warned;
if (report_lost_ticks) {
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) {
printk(KERN_WARNING "warning: many lost ticks.\n"
KERN_WARNING "Your time source seems to be instable or "
"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) {
printk(KERN_WARNING "Falling back to HPET\n");
if (hpet_use_timer)
@ -339,7 +339,7 @@ static noinline void handle_lost_ticks(int lost, struct pt_regs *regs)
#endif
}
void main_timer_handler(struct pt_regs *regs)
void main_timer_handler(void)
{
static unsigned long rtc_update = 0;
unsigned long tsc;
@ -411,7 +411,7 @@ void main_timer_handler(struct pt_regs *regs)
}
if (lost > 0)
handle_lost_ticks(lost, regs);
handle_lost_ticks(lost);
else
lost = 0;
@ -421,7 +421,7 @@ void main_timer_handler(struct pt_regs *regs)
do_timer(lost + 1);
#ifndef CONFIG_SMP
update_process_times(user_mode(regs));
update_process_times(user_mode(get_irq_regs()));
#endif
/*
@ -431,7 +431,7 @@ void main_timer_handler(struct pt_regs *regs)
*/
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
@ -450,11 +450,11 @@ void main_timer_handler(struct pt_regs *regs)
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)
return IRQ_HANDLED;
main_timer_handler(regs);
main_timer_handler();
if (using_apic_timer)
smp_send_timer_broadcast_ipi();
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) {
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;
}

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

@ -938,7 +938,7 @@ static void do_mfm_request(request_queue_t *q)
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;

2
drivers/acpi/osl.c
View File

@ -237,7 +237,7 @@ acpi_os_table_override(struct acpi_table_header * existing_table,
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;
}

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 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 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 int ahci_port_start(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 */
}
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 ahci_host_priv *hpriv;

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

@ -4857,7 +4857,6 @@ idle_irq:
* ata_interrupt - Default ATA host interrupt handler
* @irq: irq line (unused)
* @dev_instance: pointer to our ata_host information structure
* @regs: unused
*
* Default interrupt handler for PCI IDE devices. Calls
* ata_host_intr() for each port that is not disabled.
@ -4869,7 +4868,7 @@ idle_irq:
* 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;
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,
const struct pci_device_id *ent);
static irqreturn_t adma_intr (int irq, void *dev_instance,
struct pt_regs *regs);
static irqreturn_t adma_intr (int irq, void *dev_instance);
static int adma_port_start(struct ata_port *ap);
static void adma_host_stop(struct ata_host *host);
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;
}
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;
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_iie(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,
struct pt_regs *regs);
static irqreturn_t mv_interrupt(int irq, void *dev_instance);
static void mv_eng_timeout(struct ata_port *ap);
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
* interrupts.
*/
static irqreturn_t mv_interrupt(int irq, void *dev_instance,
struct pt_regs *regs)
static irqreturn_t mv_interrupt(int irq, void *dev_instance)
{
struct ata_host *host = dev_instance;
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 void nv_ck804_host_stop(struct ata_host *host);
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,
struct pt_regs *regs);
static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance,
struct pt_regs *regs);
static irqreturn_t nv_generic_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);
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);
@ -276,8 +273,7 @@ MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(pci, nv_pci_tbl);
MODULE_VERSION(DRV_VERSION);
static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance,
struct pt_regs *regs)
static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance)
{
struct ata_host *host = dev_instance;
unsigned int i;
@ -357,8 +353,7 @@ static irqreturn_t nv_do_interrupt(struct ata_host *host, u8 irq_stat)
return IRQ_RETVAL(handled);
}
static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance,
struct pt_regs *regs)
static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance)
{
struct ata_host *host = dev_instance;
u8 irq_stat;
@ -372,8 +367,7 @@ static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance,
return ret;
}
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 ata_host *host = dev_instance;
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 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 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 int pdc_port_start(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);
}
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_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 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 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 void qs_host_stop(struct ata_host *host);
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;
}
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;
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 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 irqreturn_t sil_interrupt(int irq, void *dev_instance,
struct pt_regs *regs);
static irqreturn_t sil_interrupt(int irq, void *dev_instance);
static void sil_freeze(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);
}
static irqreturn_t sil_interrupt(int irq, void *dev_instance,
struct pt_regs *regs)
static irqreturn_t sil_interrupt(int irq, void *dev_instance)
{
struct ata_host *host = dev_instance;
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 unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
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_thaw(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);
}
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 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 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_20621_phy_reset (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);
}
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_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.
*/
static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance,
struct pt_regs *regs)
static irqreturn_t vsc_sata_interrupt (int irq, void *dev_instance)
{
struct ata_host *host = dev_instance;
unsigned int i;

4
drivers/atm/ambassador.c
View File

@ -861,10 +861,8 @@ static inline void interrupts_off (amb_dev * dev) {
/********** interrupt handling **********/
static irqreturn_t interrupt_handler(int irq, void *dev_id,
struct pt_regs *pt_regs) {
static irqreturn_t interrupt_handler(int irq, void *dev_id) {
amb_dev * dev = (amb_dev *) dev_id;
(void) pt_regs;
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 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;
u32 status;

2
drivers/atm/fore200e.c
View File

@ -1328,7 +1328,7 @@ fore200e_irq(struct fore200e* fore200e)
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);

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 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 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 int he_proc_read(struct atm_dev *dev,loff_t *pos,char *page);
static int he_start(struct atm_dev *dev);
@ -2216,7 +2216,7 @@ he_tasklet(unsigned long data)
}
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;
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 **********/
static irqreturn_t interrupt_handler(int irq, void *dev_id,
struct pt_regs *pt_regs) {
static irqreturn_t interrupt_handler(int irq, void *dev_id) {
hrz_dev * dev = (hrz_dev *) dev_id;
u32 int_source;
unsigned int irq_ok;
(void) pt_regs;
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
idt77252_interrupt(int irq, void *dev_id, struct pt_regs *ptregs)
idt77252_interrupt(int irq, void *dev_id)
{
struct idt77252_dev *card = dev_id;
u32 stat;

2
drivers/atm/iphase.c
View File

@ -2195,7 +2195,7 @@ err_out:
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;
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);
}
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;
u32 reason;
(void) irq; (void) regs; /* unused variables */
(void) irq; /* unused variables */
#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 void free_scq(scq_info *scq, struct atm_vcc *vcc);
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 void ns_close(struct atm_vcc *vcc);
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;
ns_dev *card;

2
drivers/atm/zatm.c
View File

@ -1012,7 +1012,7 @@ static int start_tx(struct atm_dev *dev)
/*------------------------------- 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 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 *)entry->driver_data;
irqreturn_t (*InterruptHandler)(int, void *, struct pt_regs *) =
privdata->InterruptHandler;
irq_handler_t InterruptHandler = privdata->InterruptHandler;
unsigned int MemoryWindowSize = privdata->MemoryWindowSize;
DAC960_Controller_T *Controller = NULL;
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,
void *DeviceIdentifier,
struct pt_regs *InterruptRegisters)
void *DeviceIdentifier)
{
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
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,
void *DeviceIdentifier,
struct pt_regs *InterruptRegisters)
void *DeviceIdentifier)
{
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
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,
void *DeviceIdentifier,
struct pt_regs *InterruptRegisters)
void *DeviceIdentifier)
{
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
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,
void *DeviceIdentifier,
struct pt_regs *InterruptRegisters)
void *DeviceIdentifier)
{
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
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,
void *DeviceIdentifier,
struct pt_regs *InterruptRegisters)
void *DeviceIdentifier)
{
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
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,
void *DeviceIdentifier,
struct pt_regs *InterruptRegisters)
void *DeviceIdentifier)
{
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
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,
void *DeviceIdentifier,
struct pt_regs *InterruptRegisters)
void *DeviceIdentifier)
{
DAC960_Controller_T *Controller = (DAC960_Controller_T *) DeviceIdentifier;
void __iomem *ControllerBaseAddress = Controller->BaseAddress;

14
drivers/block/DAC960.h
View File

@ -2175,7 +2175,7 @@ static char
struct DAC960_privdata {
DAC960_HardwareType_T HardwareType;
DAC960_FirmwareType_T FirmwareType;
irqreturn_t (*InterruptHandler)(int, void *, struct pt_regs *);
irq_handler_t InterruptHandler;
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_V2_QueueReadWriteCommand(DAC960_Command_T *);
static void DAC960_RequestFunction(struct request_queue *);
static irqreturn_t DAC960_BA_InterruptHandler(int, void *, struct pt_regs *);
static irqreturn_t DAC960_LP_InterruptHandler(int, void *, struct pt_regs *);
static irqreturn_t DAC960_LA_InterruptHandler(int, void *, struct pt_regs *);
static irqreturn_t DAC960_PG_InterruptHandler(int, void *, struct pt_regs *);
static irqreturn_t DAC960_PD_InterruptHandler(int, void *, struct pt_regs *);
static irqreturn_t DAC960_P_InterruptHandler(int, void *, struct pt_regs *);
static irqreturn_t DAC960_BA_InterruptHandler(int, void *);
static irqreturn_t DAC960_LP_InterruptHandler(int, void *);
static irqreturn_t DAC960_LA_InterruptHandler(int, void *);
static irqreturn_t DAC960_PG_InterruptHandler(int, void *);
static irqreturn_t DAC960_PD_InterruptHandler(int, void *);
static irqreturn_t DAC960_P_InterruptHandler(int, void *);
static void DAC960_V1_QueueMonitoringCommand(DAC960_Command_T *);
static void DAC960_V2_QueueMonitoringCommand(DAC960_Command_T *);
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);
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 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 bad_rw_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;

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
*ppos );
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 set_dma_addr( unsigned long paddr );
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 */
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;
int stat;

4
drivers/block/amiflop.c
View File

@ -209,7 +209,7 @@ static int fd_device[4] = { 0, 0, 0, 0 };
/* 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;
wake_up(&ms_wait);
@ -560,7 +560,7 @@ static unsigned long fd_get_drive_id(int drive)
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)
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_motor_off_timer( 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 int do_format(int drive, int type, struct atari_format_descr *desc);
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 irqreturn_t floppy_irq (int irq, void *dummy, struct pt_regs *fp)
static irqreturn_t floppy_irq (int irq, void *dummy)
{
unsigned char status;
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 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_release(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
/* if we saved some commands for later, process them now. */
if (info_p->scsi_rejects.ncompletions > 0)
do_cciss_intr(0, info_p, NULL);
do_cciss_intr(0, info_p);
#endif
cmd_free(info_p, c, 1);
return status;
@ -2652,7 +2652,7 @@ static inline long interrupt_not_for_us(ctlr_info_t *h)
#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;
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_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 int ida_revalidate(struct gendisk *disk);
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
* 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;
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 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);
#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 */
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;
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 irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id,
struct pt_regs *regs);
static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id);
static void (*current_int_handler) (u_int) = NULL;
static void ps2esdi_normal_interrupt_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,
struct pt_regs *regs)
static irqreturn_t ps2esdi_interrupt_handler(int irq, void *dev_id)
{
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 settle_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 void fd_dma_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);*/
static int grab_drive(struct floppy_state *fs, enum swim_state state,
int interruptible);
static void release_drive(struct floppy_state *fs);
@ -624,7 +624,7 @@ static void xfer_timeout(unsigned long data)
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 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);
static void swimiop_init_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 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.
*/
void swimiop_receive(struct iop_msg *msg, struct pt_regs *regs)
void swimiop_receive(struct iop_msg *msg)
{
struct swim_iop_req *req;
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;
}
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;
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,
struct ub_request *urq, 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_dispatch(struct ub_dev *sc);
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). 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;
@ -1923,7 +1923,7 @@ err_alloc:
/*
*/
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;
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
-----------------------------------------------------------------------------------
*/
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;
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 */
static irqreturn_t xd_interrupt_handler(int irq, void *dev_id,
struct pt_regs *regs)
static irqreturn_t xd_interrupt_handler(int irq, void *dev_id)
{
if (inb(XD_STATUS) & STAT_INTERRUPT) { /* check if it was our device */
#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 void xd_recalibrate (u_char drive);
static irqreturn_t xd_interrupt_handler(int irq, void *dev_id,
struct pt_regs *regs);
static irqreturn_t xd_interrupt_handler(int irq, void *dev_id);
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 void xd_watchdog (unsigned long unused);

2
drivers/bluetooth/bcm203x.c
View File

@ -82,7 +82,7 @@ struct bcm203x_data {
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 usb_device *udev = urb->dev;

8
drivers/bluetooth/bfusb.c
View File

@ -95,8 +95,8 @@ struct bfusb_data_scb {
struct urb *urb;
};
static void bfusb_tx_complete(struct urb *urb, struct pt_regs *regs);
static void bfusb_rx_complete(struct urb *urb, struct pt_regs *regs);
static void bfusb_tx_complete(struct urb *urb);
static void bfusb_rx_complete(struct urb *urb);
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);
}
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 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;
}
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 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;
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;
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;
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;
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;
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;
}
static void hci_usb_rx_complete(struct urb *urb, struct pt_regs *regs);
static void hci_usb_tx_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);
#define __pending_tx(husb, type) (&husb->pending_tx[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;
}
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 hci_usb *husb = (void *) urb->context;
@ -786,7 +786,7 @@ unlock:
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 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);
}
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;

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.
*/
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;
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;
unsigned char b;

2
drivers/cdrom/sonycd535.c
View File

@ -322,7 +322,7 @@ disable_interrupts(void)
}
static irqreturn_t
cdu535_interrupt(int irq, void *dev_id, struct pt_regs *regs)
cdu535_interrupt(int irq, void *dev_id)
{
disable_interrupts();
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 */
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;
}
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;
@ -480,7 +480,7 @@ static irqreturn_t ser_rx_int(int irq, void *dev_id, struct pt_regs * regs)
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;

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 int ac_ioctl(struct inode *, struct file *, unsigned int,
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 = {
.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 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.
*/
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;
int status;
@ -1802,7 +1802,7 @@ cyz_handle_cmd(struct cyclades_card *cinfo)
#ifdef CONFIG_CYZ_INTR
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;

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