kernel/interrupt.c

   1 /*
   2  *   The Minix hardware interrupt system.
   3  *
   4  *   This file contains routines for managing the interrupt
   5  *   controller.
   6  *
   7  *   put_irq_handler: register an interrupt handler.
   8  *   rm_irq_handler:  deregister an interrupt handler.
   9  *   irq_handle:     handle a hardware interrupt.
  10  *                    called by the system dependent part when an
  11  *                    external interrupt occures.
  12  *   enable_irq:      enable hook for IRQ.
  13  *   disable_irq:     disable hook for IRQ.
  14  */
  15
  16 #include <assert.h>
  17
  18 #include "kernel.h"
  19 #include "proc.h"
  20 #include "archconst.h"
  21 #include "hw_intr.h"
  22
  23 /* number of lists of IRQ hooks, one list per supported line. */
  24 PUBLIC irq_hook_t* irq_handlers[NR_IRQ_VECTORS] = {0};
  25 /*===========================================================================*
  26  *                              put_irq_handler                              *
  27  *===========================================================================*/
  28 /* Register an interrupt handler.  */
  29 PUBLIC void put_irq_handler( irq_hook_t* hook, int irq,
  30   const irq_handler_t handler)
  31 {
  32   int id;
  33   irq_hook_t **line;
  34   unsigned long bitmap;
  35
  36   if( irq < 0 || irq >= NR_IRQ_VECTORS )
  37         panic("invalid call to put_irq_handler: %d",  irq);
  38
  39   line = &irq_handlers[irq];
  40
  41   bitmap = 0;
  42   while ( *line != NULL ) {
  43         if(hook == *line) return; /* extra initialization */
  44         bitmap |= (*line)->id;  /* mark ids in use */
  45         line = &(*line)->next;
  46   }
  47
  48   /* find the lowest id not in use */
  49   for (id = 1; id != 0; id <<= 1)
  50         if (!(bitmap & id)) break;
  51
  52   if(id == 0)
  53         panic("Too many handlers for irq: %d",  irq);
  54
  55   hook->next = NULL;
  56   hook->handler = handler;
  57   hook->irq = irq;
  58   hook->id = id;
  59   *line = hook;
  60   irq_use |= 1 << irq;  /* this does not work for irq >= 32 */
  61
  62   /* And as last enable the irq at the hardware.
  63    *
  64    * Internal this activates the line or source of the given interrupt.
  65    */
  66   if((irq_actids[hook->irq] &= ~hook->id) == 0) {
  67           hw_intr_unmask(hook->irq);
  68   }
  69 }
  70
  71 /*===========================================================================*
  72  *                              rm_irq_handler                               *
  73  *===========================================================================*/
  74 /* Unregister an interrupt handler.  */
  75 PUBLIC void rm_irq_handler( const irq_hook_t* hook ) {
  76   const int irq = hook->irq;
  77   const int id = hook->id;
  78   irq_hook_t **line;
  79
  80   if( irq < 0 || irq >= NR_IRQ_VECTORS )
  81         panic("invalid call to rm_irq_handler: %d",  irq);
  82
  83   /* remove the hook  */
  84   line = &irq_handlers[irq];
  85   while( (*line) != NULL ) {
  86         if((*line)->id == id) {
  87                 (*line) = (*line)->next;
  88                 if(!irq_handlers[irq])
  89                         irq_use &= ~(1 << irq);
  90                 if (irq_actids[irq] & id)
  91                         irq_actids[irq] &= ~id;
  92         }
  93         else {
  94                 line = &(*line)->next;
  95         }
  96   }
  97
  98   /* Disable the irq if there are no other handlers registered.
  99    * If the irq is shared, reenable it if there is no active handler.
 100    */
 101   if (irq_handlers[irq] == NULL) {
 102         hw_intr_mask(irq);
 103   }
 104   else if (irq_actids[irq] == 0) {
 105         hw_intr_unmask(irq);
 106   }
 107 }
 108
 109 /*===========================================================================*
 110  *                              irq_handle                                   *
 111  *===========================================================================*/
 112 /*
 113  * The function first disables interrupt is need be and restores the state at
 114  * the end. Before returning, it unmasks the IRQ if and only if all active ID
 115  * bits are cleared, and restart a process.
 116  */
 117 PUBLIC void irq_handle(int irq)
 118 {
 119   irq_hook_t * hook;
 120
 121   /* here we need not to get this IRQ until all the handlers had a say */
 122   assert(irq >= 0 && irq < NR_IRQ_VECTORS);
 123   hw_intr_mask(irq);
 124   hook = irq_handlers[irq];
 125
 126   /* Check for spurious interrupts. */
 127   if(hook == NULL) {
 128       static int nspurious[NR_IRQ_VECTORS];
 129       nspurious[irq]++;
 130       if(nspurious[irq] == 1 || !(nspurious[irq] % 1000)) {
 131         printf("irq_handle: spurious irq %d (count: %d); keeping masked\n",
 132                 irq, nspurious[irq]);
 133       }
 134       return;
 135   }
 136
 137   /* Call list of handlers for an IRQ. */
 138   while( hook != NULL ) {
 139     /* For each handler in the list, mark it active by setting its ID bit,
 140      * call the function, and unmark it if the function returns true.
 141      */
 142     irq_actids[irq] |= hook->id;
 143
 144     /* Call the hooked function. */
 145     if( (*hook->handler)(hook) )
 146       irq_actids[hook->irq] &= ~hook->id;
 147
 148     /* Next hooked function. */
 149     hook = hook->next;
 150   }
 151
 152   /* reenable the IRQ only if there is no active handler */
 153   if (irq_actids[irq] == 0)
 154           hw_intr_unmask(irq);
 155 }
 156
 157 /* Enable/Disable a interrupt line.  */
 158 PUBLIC void enable_irq(const irq_hook_t *hook)
 159 {
 160   if((irq_actids[hook->irq] &= ~hook->id) == 0) {
 161     hw_intr_unmask(hook->irq);
 162   }
 163 }
 164
 165 /* Return true if the interrupt was enabled before call.  */
 166 PUBLIC int disable_irq(const irq_hook_t *hook)
 167 {
 168   if(irq_actids[hook->irq] & hook->id)  /* already disabled */
 169     return 0;
 170   irq_actids[hook->irq] |= hook->id;
 171   hw_intr_mask(hook->irq);
 172   return TRUE;
 173 }
 174