WebSVN – HelenOS – Diff – /trunk/kernel/generic/src/ddi/irq.c

 #include <ddi/irq.h>
 #include <adt/hash_table.h>
 #include <mm/slab.h>
 #include <arch/types.h>
 #include <synch/spinlock.h>
+#include <console/console.h>
 #include <memstr.h>
 #include <arch.h>
 #define KEY_INR     0
 #define KEY_DEVNO   1
     spinlock_unlock(&irq->lock);
     spinlock_unlock(&irq_kernel_hash_table_lock);
     interrupts_restore(ipl);
+}
-/** Dispatch the IRQ.
+/** Search and lock the uspace IRQ hash table.
+ *
- * We assume this function is only called from interrupt
- * context (i.e. that interrupts are disabled prior to
- * this call).
- *
- * This function attempts to lookup a fitting IRQ
- * structure. In case of success, return with interrupts
- * disabled and holding the respective structure.
- *
- * @param inr Interrupt number (aka inr or irq).
- *
- * @return IRQ structure of the respective device or NULL.
  */
-irq_t *irq_dispatch_and_lock(inr_t inr)
+static irq_t *irq_dispatch_and_lock_uspace(inr_t inr)
+{
     link_t *lnk;
     unative_t key[] = {
         (unative_t) inr,
-        (unative_t) -1      /* search will use claim() instead of devno */
+        (unative_t) -1    /* search will use claim() instead of devno */
     };
-    /*
-     * Try uspace handlers first.
-     */
     spinlock_lock(&irq_uspace_hash_table_lock);
     lnk = hash_table_find(&irq_uspace_hash_table, key);
     if (lnk) {
         irq_t *irq;
         irq = hash_table_get_instance(lnk, irq_t, link);
         spinlock_unlock(&irq_uspace_hash_table_lock);
         return irq;
+    }
     spinlock_unlock(&irq_uspace_hash_table_lock);
+    return NULL;
+}
+/** Search and lock the kernel IRQ hash table.
-    /*
+ *
+ */
+static irq_t *irq_dispatch_and_lock_kernel(inr_t inr)
+{
+    link_t *lnk;
-     * Fallback to kernel handlers.
+    unative_t key[] = {
+        (unative_t) inr,
+        (unative_t) -1    /* search will use claim() instead of devno */
-     */
+    };
     spinlock_lock(&irq_kernel_hash_table_lock);
     lnk = hash_table_find(&irq_kernel_hash_table, key);
     if (lnk) {
         irq_t *irq;
         irq = hash_table_get_instance(lnk, irq_t, link);
         spinlock_unlock(&irq_kernel_hash_table_lock);
         return irq;
+    }
     spinlock_unlock(&irq_kernel_hash_table_lock);
+    return NULL;
+}
+/** Dispatch the IRQ.
+ *
+ * We assume this function is only called from interrupt
+ * context (i.e. that interrupts are disabled prior to
+ * this call).
+ *
+ * This function attempts to lookup a fitting IRQ
+ * structure. In case of success, return with interrupts
+ * disabled and holding the respective structure.
+ *
+ * @param inr Interrupt number (aka inr or irq).
+ *
+ * @return IRQ structure of the respective device or NULL.
+ */
+irq_t *irq_dispatch_and_lock(inr_t inr)
+{
+    irq_t *irq;
+    /*
+     * If the kernel console is silenced,
+     * then try first the uspace handlers,
+     * eventually fall back to kernel handlers.
+     *
+     * If the kernel console is active,
+     * then do it the other way around.
+     */
+    if (silent) {
+        irq = irq_dispatch_and_lock_uspace(inr);
+        if (irq)
+            return irq;
+        return irq_dispatch_and_lock_kernel(inr);
+    }
+    irq = irq_dispatch_and_lock_kernel(inr);
+    if (irq)
-    return NULL;
+        return irq;
+    return irq_dispatch_and_lock_uspace(inr);
+}
 /** Compute hash index for the key.
+ *
  * This function computes hash index into

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/ddi/irq.c – Rev 3950 → 3964