/************************************************************************
| Plik linux/include/asm/irq.h dla i386 |
| Skomentował Piotr Hoffman |
| Plik zawiera makra wykorzystane następnie w pliku irq.c |
| Makra te definiują obsługę przerwań sprzętowych najniższego |
| poziomu. |
| Duża część pliku dotyczy wyłącznie SMP - tego nie komentowałem |
| Wytłumaczenie wielu szczegółów, m.in. pewnych elementów |
| składni wykorzystanego asemblera można znaleźć |
| tutaj. |
|***********************************************************************/
/************************************************************************
| Przyjmuję metodę komentowania definicji asemblerowego makra |
| przed tą definicją, a nie wewnątrz niej. Składnia tych poleceń |
| jest tak okropna, że lepiej wcześniej w komentarzu pokazać |
| wyczyszczoną wersję. |
************************************************************************/
#ifndef _ASM_IRQ_H
#define _ASM_IRQ_H
/*
* linux/include/asm/irq.h
*
* (C) 1992, 1993 Linus Torvalds
*
* IRQ/IPI changes taken from work by Thomas Radke
*/
#include < linux/linkage.h>
#include < asm/segment.h>
#define NR_IRQS 16
#define TIMER_IRQ 0
extern void disable_irq(unsigned int);
extern void enable_irq(unsigned int);
#define __STR(x) #x
#define STR(x) __STR(x)
/************************************************************************
| Odpowiednikiem tego jest RESTORE_ALL |
| z pliku entry.S |
| RESTORE_ALL odwraca SAVE_ALL, ale potem usuwa 4 bajty ze stosu |
| i wykonuje iret |
************************************************************************/
#define SAVE_ALL \
"cld\n\t" \
"push %gs\n\t" \
"push %fs\n\t" \
"push %es\n\t" \
"push %ds\n\t" \
"pushl %eax\n\t" \
"pushl %ebp\n\t" \
"pushl %edi\n\t" \
"pushl %esi\n\t" \
"pushl %edx\n\t" \
"pushl %ecx\n\t" \
"pushl %ebx\n\t" \
"movl $" STR(KERNEL_DS) ",%edx\n\t" \
"mov %dx,%ds\n\t" \
"mov %dx,%es\n\t" \
"movl $" STR(USER_DS) ",%edx\n\t" \
"mov %dx,%fs\n\t" \
"movl $0,%edx\n\t" \
"movl %edx,%db7\n\t"
/*
* SAVE_MOST/RESTORE_MOST is used for the faster version of IRQ handlers,
* installed by using the SA_INTERRUPT flag. These kinds of IRQ's don't
* call the routines that do signal handling etc on return, and can have
* more relaxed register-saving etc. They are also atomic, and are thus
* suited for small, fast interrupts like the serial lines or the harddisk
* drivers, which don't actually need signal handling etc.
*
* Also note that we actually save only those registers that are used in
* C subroutines (%eax, %edx and %ecx), so if you do something weird,
* you're on your own. The only segments that are saved (not counting the
* automatic stack and code segment handling) are %ds and %es, and they
* point to kernel space. No messing around with %fs here.
*/
#define SAVE_MOST \
"cld\n\t" \
"push %es\n\t" \
"push %ds\n\t" \
"pushl %eax\n\t" \
"pushl %edx\n\t" \
"pushl %ecx\n\t" \
"movl $" STR(KERNEL_DS) ",%edx\n\t" \
"mov %dx,%ds\n\t" \
"mov %dx,%es\n\t"
#define RESTORE_MOST \
"popl %ecx\n\t" \
"popl %edx\n\t" \
"popl %eax\n\t" \
"pop %ds\n\t" \
"pop %es\n\t" \
"iret"
/*
* The "inb" instructions are not needed, but seem to change the timings
* a bit - without them it seems that the harddisk driver won't work on
* all hardware. Arghh.
*/
/************************************************************************
| Blokuje przerwanie nr na pierwszym sterowniku. Uaktualnia |
| wartość zmiennej cache_21. Wysyła non-specific end of interrupt |
| (EOI) do pierwszego sterownika. W ten sposób odblokowuje |
| pozostałe przerwania na sterowniku. |
*************************************************************************/
#define ACK_FIRST(mask,nr) \
"inb $0x21,%al\n\t" \
"jmp 1f\n" \
"1:\tjmp 1f\n" \
"1:\torb $" #mask ","SYMBOL_NAME_STR(cache_21)"\n\t" \
"movb "SYMBOL_NAME_STR(cache_21)",%al\n\t" \
"outb %al,$0x21\n\t" \
"jmp 1f\n" \
"1:\tjmp 1f\n" \
"1:\tmovb $0x20,%al\n\t" \
"outb %al,$0x20\n\t"
/************************************************************************
| Blokuje przerwanie nr na drugim sterowniku. Uaktualnia |
| wartość zmiennej cache_A1. Wysyła non-specific end of interrupt |
| (EOI) do drugiego sterownika. Następnie wysyła EOI do pierwszego|
| sterownika. |
*************************************************************************/
#define ACK_SECOND(mask,nr) \
"inb $0xA1,%al\n\t" \
"jmp 1f\n" \
"1:\tjmp 1f\n" \
"1:\torb $" #mask ","SYMBOL_NAME_STR(cache_A1)"\n\t" \
"movb "SYMBOL_NAME_STR(cache_A1)",%al\n\t" \
"outb %al,$0xA1\n\t" \
"jmp 1f\n" \
"1:\tjmp 1f\n" \
"1:\tmovb $0x20,%al\n\t" \
"outb %al,$0xA0\n\t" \
"jmp 1f\n" \
"1:\tjmp 1f\n" \
"1:\toutb %al,$0x20\n\t"
/************************************************************************
| Odblokowuje przerwanie o numerze nr na pierwszym sterowniku |
| i ukatualnia wartość zmiennej cache_21. |
*************************************************************************/
#define UNBLK_FIRST(mask) \
"inb $0x21,%al\n\t" \
"jmp 1f\n" \
"1:\tjmp 1f\n" \
"1:\tandb $~(" #mask "),"SYMBOL_NAME_STR(cache_21)"\n\t" \
"movb "SYMBOL_NAME_STR(cache_21)",%al\n\t" \
"outb %al,$0x21\n\t"
/************************************************************************
| Odblokowuje przerwanie o numerze nr na drugim sterowniku |
| i ukatualnia wartość zmiennej cache_A1. |
*************************************************************************/
#define UNBLK_SECOND(mask) \
"inb $0xA1,%al\n\t" \
"jmp 1f\n" \
"1:\tjmp 1f\n" \
"1:\tandb $~(" #mask "),"SYMBOL_NAME_STR(cache_A1)"\n\t" \
"movb "SYMBOL_NAME_STR(cache_A1)",%al\n\t" \
"outb %al,$0xA1\n\t"
/************************************************************************
| Po tych definicjach IRQ_NAME(5) oznacza IRQ5_interrupt(void), |
| FAST_IRQ_NAME(5) oznacza fast_IRQ5_interrupt(void), a |
| BAD_IRQ_NAME(5) oznacza bad_IRQ5_interrupt(void). |
*************************************************************************/
#define IRQ_NAME2(nr) nr##_interrupt(void)
#define IRQ_NAME(nr) IRQ_NAME2(IRQ##nr)
#define FAST_IRQ_NAME(nr) IRQ_NAME2(fast_IRQ##nr)
#define BAD_IRQ_NAME(nr) IRQ_NAME2(bad_IRQ##nr)
/************************************************************************
| SMP - pomijam |
*************************************************************************/
#ifdef __SMP__
#ifndef __SMP_PROF__
#define SMP_PROF_INT_SPINS
#define SMP_PROF_IPI_CNT
#else
#define SMP_PROF_INT_SPINS "incl "SYMBOL_NAME_STR(smp_spins)"(,%eax,4)\n\t"
#define SMP_PROF_IPI_CNT "incl "SYMBOL_NAME_STR(ipi_count)"\n\t"
#endif
#define GET_PROCESSOR_ID \
"movl "SYMBOL_NAME_STR(apic_reg)", %edx\n\t" \
"movl 32(%edx), %eax\n\t" \
"shrl $24,%eax\n\t" \
"andb $0x0F,%al\n"
#define ENTER_KERNEL \
"pushl %eax\n\t" \
"pushl %ebx\n\t" \
"pushl %ecx\n\t" \
"pushl %edx\n\t" \
"pushfl\n\t" \
"cli\n\t" \
"movl $6000, %ebx\n\t" \
"movl "SYMBOL_NAME_STR(smp_loops_per_tick)", %ecx\n\t" \
GET_PROCESSOR_ID \
"btsl $" STR(SMP_FROM_INT) ","SYMBOL_NAME_STR(smp_proc_in_lock)"(,%eax,4)\n\t" \
"1: " \
"lock\n\t" \
"btsl $0, "SYMBOL_NAME_STR(kernel_flag)"\n\t" \
"jnc 3f\n\t" \
"cmpb "SYMBOL_NAME_STR(active_kernel_processor)", %al\n\t" \
"je 4f\n\t" \
"movb $1, "SYMBOL_NAME_STR(smp_blocked_interrupt_pending)"\n\t" \
"2: " \
SMP_PROF_INT_SPINS \
"btl %al, "SYMBOL_NAME_STR(smp_invalidate_needed)"\n\t" \
"jnc 5f\n\t" \
"lock\n\t" \
"btrl %al, "SYMBOL_NAME_STR(smp_invalidate_needed)"\n\t" \
"jnc 5f\n\t" \
"movl %cr3,%edx\n\t" \
"movl %edx,%cr3\n" \
"5: btl $0, "SYMBOL_NAME_STR(kernel_flag)"\n\t" \
"jnc 1b\n\t" \
"cmpb "SYMBOL_NAME_STR(active_kernel_processor)", %al\n\t" \
"je 4f\n\t" \
"decl %ecx\n\t" \
"jne 2b\n\t" \
"decl %ebx\n\t" \
"jne 6f\n\t" \
"call "SYMBOL_NAME_STR(irq_deadlock_detected)"\n\t" \
"6: movl "SYMBOL_NAME_STR(smp_loops_per_tick)", %ecx\n\t" \
"cmpb "SYMBOL_NAME_STR(boot_cpu_id)", %al\n\t" \
"jne 2b\n\t" \
"incl "SYMBOL_NAME_STR(jiffies)"\n\t" \
"jmp 2b\n\t" \
"3: " \
"movb %al, "SYMBOL_NAME_STR(active_kernel_processor)"\n\t" \
"4: " \
"incl "SYMBOL_NAME_STR(kernel_counter)"\n\t" \
"movb $0, "SYMBOL_NAME_STR(smp_blocked_interrupt_pending)"\n\t" \
"popfl\n\t" \
"popl %edx\n\t" \
"popl %ecx\n\t" \
"popl %ebx\n\t" \
"popl %eax\n\t"
#define LEAVE_KERNEL \
GET_PROCESSOR_ID \
"btrl $" STR(SMP_FROM_INT) ","SYMBOL_NAME_STR(smp_proc_in_lock)"(,%eax,4)\n\t" \
"pushfl\n\t" \
"cli\n\t" \
"decl "SYMBOL_NAME_STR(kernel_counter)"\n\t" \
"jnz 1f\n\t" \
"movb "SYMBOL_NAME_STR(saved_active_kernel_processor)",%al\n\t" \
"movb %al,"SYMBOL_NAME_STR(active_kernel_processor)"\n\t" \
"cmpb $" STR (NO_PROC_ID) ",%al\n\t" \
"jne 1f\n\t" \
"lock\n\t" \
"btrl $0, "SYMBOL_NAME_STR(kernel_flag)"\n\t" \
"1: " \
"popfl\n\t"
/*
* the syscall count inc is a gross hack because ret_from_syscall is used by both irq and
* syscall return paths (urghh).
*/
#define BUILD_IRQ(chip,nr,mask) \
asmlinkage void IRQ_NAME(nr); \
asmlinkage void FAST_IRQ_NAME(nr); \
asmlinkage void BAD_IRQ_NAME(nr); \
__asm__( \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
"pushl $-"#nr"-2\n\t" \
SAVE_ALL \
ENTER_KERNEL \
ACK_##chip(mask,(nr&7)) \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
"sti\n\t" \
"movl %esp,%ebx\n\t" \
"pushl %ebx\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_IRQ)"\n\t" \
"addl $8,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"incl "SYMBOL_NAME_STR(syscall_count)"\n\t" \
"jmp ret_from_sys_call\n" \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:\n\t" \
SAVE_MOST \
ENTER_KERNEL \
ACK_##chip(mask,(nr&7)) \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_fast_IRQ)"\n\t" \
"addl $4,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
LEAVE_KERNEL \
RESTORE_MOST \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:\n\t" \
SAVE_MOST \
ENTER_KERNEL \
ACK_##chip(mask,(nr&7)) \
LEAVE_KERNEL \
RESTORE_MOST);
#define BUILD_TIMER_IRQ(chip,nr,mask) \
asmlinkage void IRQ_NAME(nr); \
asmlinkage void FAST_IRQ_NAME(nr); \
asmlinkage void BAD_IRQ_NAME(nr); \
__asm__( \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:\n\t" \
SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:\n\t" \
SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
"pushl $-"#nr"-2\n\t" \
SAVE_ALL \
ENTER_KERNEL \
ACK_##chip(mask,(nr&7)) \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
"movl %esp,%ebx\n\t" \
"pushl %ebx\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_IRQ)"\n\t" \
"addl $8,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"incl "SYMBOL_NAME_STR(syscall_count)"\n\t" \
"jmp ret_from_sys_call\n");
/*
* Message pass must be a fast IRQ..
*/
#define BUILD_MSGIRQ(chip,nr,mask) \
asmlinkage void IRQ_NAME(nr); \
asmlinkage void FAST_IRQ_NAME(nr); \
asmlinkage void BAD_IRQ_NAME(nr); \
__asm__( \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
"pushl $-"#nr"-2\n\t" \
SAVE_ALL \
ENTER_KERNEL \
ACK_##chip(mask,(nr&7)) \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
"sti\n\t" \
"movl %esp,%ebx\n\t" \
"pushl %ebx\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_IRQ)"\n\t" \
"addl $8,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
GET_PROCESSOR_ID \
"btrl $" STR(SMP_FROM_INT) ","SYMBOL_NAME_STR(smp_proc_in_lock)"(,%eax,4)\n\t" \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"incl "SYMBOL_NAME_STR(syscall_count)"\n\t" \
"jmp ret_from_sys_call\n" \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:\n\t" \
SAVE_MOST \
ACK_##chip(mask,(nr&7)) \
SMP_PROF_IPI_CNT \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_fast_IRQ)"\n\t" \
"addl $4,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
RESTORE_MOST \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:\n\t" \
SAVE_MOST \
ACK_##chip(mask,(nr&7)) \
RESTORE_MOST);
#define BUILD_RESCHEDIRQ(nr) \
asmlinkage void IRQ_NAME(nr); \
__asm__( \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
"pushl $-"#nr"-2\n\t" \
SAVE_ALL \
ENTER_KERNEL \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
"sti\n\t" \
"movl %esp,%ebx\n\t" \
"pushl %ebx\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(smp_reschedule_irq)"\n\t" \
"addl $8,%esp\n\t" \
"cli\n\t" \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"incl "SYMBOL_NAME_STR(syscall_count)"\n\t" \
"jmp ret_from_sys_call\n");
#else
/************************************************************************
| Koniec SMP - od tego momentu kontynuuję opis |
*************************************************************************/
/************************************************************************
| W tym makrze chip=FIRST lub chip=SECOND, nr to numer przerwania,|
| a mask to jego maska. Oznacza to, że mask=1<IRQ1_interrupt(void); |
| asmlinkage void fast_IRQ1_interrupt(void); |
| asmlinkage void bad_IRQ1_interrupt(void); |
| __asm__(__ALIGN_STR ; dla zwiększenia szybkości
IRQ1_interrupt: ; zwykłe przerwania
; w tym momencie przerwania są zablokowane (IF=0)
pushl $-nr-2 ; w entry.S to miejsce będzie się
; nazywać ORIG_EAX (po co???)
; w każdym razie coś włożyć na stos
; trzeba, bo ret_from_sys_call
; oczekuje tam 4 bajtów
SAVE_ALL
ACK_FIRST(mask, (nr&7))
; drugi argument do makra to numer
; na sterowniku = 3 bity całego numeru.
; To makro maskuje nasze przerwanie
; wysyła EOI do sterownika(ów)
incl intr_count
sti
movl %esp, %ebx ; wstawiamy wskaźnik do rejestrów
; do ebx...
pushl ebx ;...i umieszczamy na stosie.
; Parametry funkcji w C idą na stos
; od końca - ten odpowiada parametrowi
; struct ptregs * regs do funkcji do_IRQ
pushl $nr ; pierwszym argumentem do_IRQ jest
; numer obsługiwanego przerwania
call do_IRQ
addl $8, %esp ; w C usunięcie argumentów ze stosu jest
; obowiązkiem wołającego
cli
UNBLK_FIRST(mask)
decl intr_count ; jeżeli jesteśmy jedynym przerwaniem
; to teraz intr_count==0
jmp ret_from_sys_call ; tu wchodzimy z zablokowanymi
; przerwaniami
; z tego wywołania się nie wraca
__ALIGN_STR
fast_IRQ1_interrupt: ; szybkie przerwania - bez ret_from_sys_call
SAVE_MOST
ACK_FIRST(mask,(nr&7))
incl intr_count
pushl $nr ; przekazujemy argument - numer przerwania
call do_fast_IRQ; szybka funkcja - wchodzimy z zablokowanymi
; przerwaniami, ale ona może je odblokować
addl $4,%esp ; czyścimy stos po wywołaniu
cli ; na wypadek, gdyby do_fast_IRQ wykonała sti
UNBLK_FIRST(mask)
decl intr_count
RESTORE_MOST ; instrukcja iret odtworzy stan flag
__ALIGN_STR
bad_IRQ1_interrupt: ; obsługa przerwań, które nie mają
; zainstalowanej procedury obsługi
; wysyłamy EOI i blokujemy to
; przerwanie (skoro i tak nie ma
; procedury obsługi...)
SAVE_MOST
ACK_FIRST(mask,(nr&7))
RESTORE_MOST
);
| |
| |
************************************************************************/
#define BUILD_IRQ(chip,nr,mask) \
asmlinkage void IRQ_NAME(nr); \
asmlinkage void FAST_IRQ_NAME(nr); \
asmlinkage void BAD_IRQ_NAME(nr); \
__asm__( \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
"pushl $-"#nr"-2\n\t" \
SAVE_ALL \
ACK_##chip(mask,(nr&7)) \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
"sti\n\t" \
"movl %esp,%ebx\n\t" \
"pushl %ebx\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_IRQ)"\n\t" \
"addl $8,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"jmp ret_from_sys_call\n" \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:\n\t" \
SAVE_MOST \
ACK_##chip(mask,(nr&7)) \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_fast_IRQ)"\n\t" \
"addl $4,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
RESTORE_MOST \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:\n\t" \
SAVE_MOST \
ACK_##chip(mask,(nr&7)) \
RESTORE_MOST);
/************************************************************************
| A teraz takie same makra dla przerwań zegarowych (niezależnie |
| od numeru, pod jakim się to przerwanie znajduje). |
| Dla wszystkich wypadków robimy to samo, co poprzednio dla |
| IRQ?_interrupt,ale jest jedna jedyna różnica - do funkcji |
| do_IRQ wchodzimy z zablokowanymi przerwaniami i nie wolno |
| ich tam odblokowywać (patrz irq.c) |
************************************************************************/
#define BUILD_TIMER_IRQ(chip,nr,mask) \
asmlinkage void IRQ_NAME(nr); \
asmlinkage void FAST_IRQ_NAME(nr); \
asmlinkage void BAD_IRQ_NAME(nr); \
__asm__( \
"\n"__ALIGN_STR"\n" \
SYMBOL_NAME_STR(fast_IRQ) #nr "_interrupt:\n\t" \
SYMBOL_NAME_STR(bad_IRQ) #nr "_interrupt:\n\t" \
SYMBOL_NAME_STR(IRQ) #nr "_interrupt:\n\t" \
"pushl $-"#nr"-2\n\t" \
SAVE_ALL \
ACK_##chip(mask,(nr&7)) \
"incl "SYMBOL_NAME_STR(intr_count)"\n\t"\
"movl %esp,%ebx\n\t" \
"pushl %ebx\n\t" \
"pushl $" #nr "\n\t" \
"call "SYMBOL_NAME_STR(do_IRQ)"\n\t" \
"addl $8,%esp\n\t" \
"cli\n\t" \
UNBLK_##chip(mask) \
"decl "SYMBOL_NAME_STR(intr_count)"\n\t" \
"jmp ret_from_sys_call\n");
#endif
#endif
Autor: Piotr Hoffman