Prex Home / Browse Source - Prex Version: 0.9.0

root/sys/kern/irq.c

DEFINITIONS

1. irq_attach
2. irq_detach
3. irq_thread
4. irq_handler
5. irq_info
6. irq_init

   1 /*-
   2  * Copyright (c) 2005-2007, Kohsuke Ohtani
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  30 /*
  31  * irq.c - interrupt request management routines.
  32  */
  34 /**
  35  * We define the following two different types of interrupt services
  36  * in order to improve real-time performance.
  37  *
  38  * - Interrupt Service Routine (ISR)
  39  *
  40  *  ISR is started by an actual hardware interrupt. The associated
  41  *  interrupt is disabled in Interrupt Control Unit (ICU), and CPU
  42  *  interrupt is enabled while ISR runs.
  43  *  If ISR determines that the corresponding device generated the
  44  *  interrupt, ISR must program the device to stop that interrupt.
  45  *  Then, ISR should do minimum I/O operation and return control as
  46  *  quickly as possible. ISR will run within a context of the thread
  47  *  running when interrupt occurs. So, only few kernel services are
  48  *  available within ISR.
  49  *
  50  * - Interrupt Service Thread (IST)
  51  *
  52  *  IST is automatically activated if ISR returns INT_CONTINUE. It
  53  *  will be called when the system enters safer condition than ISR.
  54  *  A device driver should use IST to do heavy I/O operation as much
  55  *  as possible. Since ISR for the same IRQ line may be invoked during
  56  *  IST, the shared data, resources, and device registers must be
  57  *  synchronized by disabling interrupts. IST does not have to be
  58  *  reentrant because it is not interrupted by same IST itself.
  59  */
  61 #include <kernel.h>
  62 #include <event.h>
  63 #include <kmem.h>
  64 #include <sched.h>
  65 #include <thread.h>
  66 #include <irq.h>
  67 #include <hal.h>
  69 /* forward declarations */
  70 static void     irq_thread(void *);
  72 static struct irq       *irq_table[MAXIRQS];    /* IRQ descriptor table */
  74 /*
  75  * irq_attach - attach ISR and IST to the specified interrupt.
  76  *
  77  * Returns irq handle, or panic on failure.  The interrupt of
  78  * attached irq will be unmasked (enabled) in this routine.
  79  * TODO: Interrupt sharing is not supported, for now.
  80  */
irq_t
irq_attach(int vector, int pri, int shared,
  83            int (*isr)(void *), void (*ist)(void *), void *data)
  84 {
  85         struct irq *irq;
  86         int mode;
ASSERT(isr != NULL);
sched_lock();
  91         if ((irq = kmem_alloc(sizeof(*irq))) == NULL)
panic("irq_attach");
memset(irq, 0, sizeof(*irq));
irq->vector = vector;
irq->priority = pri;
irq->isr = isr;
irq->ist = ist;
irq->data = data;
 101         if (ist != IST_NONE) {
 102                 /*
 103                  * Create a new thread for IST.
 104                  */
irq->thread = kthread_create(&irq_thread, irq, ISTPRI(pri));
 106                 if (irq->thread == NULL)
panic("irq_attach");
event_init(&irq->istevt, "interrupt");
 110         }
irq_table[vector] = irq;
mode = shared ? IMODE_LEVEL : IMODE_EDGE;
interrupt_setup(vector, mode);
interrupt_unmask(vector, pri);
sched_unlock();
DPRINTF(("IRQ%d attached priority=%d\n", vector, pri));
 118         return irq;
 119 }
 121 /*
 122  * Detach an interrupt handler from the interrupt chain.
 123  * The detached interrupt will be masked off if nobody
 124  * attaches to it, anymore.
 125  */
 126 void
irq_detach(irq_t irq)
 128 {
ASSERT(irq != NULL);
ASSERT(irq->vector < MAXIRQS);
interrupt_mask(irq->vector);
irq_table[irq->vector] = NULL;
 134         if (irq->thread != NULL)
kthread_terminate(irq->thread);
kmem_free(irq);
 138 }
 140 /*
 141  * Interrupt service thread.
 142  * This is a common dispatcher to all interrupt threads.
 143  */
 144 static void
irq_thread(void *arg)
 146 {
 147         void (*fn)(void *);
 148         void *data;
 149         struct irq *irq;
splhigh();
irq = (struct irq *)arg;
fn = irq->ist;
data = irq->data;
 157         for (;;) {
 158                 if (irq->istreq <= 0) {
 159                         /*
 160                          * Since the interrupt is disabled above,
 161                          * an interrupt for this vector keeps
 162                          * pending until this thread enters sleep
 163                          * state. Thus, we don't lose any IST
 164                          * requests even if the interrupt is fired
 165                          * here.
 166                          */
sched_sleep(&irq->istevt);
 168                 }
irq->istreq--;
ASSERT(irq->istreq >= 0);
 172                 /*
 173                  * Call IST
 174                  */
spl0();
 176                 (*fn)(data);
splhigh();
 178         }
 179         /* NOTREACHED */
 180 }
 182 /*
 183  * Interrupt handler.
 184  *
 185  * This routine will call the corresponding ISR for the
 186  * requested interrupt vector. HAL code must call this
 187  * routine with scheduler locked.
 188  */
 189 void
irq_handler(int vector)
 191 {
 192         struct irq *irq;
 193         int rc;
irq = irq_table[vector];
 196         if (irq == NULL) {
DPRINTF(("Random interrupt ignored\n"));
 198                 return;
 199         }
ASSERT(irq->isr != NULL);
 202         /* Profile */
irq->count++;
 205         /*
 206          * Call ISR
 207          */
rc = (*irq->isr)(irq->data);
 210         if (rc == INT_CONTINUE) {
 211                 /*
 212                  * Kick IST
 213                  */
ASSERT(irq->ist != IST_NONE);
irq->istreq++;
sched_wakeup(&irq->istevt);
ASSERT(irq->istreq != 0);
 218         }
 219 }
 221 /*
 222  * Return irq information.
 223  */
 224 int
irq_info(struct irqinfo *info)
 226 {
 227         int vec = info->cookie;
 228         int found = 0;
 229         struct irq *irq;
 231         while (vec < MAXIRQS) {
 232                 if (irq_table[vec]) {
found = 1;
 234                         break;
 235                 }
vec++;
 237         }
 238         if (!found)
 239                 return ESRCH;
irq = irq_table[vec];
info->vector = irq->vector;
info->count = irq->count;
info->priority = irq->priority;
info->istreq = irq->istreq;
info->thread = irq->thread;
info->cookie = vec + 1;
 248         return 0;
 249 }
 251 /*
 252  * Start interrupt processing.
 253  */
 254 void
irq_init(void)
 256 {
interrupt_init();
 260         /* Enable interrupts */
spl0();
 262 }