rom/kernel/kernel_interruptcontroller.c

   1 /*
   2     Copyright © 2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6 */
   7
   8 #include <kernel_base.h>
   9
  10 #ifdef KERNELIRQ_NEEDSCONTROLLERS
  11
  12 #include <aros/kernel.h>
  13 #include <proto/exec.h>
  14
  15 #include <inttypes.h>
  16 #include <string.h>
  17
  18
  19 #include <kernel_cpu.h>
  20 #include <kernel_debug.h>
  21 #include <kernel_interrupts.h>
  22 #include <kernel_objects.h>
  23
  24 /* We use own implementation of bug(), so we don't need aros/debug.h */
  25 #define D(x)
  26
  27 /*****************************************************************************
  28
  29             Register an Interrupt Controller in Kernelbase. Assign an ID (in ln_Type)
  30             returns -1 on failure.
  31
  32 *****************************************************************************/
  33
  34 icintrid_t krnAddInterruptController(struct KernelBase *KernelBase, struct IntrController *intController)
  35 {
  36     struct IntrController *regContr;
  37     icid_t icid = 0;
  38
  39     ForeachNode(&KernelBase->kb_ICList, regContr)
  40     {
  41         if (!strcmp(intController->ic_Node.ln_Name, regContr->ic_Node.ln_Name))
  42         {
  43             /* Already registered, return its ID */
  44             regContr->ic_Count++;
  45
  46             D(bug("[Kernel] %s: controller id #%d, use count %d\n", __func__, regContr->ic_Node.ln_Type, regContr->ic_Count));
  47
  48             return (icintrid_t)((regContr->ic_Node.ln_Type << 8) | regContr->ic_Count);
  49         }
  50     }
  51     intController->ic_Count = 1;                                                                                  /* first user */
  52     intController->ic_Node.ln_Type = KernelBase->kb_ICTypeBase++;
  53
  54     if (intController->ic_Register)
  55         icid = intController->ic_Register(KernelBase);
  56     else
  57         icid = intController->ic_Node.ln_Type;
  58
  59     if (icid == (icid_t)-1)
  60         return (icintrid_t)-1;
  61
  62     Enqueue(&KernelBase->kb_ICList, &intController->ic_Node);
  63
  64     D(bug("[Kernel] %s: new controller id #%d = '%s'\n", __func__, intController->ic_Node.ln_Type, intController->ic_Node.ln_Name));
  65
  66     return (icintrid_t)((icid << 8) | intController->ic_Count);
  67 }
  68
  69 /*****************************************************************************/
  70
  71 struct IntrController *krnFindInterruptController(struct KernelBase *KernelBase, ULONG ICType)
  72 {
  73     struct IntrController *intContr;
  74     ForeachNode(&KernelBase->kb_ICList, intContr)
  75     {
  76         if (intContr->ic_Type == ICType)
  77         {
  78             return intContr;
  79         }
  80     }
  81     return NULL;
  82 }
  83
  84 /*****************************************************************************/
  85
  86 BOOL krnInitInterrupt(struct KernelBase *KernelBase, icid_t irq, icid_t icid, icid_t icinstance)
  87 {
  88     if (KERNELIRQ_LIST(irq).lh_Type == KBL_INTERNAL)
  89     {
  90         KERNELIRQ_LIST(irq).lh_Type = icid;
  91         KERNELIRQ_LIST(irq).l_pad = icinstance;
  92         return TRUE;
  93     }
  94     return FALSE;
  95 }
  96
  97 struct IntrMapping *krnInterruptMapping(struct KernelBase *KernelBase, icid_t irq)
  98 {
  99     struct IntrMapping *intrMap;
 100
 101     ForeachNode(&KernelBase->kb_InterruptMappings, intrMap)
 102     {
 103         if (intrMap->im_Node.ln_Pri == irq)
 104         {
 105             return intrMap;
 106         }
 107     }
 108     return NULL;
 109 }
 110
 111 struct IntrMapping *krnInterruptMapped(struct KernelBase *KernelBase, icid_t irq)
 112 {
 113     struct IntrMapping *intrMap;
 114
 115     ForeachNode(&KernelBase->kb_InterruptMappings, intrMap)
 116     {
 117         if (intrMap->im_IRQ == irq)
 118         {
 119             return intrMap;
 120         }
 121     }
 122     return NULL;
 123 }
 124
 125 /*****************************************************************************
 126
 127             Initialize the registered Interrupt Controllers.
 128
 129 *****************************************************************************/
 130
 131 int krnInitInterruptControllers(struct KernelBase *KernelBase)
 132 {
 133     struct IntrController *regContr;
 134     int cnt = 0;
 135
 136     ForeachNode(&KernelBase->kb_ICList, regContr)
 137     {
 138         if (regContr->ic_Init)
 139         {
 140             if (regContr->ic_Init(KernelBase, regContr->ic_Count))
 141             {
 142                 regContr->ic_Flags |= ICF_READY;
 143                 cnt += regContr->ic_Count;
 144             }
 145         }
 146     }
 147     return cnt;
 148 }
 149
 150 #endif