I. Introduction

A. What are Interrupts? (in real mode)

Interrupts are signals generated by the computer, by either software or hardware, every time a certain event occurs. For example, anytime a key is pressed at any point during program execution, the 0x09 interrupt is generated, causing the 0x09 interrupt handler to be called, which does its job then returns control back to the program were it left off. The interrupts are numbered from 0x00 to 0xFF and each have a special function (most are unused). In real mode, the first 1,024 bytes of memory of the computer are used as the interrupt handler table. This table has a 4 byte far address to the interrupt handler (Interrupt Service Routine - ISR) for each of the 256 interrupts. Interrupts may also be simulated by calling them with the INT command in real mode, or the __dpmi_int command in protected mode

B. Protected Mode

C. Adding your own ISRs

Many times it is useful to have your own functions be automatically called every time a specific event occurs, without having to continuously check for it. This can be done by changing the proper entry in the interrupt handler table to point to your new ISR. But many times you must have your ISR first call the original ISR to make sure the event is handled properly. To do this the address of the original ISR must be taken, and the old ISR must be called from within the new ISR. This is called chaining. The whole process is implemented in the next section

II. Implementation in DJGPP (protected mode)

A. Using _go32_dpmi functions

There are three steps to using custom interrupt handler functions

1. Get the address the current ISR and save it
2. Chain your new ISR onto the old on
3. Replace the old ISR once the program is done

//Simple Example of chaining interrupt handlers
//Adopted from Matthew Mastracci's code 

#include <stdio.h>
#include <pc.h>
#include <dpmi.h>
#include <go32.h>

//macros by Shawn Hargreaves from the Allegro library for locking
//functions and variables.
#define LOCK_VARIABLE(x)    _go32_dpmi_lock_data((void *)&x,
(long)sizeof(x));
#define LOCK_FUNCTION(x)    _go32_dpmi_lock_code(x,(long)sizeof(x));

//timer interrupt 8 is generated every 18.2 ms
#define TIMER 8

//global counter
int counter = 0;

//the new ISR, will be called automatically every 18.2 ms once
installed

void TickHandler(void)
 {
 counter++;
 }


int main(void)
 {
 //structures to hold selector:offset info for the ISRs
 _go32_dpmi_seginfo OldISR, NewISR;

 printf("About to chain the new ISR onto the old timer ISR..\n");
 getkey();

 //lock the functions and variables
 LOCK_FUNCTION(TickHandler);
 LOCK_VARIABLE(counter);

 //load the address of the old timer ISR into the OldISR structure
 _go32_dpmi_get_protected_mode_interrupt_vector(TIMER, &OldISR);
  
 //point NewISR to the proper selector:offset for handler function
 NewISR.pm_offset = (int)TickHandler;
 NewISR.pm_selector = _go32_my_cs();

 //chain the new ISR onto the old one so that first the old timer ISR
 //will be called, then the new timer ISR
 _go32_dpmi_chain_protected_mode_interrupt_vector(TIMER,&NewISR);
 
 //notice no changes to counter in this loop- the interrupt
 //changes it
 while (!kbhit())
   printf("%d\n",counter);

 printf("Removing new ISR from the timer ISR chain\n");

 //load the old timer ISR back without the new ISR chained on
 _go32_dpmi_set_protected_mode_interrupt_vector(TIMER, &OldISR);

 return 0;
}

B. Using other DPMI functions

there's a bunch of them that are for doing stuff with interrupts

C. Calling (simulating) Interrupts

The __dpmi_regs structure holds the register values __dpmi_int calls the interrupt. This example sets to video mode 0x13 by calling the video I/O interrupt 0x10.

     
 __dpmi_regs r;
 r.x.ax = 0x13;
 __dpmi_int(0x10,&r);

Writen by: Jack Quinn. Email comments, addtions, corrections, etc. to son of calliope. Notice: this document is defently not complete, it is just a quick and dirty start to using interrupt handlers

For more information: Matthew Mastracci doc and the DMPI spec