rom/exec/cause.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Cause() - Cause a software interrupt.
   6     Lang: english
   7 */
   8
   9 #include <aros/asmcall.h>
  10 #include <aros/config.h>
  11 #include <exec/execbase.h>
  12 #include <hardware/custom.h>
  13 #include <hardware/intbits.h>
  14 #include <proto/kernel.h>
  15
  16 #include "exec_intern.h"
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <exec/interrupts.h>
  22 #include <proto/exec.h>
  23
  24         AROS_LH1(void, Cause,
  25
  26 /*  SYNOPSIS */
  27         AROS_LHA(struct Interrupt *, softint, A1),
  28
  29 /*  LOCATION */
  30         struct ExecBase *, SysBase, 30, Exec)
  31
  32 /*  FUNCTION
  33         Schedule a software interrupt to occur. If the processor is
  34         currently running a user task, then the software interrupt will
  35         prempt the current task and run itself. From a real interrupt, it
  36         will queue the software interrupt for a later time.
  37
  38         Software interrupts are useful from hardware interrupts if you
  39         wish to defer your processing down to a lower level. They can
  40         also be used in some special cases of device I/O. The timer.device
  41         and audio.device allow software interrupt driven timing and
  42         audio output respectively.
  43
  44         Software interrupts are restricted to 5 different priority levels,
  45         +32, +16, 0, -16, -32.
  46
  47         Software interrupts can only be scheduled once.
  48
  49         The software interrupt is called with the following prototype:
  50
  51         AROS_UFH3(void, YourIntCode,
  52             AROS_UFHA(APTR, interruptData, A1),
  53             AROS_UFHA(APTR, interruptCode, A5),
  54             AROS_UFHA(struct ExecBase *, SysBase, A6))
  55
  56         The interruptData is the value of the is_Data field, interruptCode
  57         is the value of the is_Code field - it is included for historical
  58         and compatibility reasons. You can ignore the value of interruptCode,
  59         but you must declare it.
  60
  61     INPUTS
  62         softint     -   The interrupt you wish to schedule. When setting up
  63                         you should set the type of the interrupt to either
  64                         NT_INTERRUPT or NT_UNKNOWN.
  65
  66     RESULT
  67         The software interrupt will be delivered, or queued for later
  68         delivery.
  69
  70     NOTES
  71         No bounds checking on the software interrupt priority is done.
  72         Passing a bad priority to the system can have a strange effect.
  73
  74     EXAMPLE
  75
  76     BUGS
  77         Older versions of the Amiga operating system require that the
  78         software interrupts preserve the A6 register.
  79
  80         Software interrupts which are added from a software interrupt of
  81         lower priority may not be called immediately.
  82
  83     SEE ALSO
  84
  85     INTERNALS
  86
  87 ******************************************************************************/
  88 {
  89     AROS_LIBFUNC_INIT
  90
  91     UBYTE pri;
  92
  93     Disable();
  94     /* Check to ensure that this node is not already in a list. */
  95     if( softint->is_Node.ln_Type != NT_SOFTINT )
  96     {
  97         /* Scale the priority down to a number between 0 and 4 inclusive
  98         We can use that to index into exec's software interrupt lists. */
  99         pri = (softint->is_Node.ln_Pri + 0x20)>>4;
 100
 101         /* We are accessing an Exec list, protect ourselves. */
 102         ADDTAIL(&SysBase->SoftInts[pri].sh_List, &softint->is_Node);
 103         softint->is_Node.ln_Type = NT_SOFTINT;
 104         SysBase->SysFlags |= SFF_SoftInt;
 105 #if (AROS_FLAVOUR & AROS_FLAVOUR_BINCOMPAT) && defined(__mc68000)
 106         {
 107            /* Quick soft int request. For optimal performance m68k-amiga
 108             * Enable() does not do any extra SFF_SoftInt checks */
 109             volatile struct Custom *custom = (struct Custom*)0xdff000;
 110             custom->intreq = INTF_SETCLR | INTF_SOFTINT;
 111         }
 112 #else
 113         /* If we are in usermode the software interrupt will end up
 114            being triggered in Enable(). See Enable() code */
 115 #endif
 116     }
 117     Enable();
 118
 119     AROS_LIBFUNC_EXIT
 120 } /* Cause() */
 121
 122 /*
 123     This is the dispatcher for software interrupts. We go through the
 124     lists and remove the interrupts before calling them. Because we
 125     can be interrupted we should not cache the next pointer, but
 126     retreive it from ExecBase each time.
 127
 128     Note: All these arguments are passed to the function, so you must
 129     at least declare all of them. You do not however have to use any
 130     of them (although that is recommended).
 131
 132     This procedure could be more efficient.
 133 */
 134
 135 AROS_UFH5(void, SoftIntDispatch,
 136     AROS_UFHA(ULONG, intReady, D1),
 137     AROS_UFHA(volatile struct Custom *, custom, A0),
 138     AROS_UFHA(IPTR, intData, A1),
 139     AROS_UFHA(ULONG_FUNC, intCode, A5),
 140     AROS_UFHA(struct ExecBase *, SysBase, A6))
 141 {
 142     AROS_USERFUNC_INIT
 143
 144     struct Interrupt *intr = NULL;
 145     BYTE i;
 146
 147 #if defined(__mc68000)
 148     /* If we are working on classic Amiga(tm), we have valid custom chip pointer */
 149     if (custom)
 150     {
 151         /* disable soft ints temporarily */
 152         custom->intena = INTF_SOFTINT;
 153         /* clear request */
 154         custom->intreq = INTF_SOFTINT;
 155     }
 156 #endif
 157
 158     /* Don't bother if there are no software ints queued. */
 159     if( SysBase->SysFlags & SFF_SoftInt )
 160     {
 161         /* Clear Software interrupt pending flag. */
 162         SysBase->SysFlags &= ~(SFF_SoftInt);
 163
 164         for(;;)
 165         {
 166             for(i=4; i>=0; i--)
 167             {
 168                 /*
 169                  * This KrnCli() is needed because we could re-enter here after one handler has already
 170                  * been executed. In this case interrupts have been enabled before calling the handler.
 171                  */
 172                 KrnCli();
 173                 intr = (struct Interrupt *)RemHead(&SysBase->SoftInts[i].sh_List);
 174
 175                 if (intr)
 176                 {
 177                     intr->is_Node.ln_Type = NT_INTERRUPT;
 178
 179                     /*
 180                      * SoftInt handlers are called with interrupts enabled,
 181                      * this is how original AmigaOS(tm) works
 182                      */
 183                     KrnSti();
 184
 185                     /* Call the software interrupt. */
 186                     AROS_UFC3(void, intr->is_Code,
 187                               AROS_UFCA(APTR, intr->is_Data, A1),
 188                               AROS_UFCA(APTR, intr->is_Code, A5),
 189                               AROS_UFCA(struct ExecBase *, SysBase, A6));
 190
 191                     /* Get out and start loop *all* over again *from scratch*! */
 192                     break;
 193                 }
 194             }
 195             if (!intr)
 196             {
 197                 /*
 198                  * We executed KrnCli() and attempted to fetch a request from the list,
 199                  * but the list was empty.
 200                  * We are going to exit, but before this we need to re-enable
 201                  * interrupts. Otherwise we exit this vector with disabled interrupts,
 202                  * screwing things up.
 203                  */
 204                 KrnSti();
 205                 break;
 206             }
 207         }
 208     }
 209
 210 #if defined(__mc68000)
 211     /* re-enable soft ints */
 212     if (custom)
 213         custom->intena = INTF_SETCLR | INTF_SOFTINT;
 214 #endif
 215
 216     AROS_USERFUNC_EXIT
 217 }