rom/exec/cause.c

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