mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

[PATCH] sparc32 pt_regs fixes 

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Al Viro 2006-10-08 14:30:44 +01:00 committed by Linus Torvalds
parent 7ff3e52cf2
commit 0d84438d98
13 changed files with 49 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
arch/sparc/kernel/irq.c
View File

@ -46,6 +46,7 @@
#include <asm/pgtable.h> #include <asm/pgtable.h>
#include <asm/pcic.h> #include <asm/pcic.h>
#include <asm/cacheflush.h> #include <asm/cacheflush.h>
#include <asm/irq_regs.h>
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
#define SMP_NOP2 "nop; nop;\n\t" #define SMP_NOP2 "nop; nop;\n\t"
@ -133,8 +134,8 @@ static void irq_panic(void)
prom_halt(); prom_halt();
} }
void (*sparc_init_timers)(irqreturn_t (*)(int, void *,struct pt_regs *)) = void (*sparc_init_timers)(irqreturn_t (*)(int, void *)) =
(void (*)(irqreturn_t (*)(int, void *,struct pt_regs *))) irq_panic; (void (*)(irqreturn_t (*)(int, void *))) irq_panic;
/* /*
* Dave Redman (djhr@tadpole.co.uk) * Dave Redman (djhr@tadpole.co.uk)
@ -319,12 +320,14 @@ void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
void handler_irq(int irq, struct pt_regs * regs) void handler_irq(int irq, struct pt_regs * regs)
{ {
struct pt_regs *old_regs;
struct irqaction * action; struct irqaction * action;
int cpu = smp_processor_id(); int cpu = smp_processor_id();
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
extern void smp4m_irq_rotate(int cpu); extern void smp4m_irq_rotate(int cpu);
#endif #endif
old_regs = set_irq_regs(regs);
irq_enter(); irq_enter();
disable_pil_irq(irq); disable_pil_irq(irq);
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
@ -338,27 +341,31 @@ void handler_irq(int irq, struct pt_regs * regs)
do { do {
if (!action || !action->handler) if (!action || !action->handler)
unexpected_irq(irq, NULL, regs); unexpected_irq(irq, NULL, regs);
action->handler(irq, action->dev_id, regs); action->handler(irq, action->dev_id);
action = action->next; action = action->next;
} while (action); } while (action);
sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS; sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
enable_pil_irq(irq); enable_pil_irq(irq);
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
#ifdef CONFIG_BLK_DEV_FD #ifdef CONFIG_BLK_DEV_FD
extern void floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs); extern void floppy_interrupt(int irq, void *dev_id)
void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs) void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
{ {
struct pt_regs *old_regs;
int cpu = smp_processor_id(); int cpu = smp_processor_id();
old_regs = set_irq_regs(regs);
disable_pil_irq(irq); disable_pil_irq(irq);
irq_enter(); irq_enter();
kstat_cpu(cpu).irqs[irq]++; kstat_cpu(cpu).irqs[irq]++;
floppy_interrupt(irq, dev_id, regs); floppy_interrupt(irq, dev_id);
irq_exit(); irq_exit();
enable_pil_irq(irq); enable_pil_irq(irq);
set_irq_regs(old_regs);
// XXX Eek, it's totally changed with preempt_count() and such // XXX Eek, it's totally changed with preempt_count() and such
// if (softirq_pending(cpu)) // if (softirq_pending(cpu))
// do_softirq(); // do_softirq();
@ -369,7 +376,7 @@ void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
* thus no sharing possible. * thus no sharing possible.
*/ */
int request_fast_irq(unsigned int irq, int request_fast_irq(unsigned int irq,
irqreturn_t (*handler)(int, void *, struct pt_regs *), irqreturn_t (*handler)(int, void *),
unsigned long irqflags, const char *devname) unsigned long irqflags, const char *devname)
{ {
struct irqaction *action; struct irqaction *action;
@ -468,7 +475,7 @@ out:
} }
int request_irq(unsigned int irq, int request_irq(unsigned int irq,
irqreturn_t (*handler)(int, void *, struct pt_regs *), irqreturn_t (*handler)(int, void *),
unsigned long irqflags, const char * devname, void *dev_id) unsigned long irqflags, const char * devname, void *dev_id)
{ {
struct irqaction * action, **actionp; struct irqaction * action, **actionp;
@ -478,7 +485,7 @@ int request_irq(unsigned int irq,
if (sparc_cpu_model == sun4d) { if (sparc_cpu_model == sun4d) {
extern int sun4d_request_irq(unsigned int, extern int sun4d_request_irq(unsigned int,
irqreturn_t (*)(int, void *, struct pt_regs *), irqreturn_t (*)(int, void *),
unsigned long, const char *, void *); unsigned long, const char *, void *);
return sun4d_request_irq(irq, handler, irqflags, devname, dev_id); return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
} }

4
arch/sparc/kernel/pcic.c
View File

@ -708,13 +708,13 @@ static void pcic_clear_clock_irq(void)
pcic_timer_dummy = readl(pcic0.pcic_regs+PCI_SYS_LIMIT); pcic_timer_dummy = readl(pcic0.pcic_regs+PCI_SYS_LIMIT);
} }
static irqreturn_t pcic_timer_handler (int irq, void *h, struct pt_regs *regs) static irqreturn_t pcic_timer_handler (int irq, void *h)
{ {
write_seqlock(&xtime_lock); /* Dummy, to show that we remember */ write_seqlock(&xtime_lock); /* Dummy, to show that we remember */
pcic_clear_clock_irq(); pcic_clear_clock_irq();
do_timer(1); do_timer(1);
#ifndef CONFIG_SMP #ifndef CONFIG_SMP
update_process_times(user_mode(regs)); update_process_times(user_mode(get_irq_regs()));
#endif #endif
write_sequnlock(&xtime_lock); write_sequnlock(&xtime_lock);
return IRQ_HANDLED; return IRQ_HANDLED;

2
arch/sparc/kernel/sun4c_irq.c
View File

@ -154,7 +154,7 @@ static void sun4c_load_profile_irq(int cpu, unsigned int limit)
/* Errm.. not sure how to do this.. */ /* Errm.. not sure how to do this.. */
} }
static void __init sun4c_init_timers(irqreturn_t (*counter_fn)(int, void *, struct pt_regs *)) static void __init sun4c_init_timers(irqreturn_t (*counter_fn)(int, void *))
{ {
int irq; int irq;

12
arch/sparc/kernel/sun4d_irq.c
View File

@ -38,6 +38,7 @@
#include <asm/sbus.h> #include <asm/sbus.h>
#include <asm/sbi.h> #include <asm/sbi.h>
#include <asm/cacheflush.h> #include <asm/cacheflush.h>
#include <asm/irq_regs.h>
/* If you trust current SCSI layer to handle different SCSI IRQs, enable this. I don't trust it... -jj */ /* If you trust current SCSI layer to handle different SCSI IRQs, enable this. I don't trust it... -jj */
/* #define DISTRIBUTE_IRQS */ /* #define DISTRIBUTE_IRQS */
@ -198,6 +199,7 @@ extern void unexpected_irq(int, void *, struct pt_regs *);
void sun4d_handler_irq(int irq, struct pt_regs * regs) void sun4d_handler_irq(int irq, struct pt_regs * regs)
{ {
struct pt_regs *old_regs;
struct irqaction * action; struct irqaction * action;
int cpu = smp_processor_id(); int cpu = smp_processor_id();
/* SBUS IRQ level (1 - 7) */ /* SBUS IRQ level (1 - 7) */
@ -208,6 +210,7 @@ void sun4d_handler_irq(int irq, struct pt_regs * regs)
cc_set_iclr(1 << irq); cc_set_iclr(1 << irq);
old_regs = set_irq_regs(regs);
irq_enter(); irq_enter();
kstat_cpu(cpu).irqs[irq]++; kstat_cpu(cpu).irqs[irq]++;
if (!sbusl) { if (!sbusl) {
@ -215,7 +218,7 @@ void sun4d_handler_irq(int irq, struct pt_regs * regs)
if (!action) if (!action)
unexpected_irq(irq, NULL, regs); unexpected_irq(irq, NULL, regs);
do { do {
action->handler(irq, action->dev_id, regs); action->handler(irq, action->dev_id);
action = action->next; action = action->next;
} while (action); } while (action);
} else { } else {
@ -242,7 +245,7 @@ void sun4d_handler_irq(int irq, struct pt_regs * regs)
if (!action) if (!action)
unexpected_irq(irq, NULL, regs); unexpected_irq(irq, NULL, regs);
do { do {
action->handler(irq, action->dev_id, regs); action->handler(irq, action->dev_id);
action = action->next; action = action->next;
} while (action); } while (action);
release_sbi(SBI2DEVID(sbino), slot); release_sbi(SBI2DEVID(sbino), slot);
@ -250,6 +253,7 @@ void sun4d_handler_irq(int irq, struct pt_regs * regs)
} }
} }
irq_exit(); irq_exit();
set_irq_regs(old_regs);
} }
unsigned int sun4d_build_irq(struct sbus_dev *sdev, int irq) unsigned int sun4d_build_irq(struct sbus_dev *sdev, int irq)
@ -272,7 +276,7 @@ unsigned int sun4d_sbint_to_irq(struct sbus_dev *sdev, unsigned int sbint)
} }
int sun4d_request_irq(unsigned int irq, int sun4d_request_irq(unsigned int irq,
irqreturn_t (*handler)(int, void *, struct pt_regs *), irqreturn_t (*handler)(int, void *),
unsigned long irqflags, const char * devname, void *dev_id) unsigned long irqflags, const char * devname, void *dev_id)
{ {
struct irqaction *action, *tmp = NULL, **actionp; struct irqaction *action, *tmp = NULL, **actionp;
@ -466,7 +470,7 @@ static void sun4d_load_profile_irq(int cpu, unsigned int limit)
bw_set_prof_limit(cpu, limit); bw_set_prof_limit(cpu, limit);
} }
static void __init sun4d_init_timers(irqreturn_t (*counter_fn)(int, void *, struct pt_regs *)) static void __init sun4d_init_timers(irqreturn_t (*counter_fn)(int, void *))
{ {
int irq; int irq;
int cpu; int cpu;

6
arch/sparc/kernel/sun4d_smp.c
View File

@ -23,6 +23,7 @@
#include <asm/ptrace.h> #include <asm/ptrace.h>
#include <asm/atomic.h> #include <asm/atomic.h>
#include <asm/irq_regs.h>
#include <asm/delay.h> #include <asm/delay.h>
#include <asm/irq.h> #include <asm/irq.h>
@ -369,10 +370,12 @@ void smp4d_message_pass(int target, int msg, unsigned long data, int wait)
void smp4d_percpu_timer_interrupt(struct pt_regs *regs) void smp4d_percpu_timer_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs;
int cpu = hard_smp4d_processor_id(); int cpu = hard_smp4d_processor_id();
static int cpu_tick[NR_CPUS]; static int cpu_tick[NR_CPUS];
static char led_mask[] = { 0xe, 0xd, 0xb, 0x7, 0xb, 0xd }; static char led_mask[] = { 0xe, 0xd, 0xb, 0x7, 0xb, 0xd };
old_regs = set_irq_regs(regs);
bw_get_prof_limit(cpu); bw_get_prof_limit(cpu);
bw_clear_intr_mask(0, 1); /* INTR_TABLE[0] & 1 is Profile IRQ */ bw_clear_intr_mask(0, 1); /* INTR_TABLE[0] & 1 is Profile IRQ */
@ -384,7 +387,7 @@ void smp4d_percpu_timer_interrupt(struct pt_regs *regs)
show_leds(cpu); show_leds(cpu);
} }
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
if(!--prof_counter(cpu)) { if(!--prof_counter(cpu)) {
int user = user_mode(regs); int user = user_mode(regs);
@ -395,6 +398,7 @@ void smp4d_percpu_timer_interrupt(struct pt_regs *regs)
prof_counter(cpu) = prof_multiplier(cpu); prof_counter(cpu) = prof_multiplier(cpu);
} }
set_irq_regs(old_regs);
} }
extern unsigned int lvl14_resolution; extern unsigned int lvl14_resolution;

2
arch/sparc/kernel/sun4m_irq.c
View File

@ -228,7 +228,7 @@ static void sun4m_load_profile_irq(int cpu, unsigned int limit)
sun4m_timers->cpu_timers[cpu].l14_timer_limit = limit; sun4m_timers->cpu_timers[cpu].l14_timer_limit = limit;
} }
static void __init sun4m_init_timers(irqreturn_t (*counter_fn)(int, void *, struct pt_regs *)) static void __init sun4m_init_timers(irqreturn_t (*counter_fn)(int, void *))
{ {
int reg_count, irq, cpu; int reg_count, irq, cpu;
struct linux_prom_registers cnt_regs[PROMREG_MAX]; struct linux_prom_registers cnt_regs[PROMREG_MAX];

7
arch/sparc/kernel/sun4m_smp.c
View File

@ -19,6 +19,7 @@
#include <linux/profile.h> #include <linux/profile.h>
#include <asm/cacheflush.h> #include <asm/cacheflush.h>
#include <asm/tlbflush.h> #include <asm/tlbflush.h>
#include <asm/irq_regs.h>
#include <asm/ptrace.h> #include <asm/ptrace.h>
#include <asm/atomic.h> #include <asm/atomic.h>
@ -353,11 +354,14 @@ void smp4m_cross_call_irq(void)
void smp4m_percpu_timer_interrupt(struct pt_regs *regs) void smp4m_percpu_timer_interrupt(struct pt_regs *regs)
{ {
struct pt_regs *old_regs;
int cpu = smp_processor_id(); int cpu = smp_processor_id();
old_regs = set_irq_regs(regs);
clear_profile_irq(cpu); clear_profile_irq(cpu);
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
if(!--prof_counter(cpu)) { if(!--prof_counter(cpu)) {
int user = user_mode(regs); int user = user_mode(regs);
@ -368,6 +372,7 @@ void smp4m_percpu_timer_interrupt(struct pt_regs *regs)
prof_counter(cpu) = prof_multiplier(cpu); prof_counter(cpu) = prof_multiplier(cpu);
} }
set_irq_regs(old_regs);
} }
extern unsigned int lvl14_resolution; extern unsigned int lvl14_resolution;

2
arch/sparc/kernel/tick14.c
View File

@ -55,7 +55,7 @@ void install_obp_ticker(void)
linux_lvl14[3] = obp_lvl14[3]; linux_lvl14[3] = obp_lvl14[3];
} }
void claim_ticker14(irqreturn_t (*handler)(int, void *, struct pt_regs *), void claim_ticker14(irqreturn_t (*handler)(int, void *),
int irq_nr, unsigned int timeout ) int irq_nr, unsigned int timeout )
{ {
int cpu = smp_processor_id(); int cpu = smp_processor_id();

7
arch/sparc/kernel/time.c
View File

@ -42,6 +42,7 @@
#include <asm/page.h> #include <asm/page.h>
#include <asm/pcic.h> #include <asm/pcic.h>
#include <asm/of_device.h> #include <asm/of_device.h>
#include <asm/irq_regs.h>
DEFINE_SPINLOCK(rtc_lock); DEFINE_SPINLOCK(rtc_lock);
enum sparc_clock_type sp_clock_typ; enum sparc_clock_type sp_clock_typ;
@ -104,13 +105,13 @@ __volatile__ unsigned int *master_l10_limit;
#define TICK_SIZE (tick_nsec / 1000) #define TICK_SIZE (tick_nsec / 1000)
irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs * regs) irqreturn_t timer_interrupt(int irq, void *dev_id)
{ {
/* last time the cmos clock got updated */ /* last time the cmos clock got updated */
static long last_rtc_update; static long last_rtc_update;
#ifndef CONFIG_SMP #ifndef CONFIG_SMP
profile_tick(CPU_PROFILING, regs); profile_tick(CPU_PROFILING);
#endif #endif
/* Protect counter clear so that do_gettimeoffset works */ /* Protect counter clear so that do_gettimeoffset works */
@ -128,7 +129,7 @@ irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs * regs)
do_timer(1); do_timer(1);
#ifndef CONFIG_SMP #ifndef CONFIG_SMP
update_process_times(user_mode(regs)); update_process_times(user_mode(get_irq_regs()));
#endif #endif

2
drivers/parport/parport_sunbpp.c
View File

@ -48,7 +48,7 @@
static irqreturn_t parport_sunbpp_interrupt(int irq, void *dev_id) static irqreturn_t parport_sunbpp_interrupt(int irq, void *dev_id)
{ {
parport_generic_irq(irq, (struct parport *) dev_id, regs); parport_generic_irq(irq, (struct parport *) dev_id);
return IRQ_HANDLED; return IRQ_HANDLED;
} }

2
include/asm-sparc/floppy.h
View File

@ -262,7 +262,7 @@ static __inline__ void sun_fd_enable_dma(void)
} }
/* Our low-level entry point in arch/sparc/kernel/entry.S */ /* Our low-level entry point in arch/sparc/kernel/entry.S */
irqreturn_t floppy_hardint(int irq, void *unused, struct pt_regs *regs); irqreturn_t floppy_hardint(int irq, void *unused);
static int sun_fd_request_irq(void) static int sun_fd_request_irq(void)
{ {

6
include/asm-sparc/irq.h
View File

@ -76,8 +76,8 @@ static inline void load_profile_irq(int cpu, int limit)
BTFIXUP_CALL(load_profile_irq)(cpu, limit); BTFIXUP_CALL(load_profile_irq)(cpu, limit);
} }
extern void (*sparc_init_timers)(irqreturn_t (*lvl10_irq)(int, void *, struct pt_regs *)); extern void (*sparc_init_timers)(irqreturn_t (*lvl10_irq)(int, void *));
extern void claim_ticker14(irqreturn_t (*irq_handler)(int, void *, struct pt_regs *), extern void claim_ticker14(irqreturn_t (*irq_handler)(int, void *),
int irq, int irq,
unsigned int timeout); unsigned int timeout);
@ -91,7 +91,7 @@ BTFIXUPDEF_CALL(void, set_irq_udt, int)
#define set_irq_udt(cpu) BTFIXUP_CALL(set_irq_udt)(cpu) #define set_irq_udt(cpu) BTFIXUP_CALL(set_irq_udt)(cpu)
#endif #endif
extern int request_fast_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, __const__ char *devname); extern int request_fast_irq(unsigned int irq, irqreturn_t (*handler)(int, void *), unsigned long flags, __const__ char *devname);
/* On the sun4m, just like the timers, we have both per-cpu and master /* On the sun4m, just like the timers, we have both per-cpu and master
* interrupt registers. * interrupt registers.

1
include/asm-sparc/irq_regs.h Normal file
View File

@ -0,0 +1 @@
#include <asm-generic/irq_regs.h>