/************************************************************************
|	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