Assembleur Intel avec NASM

C'est vrai, ça, pourquoi les interruptions ? La raison en est toute baignée de considérations calculatoires. Si le processeur devait regarder régulièrement si, par exemple, un caractère est en train d'être entré au clavier, mes pauvres enfants, on ne s'en sortirait pas et on aurait encore bien du mal à faire fonctionner un simulateur de calculette. Pour gagner énormément de temps et pour qu'aucun programmeur n'oublie de vérifier l'entrée clavier, c'est l'inverse que l'on fait : c'est le contrôleur clavier qui interrompt le processeur en lui disant : "Je ne sais pas si cela vous intéresse, mon bon ami, mais j'ai ici une touche qui vient d'être frappée." Ca, c'était pour la poésie. Dans la vraie vie, ça se passe plutôt comme "Touche. -6^e procédure. -STOP ! 6^e procédure. -6^e procédure faite. -OK, j'y retourne." Et la 6^e procédure en question, c'est l'interruption clavier. Et si un contrôleur de clavier peut appeler une interruption, alors un programme aussi. C'est ce détournement que nous avons utilisé précédemment, et c'est même prévu pour être utilisé à outrance.

C'est un programme, sous-programme ou routine, peu importe le nom, dont l'exécution interrompt le cours normal d'un autre programme. Un peu comme quand l'exécution automatique d'un CD se déclenche quand vous êtes en train de rédiger votre site, par exemple. On est interrompu. Cette routine a ceci de particulier qu'elle se termine par l'instruction IRET, comme Interrupt RETurn, instruction qu'on ne trouve qu'en langage assembleur (ou alors d'autres langages parfaitement exotiques). Voici donc notre première routine de gestion d'interruption : entreeInterruption : IRET. Donc, pour appeler une routine définie comme interruption, on ne peut pas utiliser CALL. Ce sera INT.

Comme d'habitude chez nous, on va faire dans le simple, quitte à bulldozer un brin. Alors, en premier, on doit pratiquer la même chose que pour le passage en mode protégé. C'est-à-dire que l'on doit créer un IDT (Interrupt Descriptor Table), tableau de descripteurs d'interruption, contenant, comme c'est étrange, des descripteurs d'interruption. L'instruction INT prend un opérande de 8 bits, on peut donc avoir 256 descripteurs d'interruption. Voici comment je fais :

				mov eax, IDTBASE 				; Adresse de l'IDT
				mov ebx, interruptionParDefaut 	; On va remplir toute la table avec l'interruption par défaut : bx contient les bits de poids faible
				mov ecx, IDTSIZE				; Nombre de vecteurs d'interruption
				call metInterruptionNFois
 
				lidt [idtptr]	; charge l'idt
				sti
 
			;;Met l'interruption n fois dans l'idt
			metInterruptionNFois:
				mov edx, ebx
				shr edx, 16
				mov [descripteurInterruption], bx	;bx contient les bits de poids faible
				mov [descripteurInterruption + 6], dx; et dx ceux de poids fort
				mov edi, eax
			.remplitIDTPIC:
				mov esi, descripteurInterruption
				movsd
				movsd
				loop .remplitIDTPIC
				ret
 
			interruptionParDefaut:
				iret
 
			idtptr:
				dw	IDTSIZE << 3			; limite
				dd	IDTBASE					; base
 
			descripteurInterruption:
				dw 0, 1 * 8, INTGATE, 0

Notez l'instruction LIDT qui fait exactement la même chose que LGDT mais pour l'IDT, et le rétablissement des interruptions l'instant d'après. Notez aussi que nous travaillons en 32 bits, gloria alleluia.

Les périphériques d'un ordinateur compatible PC ne sont pas branchés directement sur le processeur. Ils sont branchés sur un élément qu'on appelle le PIC (Programable Interruption Controller), le contrôleur d'interruption programmable. Il y en a deux, l'un piloté par l'autre. Le pilote s'appelle le maître, l'autre l'esclave. La raison d'être du PIC est donc de déclencher des interruptions. Or, il se trouve que dans son nom, il y a "Programable", ce qui doit signifier qu'on peut faire quelques configurations. Le PIC n'étant ni la mémoire ni le processeur, pour y accéder, on va parler :

IX-4-a. Du port d'entrée/sortie▲

IX-4-b. ICW1▲

				mov al, 0x11	; Initialisation de ICW1
				out 0x20, al	; maître
				out 0xA0, al	; esclave

IX-4-c. ICW2▲

			?fine INTERRUPTION_PIC_MAITRE 0x20
			?fine INTERRUPTION_PIC_ESCLAVE 0x70
				mov al, INTERRUPTION_PIC_MAITRE	; Initialisation de ICW2
				out 0x21, al	; maître, vecteur de départ = 32
				mov al, INTERRUPTION_PIC_ESCLAVE
				out 0xA1, al	; esclave, vecteur de départ = 96

IX-4-d. ICW3▲

				mov al, 0x04	; initialisation de ICW3
				out 0x21, al
				mov al, 0x02	; esclave
				out 0xA1, al

IX-4-e. ICW4▲

				mov al, 0x05	; initialisation de ICW4
				out 0x21, al
				mov al, 0x01	; esclave
				out 0xA1, al

IX-4-f. OCW1▲

				xor al, al	; masquage des interruptions
				out 0x21, al
				out 0xA1, al

IX-4-g. Fin de traitement d'interruption▲

			interruptionPICParDefaut:
				mov al,0x20	; EOI (End Of Interrupt)
				out 0x20,al	; qu'on envoie au PIC
				iret