| /* |
| * arch/s390/kernel/irq.c |
| * |
| * S390 version |
| * Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation |
| * Author(s): Ingo Adlung (adlung@de.ibm.com) |
| * |
| * Derived from "arch/i386/kernel/irq.c" |
| * Copyright (C) 1992, 1999 Linus Torvalds, Ingo Molnar |
| * |
| * S/390 I/O interrupt processing and I/O request processing is |
| * implemented in arch/s390/kernel/s390io.c |
| */ |
| #include <linux/module.h> |
| #include <linux/config.h> |
| #include <linux/ptrace.h> |
| #include <linux/errno.h> |
| #include <linux/kernel_stat.h> |
| #include <linux/signal.h> |
| #include <linux/sched.h> |
| #include <linux/ioport.h> |
| #include <linux/interrupt.h> |
| #include <linux/timex.h> |
| #include <linux/slab.h> |
| #include <linux/string.h> |
| #include <linux/random.h> |
| #include <linux/smp.h> |
| #include <linux/threads.h> |
| #include <linux/smp_lock.h> |
| #include <linux/init.h> |
| |
| #include <asm/system.h> |
| #include <asm/io.h> |
| #include <asm/irq.h> |
| #include <asm/bitops.h> |
| #include <asm/smp.h> |
| #include <asm/pgtable.h> |
| #include <asm/delay.h> |
| #include <asm/lowcore.h> |
| |
| void s390_init_IRQ ( void ); |
| void s390_free_irq ( unsigned int irq, void *dev_id); |
| int s390_request_irq( unsigned int irq, |
| void (*handler)(int, void *, struct pt_regs *), |
| unsigned long irqflags, |
| const char *devname, |
| void *dev_id); |
| |
| #if 0 |
| /* |
| * The following vectors are part of the Linux architecture, there |
| * is no hardware IRQ pin equivalent for them, they are triggered |
| * through the ICC by us (IPIs), via smp_message_pass(): |
| */ |
| BUILD_SMP_INTERRUPT(reschedule_interrupt) |
| BUILD_SMP_INTERRUPT(invalidate_interrupt) |
| BUILD_SMP_INTERRUPT(stop_cpu_interrupt) |
| BUILD_SMP_INTERRUPT(mtrr_interrupt) |
| BUILD_SMP_INTERRUPT(spurious_interrupt) |
| #endif |
| |
| /* |
| * Global interrupt locks for SMP. Allow interrupts to come in on any |
| * CPU, yet make cli/sti act globally to protect critical regions.. |
| */ |
| #ifdef CONFIG_SMP |
| atomic_t global_irq_holder = ATOMIC_INIT(NO_PROC_ID); |
| atomic_t global_irq_lock = ATOMIC_INIT(0); |
| atomic_t global_irq_count = ATOMIC_INIT(0); |
| atomic_t global_bh_count; |
| |
| /* |
| * "global_cli()" is a special case, in that it can hold the |
| * interrupts disabled for a longish time, and also because |
| * we may be doing TLB invalidates when holding the global |
| * IRQ lock for historical reasons. Thus we may need to check |
| * SMP invalidate events specially by hand here (but not in |
| * any normal spinlocks) |
| * |
| * Thankfully we don't need this as we can deliver flush tlbs with |
| * interrupts disabled DJB :-) |
| */ |
| #define check_smp_invalidate(cpu) |
| |
| static void show(char * str) |
| { |
| int i; |
| unsigned long *stack; |
| int cpu = smp_processor_id(); |
| |
| printk("\n%s, CPU %d:\n", str, cpu); |
| printk("irq: %d [%d]\n", |
| atomic_read(&global_irq_count),local_irq_count(smp_processor_id())); |
| printk("bh: %d [%d]\n", |
| atomic_read(&global_bh_count),local_bh_count(smp_processor_id())); |
| stack = (unsigned long *) &str; |
| for (i = 40; i ; i--) { |
| unsigned long x = *++stack; |
| if (x > (unsigned long) &init_task_union && x < (unsigned long) &vsprintf) { |
| printk("<[%08lx]> ", x); |
| } |
| } |
| } |
| |
| #define MAXCOUNT 100000000 |
| |
| static inline void wait_on_bh(void) |
| { |
| int count = MAXCOUNT; |
| do { |
| if (!--count) { |
| show("wait_on_bh"); |
| count = ~0; |
| } |
| /* nothing .. wait for the other bh's to go away */ |
| } while (atomic_read(&global_bh_count) != 0); |
| } |
| |
| static inline void wait_on_irq(int cpu) |
| { |
| int count = MAXCOUNT; |
| |
| for (;;) { |
| |
| /* |
| * Wait until all interrupts are gone. Wait |
| * for bottom half handlers unless we're |
| * already executing in one.. |
| */ |
| if (!atomic_read(&global_irq_count)) { |
| if (local_bh_count(cpu)|| |
| !atomic_read(&global_bh_count)) |
| break; |
| } |
| |
| /* Duh, we have to loop. Release the lock to avoid deadlocks */ |
| atomic_set(&global_irq_lock, 0); |
| |
| for (;;) { |
| if (!--count) { |
| show("wait_on_irq"); |
| count = ~0; |
| } |
| __sti(); |
| SYNC_OTHER_CORES(cpu); |
| __cli(); |
| check_smp_invalidate(cpu); |
| if (atomic_read(&global_irq_count)) |
| continue; |
| if (atomic_read(&global_irq_lock)) |
| continue; |
| if (!local_bh_count(cpu) |
| && atomic_read(&global_bh_count)) |
| continue; |
| if (!atomic_compare_and_swap(0, 1, &global_irq_lock)) |
| break; |
| } |
| } |
| } |
| |
| /* |
| * This is called when we want to synchronize with |
| * bottom half handlers. We need to wait until |
| * no other CPU is executing any bottom half handler. |
| * |
| * Don't wait if we're already running in an interrupt |
| * context or are inside a bh handler. |
| */ |
| void synchronize_bh(void) |
| { |
| if (atomic_read(&global_bh_count) && !in_interrupt()) |
| wait_on_bh(); |
| } |
| |
| /* |
| * This is called when we want to synchronize with |
| * interrupts. We may for example tell a device to |
| * stop sending interrupts: but to make sure there |
| * are no interrupts that are executing on another |
| * CPU we need to call this function. |
| */ |
| void synchronize_irq(void) |
| { |
| if (atomic_read(&global_irq_count)) { |
| /* Stupid approach */ |
| cli(); |
| sti(); |
| } |
| } |
| |
| static inline void get_irqlock(int cpu) |
| { |
| if (atomic_compare_and_swap(0,1,&global_irq_lock) != 0) { |
| /* do we already hold the lock? */ |
| if ( cpu == atomic_read(&global_irq_holder)) |
| return; |
| /* Uhhuh.. Somebody else got it. Wait.. */ |
| do { |
| check_smp_invalidate(cpu); |
| } while (atomic_compare_and_swap(0,1,&global_irq_lock) != 0); |
| } |
| /* |
| * We also to make sure that nobody else is running |
| * in an interrupt context. |
| */ |
| wait_on_irq(cpu); |
| |
| /* |
| * Ok, finally.. |
| */ |
| atomic_set(&global_irq_holder,cpu); |
| } |
| |
| #define EFLAGS_I_SHIFT 57 |
| |
| /* |
| * A global "cli()" while in an interrupt context |
| * turns into just a local cli(). Interrupts |
| * should use spinlocks for the (very unlikely) |
| * case that they ever want to protect against |
| * each other. |
| * |
| * If we already have local interrupts disabled, |
| * this will not turn a local disable into a |
| * global one (problems with spinlocks: this makes |
| * save_flags+cli+sti usable inside a spinlock). |
| */ |
| void __global_cli(void) |
| { |
| unsigned long flags; |
| |
| __save_flags(flags); |
| if (flags & (1UL << EFLAGS_I_SHIFT)) { |
| int cpu = smp_processor_id(); |
| __cli(); |
| if (!in_irq()) |
| get_irqlock(cpu); |
| } |
| } |
| |
| void __global_sti(void) |
| { |
| |
| if (!in_irq()) |
| release_irqlock(smp_processor_id()); |
| __sti(); |
| } |
| |
| /* |
| * SMP flags value to restore to: |
| * 0 - global cli |
| * 1 - global sti |
| * 2 - local cli |
| * 3 - local sti |
| */ |
| unsigned long __global_save_flags(void) |
| { |
| int retval; |
| int local_enabled; |
| unsigned long flags; |
| |
| __save_flags(flags); |
| local_enabled = (flags >> EFLAGS_I_SHIFT) & 1; |
| /* default to local */ |
| retval = 2 + local_enabled; |
| |
| /* check for global flags if we're not in an interrupt */ |
| if (!in_irq()) |
| { |
| if (local_enabled) |
| retval = 1; |
| if (atomic_read(&global_irq_holder)== smp_processor_id()) |
| retval = 0; |
| } |
| return retval; |
| } |
| |
| void __global_restore_flags(unsigned long flags) |
| { |
| switch (flags) { |
| case 0: |
| __global_cli(); |
| break; |
| case 1: |
| __global_sti(); |
| break; |
| case 2: |
| __cli(); |
| break; |
| case 3: |
| __sti(); |
| break; |
| default: |
| printk("global_restore_flags: %08lx (%08lx)\n", |
| flags, (&flags)[-1]); |
| } |
| } |
| |
| #endif |
| |
| |
| void __init init_IRQ(void) |
| { |
| s390_init_IRQ(); |
| } |
| |
| |
| void free_irq(unsigned int irq, void *dev_id) |
| { |
| s390_free_irq( irq, dev_id); |
| } |
| |
| |
| int request_irq( unsigned int irq, |
| void (*handler)(int, void *, struct pt_regs *), |
| unsigned long irqflags, |
| const char *devname, |
| void *dev_id) |
| { |
| return( s390_request_irq( irq, handler, irqflags, devname, dev_id ) ); |
| |
| } |
| |
| void init_irq_proc(void) |
| { |
| /* For now, nothing... */ |
| } |
| |
| #ifdef CONFIG_SMP |
| EXPORT_SYMBOL(__global_cli); |
| EXPORT_SYMBOL(__global_sti); |
| EXPORT_SYMBOL(__global_save_flags); |
| EXPORT_SYMBOL(__global_restore_flags); |
| EXPORT_SYMBOL(global_irq_holder); |
| EXPORT_SYMBOL(global_irq_lock); |
| EXPORT_SYMBOL(global_irq_count); |
| EXPORT_SYMBOL(global_bh_count); |
| #endif |
| |
| EXPORT_SYMBOL(global_bh_lock); |