Return to irq.c CVS log

Up to [Early Linux] / linux / kernel

Annotation of linux/kernel/irq.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     linux/kernel/irq.c
        !             3:  *
        !             4:  *     Copyright (C) 1992 Linus Torvalds
        !             5:  *
        !             6:  * This file contains the code used by various IRQ handling routines:
        !             7:  * asking for different IRQ's should be done through these routines
        !             8:  * instead of just grabbing them. Thus setups with different IRQ numbers
        !             9:  * shouldn't result in any weird surprises, and installing new handlers
        !            10:  * should be easier.
        !            11:  */
        !            12: 
        !            13: /*
        !            14:  * IRQ's are in fact implemented a bit like signal handlers for the kernel.
        !            15:  * The same sigaction struct is used, and with similar semantics (ie there
        !            16:  * is a SA_INTERRUPT flag etc). Naturally it's not a 1:1 relation, but there
        !            17:  * are similarities.
        !            18:  *
        !            19:  * sa_handler(int irq_NR) is the default function called.
        !            20:  * sa_mask is 0 if nothing uses this IRQ
        !            21:  * sa_flags contains various info: SA_INTERRUPT etc
        !            22:  * sa_restorer is the unused
        !            23:  */
        !            24: 
        !            25: #include <linux/ptrace.h>
        !            26: #include <linux/errno.h>
        !            27: #include <linux/signal.h>
        !            28: #include <linux/sched.h>
        !            29: 
        !            30: #include <asm/system.h>
        !            31: #include <asm/io.h>
        !            32: #include <asm/irq.h>
        !            33: 
        !            34: void irq13(void);
        !            35: 
        !            36: /*
        !            37:  * This builds up the IRQ handler stubs using some ugly macros in irq.h
        !            38:  *
        !            39:  * These macros create the low-level assembly IRQ routines that do all
        !            40:  * the operations that are needed to keep the AT interrupt-controller
        !            41:  * happy. They are also written to be fast - and to disable interrupts
        !            42:  * as little as humanly possible.
        !            43:  *
        !            44:  * NOTE! These macros expand to three different handlers for each line: one
        !            45:  * complete handler that does all the fancy stuff (including signal handling),
        !            46:  * and one fast handler that is meant for simple IRQ's that want to be
        !            47:  * atomic. The specific handler is chosen depending on the SA_INTERRUPT
        !            48:  * flag when installing a handler. Finally, one "bad interrupt" handler, that
        !            49:  * is used when no handler is present.
        !            50:  */
        !            51: BUILD_IRQ(FIRST,0,0x01)
        !            52: BUILD_IRQ(FIRST,1,0x02)
        !            53: BUILD_IRQ(FIRST,2,0x04)
        !            54: BUILD_IRQ(FIRST,3,0x08)
        !            55: BUILD_IRQ(FIRST,4,0x10)
        !            56: BUILD_IRQ(FIRST,5,0x20)
        !            57: BUILD_IRQ(FIRST,6,0x40)
        !            58: BUILD_IRQ(FIRST,7,0x80)
        !            59: BUILD_IRQ(SECOND,8,0x01)
        !            60: BUILD_IRQ(SECOND,9,0x02)
        !            61: BUILD_IRQ(SECOND,10,0x04)
        !            62: BUILD_IRQ(SECOND,11,0x08)
        !            63: BUILD_IRQ(SECOND,12,0x10)
        !            64: BUILD_IRQ(SECOND,13,0x20)
        !            65: BUILD_IRQ(SECOND,14,0x40)
        !            66: BUILD_IRQ(SECOND,15,0x80)
        !            67: 
        !            68: /*
        !            69:  * Pointers to the low-level handlers: first the general ones, then the
        !            70:  * fast ones, then the bad ones.
        !            71:  */
        !            72: static void (*interrupt[16])(void) = {
        !            73:        IRQ0_interrupt, IRQ1_interrupt, IRQ2_interrupt, IRQ3_interrupt,
        !            74:        IRQ4_interrupt, IRQ5_interrupt, IRQ6_interrupt, IRQ7_interrupt,
        !            75:        IRQ8_interrupt, IRQ9_interrupt, IRQ10_interrupt, IRQ11_interrupt,
        !            76:        IRQ12_interrupt, IRQ13_interrupt, IRQ14_interrupt, IRQ15_interrupt
        !            77: };
        !            78: 
        !            79: static void (*fast_interrupt[16])(void) = {
        !            80:        fast_IRQ0_interrupt, fast_IRQ1_interrupt,
        !            81:        fast_IRQ2_interrupt, fast_IRQ3_interrupt,
        !            82:        fast_IRQ4_interrupt, fast_IRQ5_interrupt,
        !            83:        fast_IRQ6_interrupt, fast_IRQ7_interrupt,
        !            84:        fast_IRQ8_interrupt, fast_IRQ9_interrupt,
        !            85:        fast_IRQ10_interrupt, fast_IRQ11_interrupt,
        !            86:        fast_IRQ12_interrupt, fast_IRQ13_interrupt,
        !            87:        fast_IRQ14_interrupt, fast_IRQ15_interrupt
        !            88: };
        !            89: 
        !            90: static void (*bad_interrupt[16])(void) = {
        !            91:        bad_IRQ0_interrupt, bad_IRQ1_interrupt,
        !            92:        bad_IRQ2_interrupt, bad_IRQ3_interrupt,
        !            93:        bad_IRQ4_interrupt, bad_IRQ5_interrupt,
        !            94:        bad_IRQ6_interrupt, bad_IRQ7_interrupt,
        !            95:        bad_IRQ8_interrupt, bad_IRQ9_interrupt,
        !            96:        bad_IRQ10_interrupt, bad_IRQ11_interrupt,
        !            97:        bad_IRQ12_interrupt, bad_IRQ13_interrupt,
        !            98:        bad_IRQ14_interrupt, bad_IRQ15_interrupt
        !            99: };
        !           100: 
        !           101: /*
        !           102:  * Initial irq handlers.
        !           103:  */
        !           104: static struct sigaction irq_sigaction[16] = {
        !           105:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL },
        !           106:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL },
        !           107:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL },
        !           108:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL },
        !           109:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL },
        !           110:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL },
        !           111:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL },
        !           112:        { NULL, 0, 0, NULL }, { NULL, 0, 0, NULL }
        !           113: };
        !           114: 
        !           115: /*
        !           116:  * do_IRQ handles IRQ's that have been installed without the
        !           117:  * SA_INTERRUPT flag: it uses the full signal-handling return
        !           118:  * and runs with other interrupts disabled. All relatively slow
        !           119:  * IRQ's should use this format: notably the keyboard/timer
        !           120:  * routines.
        !           121:  */
        !           122: int do_IRQ(int irq, struct pt_regs * regs)
        !           123: {
        !           124:        struct sigaction * sa = irq + irq_sigaction;
        !           125: 
        !           126:        sa->sa_handler((int) regs);
        !           127:        return 0;               /* re-enable the irq when returning */
        !           128: }
        !           129: 
        !           130: /*
        !           131:  * do_fast_IRQ handles IRQ's that don't need the fancy interrupt return
        !           132:  * stuff - the handler is also running with interrupts disabled unless
        !           133:  * it explicitly enables them later.
        !           134:  */
        !           135: int do_fast_IRQ(int irq)
        !           136: {
        !           137:        struct sigaction * sa = irq + irq_sigaction;
        !           138: 
        !           139:        sa->sa_handler(0);
        !           140:        return 0;               /* re-enable the irq when returning */
        !           141: }
        !           142: 
        !           143: int irqaction(unsigned int irq, struct sigaction * new)
        !           144: {
        !           145:        struct sigaction * sa;
        !           146:        unsigned long flags;
        !           147: 
        !           148:        if (irq > 15)
        !           149:                return -EINVAL;
        !           150:        sa = irq + irq_sigaction;
        !           151:        if (sa->sa_mask)
        !           152:                return -EBUSY;
        !           153:        if (!new->sa_handler)
        !           154:                return -EINVAL;
        !           155:        __asm__ __volatile__("pushfl ; popl %0 ; cli":"=r" (flags));
        !           156:        *sa = *new;
        !           157:        sa->sa_mask = 1;
        !           158:        if (sa->sa_flags & SA_INTERRUPT)
        !           159:                set_intr_gate(0x20+irq,fast_interrupt[irq]);
        !           160:        else
        !           161:                set_intr_gate(0x20+irq,interrupt[irq]);
        !           162:        if (irq < 8)
        !           163:                outb(inb_p(0x21) & ~(1<<irq),0x21);
        !           164:        else {
        !           165:                outb(inb_p(0x21) & ~(1<<2),0x21);
        !           166:                outb(inb_p(0xA1) & ~(1<<(irq-8)),0xA1);
        !           167:        }
        !           168:        __asm__ __volatile__("pushl %0 ; popfl"::"r" (flags));
        !           169:        return 0;
        !           170: }
        !           171:                
        !           172: int request_irq(unsigned int irq, void (*handler)(int))
        !           173: {
        !           174:        struct sigaction sa;
        !           175: 
        !           176:        sa.sa_handler = handler;
        !           177:        sa.sa_flags = 0;
        !           178:        sa.sa_mask = 0;
        !           179:        sa.sa_restorer = NULL;
        !           180:        return irqaction(irq,&sa);
        !           181: }
        !           182: 
        !           183: void free_irq(unsigned int irq)
        !           184: {
        !           185:        struct sigaction * sa = irq + irq_sigaction;
        !           186:        unsigned long flags;
        !           187: 
        !           188:        if (irq > 15) {
        !           189:                printk("Trying to free IRQ%d\n",irq);
        !           190:                return;
        !           191:        }
        !           192:        if (!sa->sa_mask) {
        !           193:                printk("Trying to free free IRQ%d\n",irq);
        !           194:                return;
        !           195:        }
        !           196:        __asm__ __volatile__("pushfl ; popl %0 ; cli":"=r" (flags));
        !           197:        if (irq < 8)
        !           198:                outb(inb_p(0x21) | (1<<irq),0x21);
        !           199:        else
        !           200:                outb(inb_p(0xA1) | (1<<(irq-8)),0xA1);
        !           201:        set_intr_gate(0x20+irq,bad_interrupt[irq]);
        !           202:        sa->sa_handler = NULL;
        !           203:        sa->sa_flags = 0;
        !           204:        sa->sa_mask = 0;
        !           205:        sa->sa_restorer = NULL;
        !           206:        __asm__ __volatile__("pushl %0 ; popfl"::"r" (flags));
        !           207: }
        !           208: 
        !           209: extern void do_coprocessor_error(long,long);
        !           210: 
        !           211: static void math_error_irq(int cpl)
        !           212: {
        !           213:        outb(0,0xF0);
        !           214:        do_coprocessor_error(0,0);
        !           215: }
        !           216: 
        !           217: static void no_action(int cpl) { }
        !           218: 
        !           219: static struct sigaction ignore_IRQ = {
        !           220:        no_action,
        !           221:        0,
        !           222:        SA_INTERRUPT,
        !           223:        NULL
        !           224: };
        !           225: 
        !           226: void init_IRQ(void)
        !           227: {
        !           228:        int i;
        !           229: 
        !           230:        for (i = 0; i < 16 ; i++)
        !           231:                set_intr_gate(0x20+i,bad_interrupt[i]);
        !           232:        if (irqaction(2,&ignore_IRQ))
        !           233:                printk("Unable to get IRQ2 for cascade\n");
        !           234:        if (request_irq(13,math_error_irq))
        !           235:                printk("Unable to get IRQ13 for math-error handler\n");
        !           236: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.