arch/i386-pc/exec/cause.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: i386native version of Cause().
   6     Lang: english
   7 */
   8
   9
  10 #include <exec/execbase.h>
  11 #include <aros/asmcall.h>
  12 #include <exec/interrupts.h>
  13 #include <hardware/custom.h>
  14 #include <hardware/intbits.h>
  15 #include <proto/exec.h>
  16
  17 #include <exec_intern.h>
  18
  19 #include <asm/linkage.h>
  20 #include <asm/ptrace.h>
  21 #include <asm/irq.h>
  22
  23 #include "etask.h"
  24
  25 extern char softblock;
  26
  27 #define get_cs() \
  28         ({  short __value; \
  29         __asm__ __volatile__ ("mov %%ds,%%ax":"=a"(__value)); \
  30         (__value & 0x03);       })
  31
  32 AROS_LH1(void, Cause,
  33     AROS_LHA(struct Interrupt *, softint, A1),
  34     struct ExecBase *, SysBase, 30, Exec)
  35 {
  36     AROS_LIBFUNC_INIT
  37
  38     UBYTE pri;
  39
  40
  41     Disable();
  42     /* Check to ensure that this node is not already in a list. */
  43     if( softint->is_Node.ln_Type != NT_SOFTINT )
  44     {
  45         /* Scale the priority down to a number between 0 and 4 inclusive
  46         We can use that to index into exec's software interrupt lists. */
  47         pri = (softint->is_Node.ln_Pri + 0x20)>>4;
  48
  49         /* We are accessing an Exec list, protect ourselves. */
  50         ADDTAIL(&SysBase->SoftInts[pri].sh_List, &softint->is_Node);
  51         softint->is_Node.ln_Type = NT_SOFTINT;
  52         SysBase->SysFlags |= SFF_SoftInt;
  53
  54         /* If we are in usermode the software interrupt will end up
  55            being triggered in Enable(). See Enable() code */
  56 #if 0
  57         if (!softblock)
  58             if (get_cs())
  59                 __asm__ __volatile__ ("movl $0,%%eax\n\tint $0x80":::"eax","memory");
  60              else
  61              {
  62              /* Cause() inside supervisor mode. We will call IntServer directly
  63                 no matter it is normal irq or Supervisor() call */
  64              struct IntVector *iv = &SysBase->IntVects[INTB_SOFTINT];
  65
  66                  if (iv->iv_Code)
  67                  {
  68                      AROS_UFC5(void, iv->iv_Code,
  69                          AROS_UFCA(ULONG, 0, D1),
  70                          AROS_UFCA(ULONG, 0, A0),
  71                          AROS_UFCA(APTR, NULL, A1),
  72                          AROS_UFCA(APTR, iv->iv_Code, A5),
  73                          AROS_UFCA(struct ExecBase *, SysBase, A6)
  74                      );
  75                  }
  76              }
  77 #endif
  78
  79     }
  80     Enable();
  81
  82
  83     AROS_LIBFUNC_EXIT
  84 } /* Cause() */
  85
  86 #ifdef SysBase
  87 #undef SysBase
  88 #endif
  89 #define SysBase (*(struct ExecBase **)4UL)
  90
  91 /*
  92 #define SC_ENABLE(regs)         (regs.eflags |= 0x200)
  93 #define SC_DISABLE(regs)        (regs.eflags &= ~0x200)
  94 */
  95
  96 // asmlinkage void sys_Cause(struct pt_regs regs)
  97 asmlinkage void sys_Cause(void)
  98 {
  99     struct IntVector *iv;
 100
 101     iv = &SysBase->IntVects[INTB_SOFTINT];
 102
 103     if (iv->iv_Code)
 104     {
 105         /*  Call it. I call with all these parameters for a reason.
 106
 107         In my `Amiga ROM Kernel Reference Manual: Libraries and
 108         Devices' (the 1.3 version), interrupt servers are called
 109         with the following 5 parameters.
 110
 111         D1 - Mask of INTENAR and INTREQR
 112         A0 - 0xDFF000 (base of custom chips)
 113         A1 - Interrupt Data
 114         A5 - Interrupt Code vector
 115         A6 - SysBase
 116
 117         It is quite possible that some code uses all of these, so
 118         I must supply them here. Obviously I will dummy some of these
 119         though.
 120         */
 121         AROS_UFC5(void, iv->iv_Code,
 122             AROS_UFCA(ULONG, 0, D1),
 123             AROS_UFCA(ULONG, 0, A0),
 124             AROS_UFCA(APTR, 0, A1),
 125             AROS_UFCA(APTR, iv->iv_Code, A5),
 126             AROS_UFCA(struct ExecBase *, SysBase, A6)
 127         );
 128     }
 129 }
 130
 131 #undef SysBase
 132
 133 /*
 134     This is the dispatcher for software interrupts. We go through the
 135     lists and remove the interrupts before calling them. Because we
 136     can be interrupted we should not cache the next pointer, but
 137     retreive it from ExecBase each time.
 138
 139     Note: All these arguments are passed to the structure, so you must
 140     at least declare all of them. You do not however have to use any
 141     of them (although that is recommended).
 142
 143     This procedure could be more efficient, and it has to be implemented
 144     in the kernel.
 145 */
 146
 147 AROS_UFH5(void, SoftIntDispatch,
 148     AROS_UFHA(ULONG, intReady, D1),
 149     AROS_UFHA(struct Custom *, custom, A0),
 150     AROS_UFHA(IPTR, intData, A1),
 151     AROS_UFHA(IPTR, intCode, A5),
 152     AROS_UFHA(struct ExecBase *, SysBase, A6))
 153 {
 154     AROS_USERFUNC_INIT
 155
 156     struct Interrupt *intr = 0;
 157     BYTE i;
 158
 159     if( SysBase->SysFlags & SFF_SoftInt )
 160     {
 161 #if 1
 162         /* Clear the Software interrupt pending flag. */
 163         SysBase->SysFlags &= ~(SFF_SoftInt);
 164
 165         for(;;)
 166         {
 167             for(i=4; i>=0; i--)
 168             {
 169                 __cli();
 170                 intr = (struct Interrupt *)RemHead(&SysBase->SoftInts[i].sh_List);
 171
 172                 if (intr)
 173                 {
 174                     intr->is_Node.ln_Type = NT_INTERRUPT;
 175
 176                     __sti();
 177
 178                     /* Call the software interrupt. */
 179                     AROS_UFC3(void, intr->is_Code,
 180                     AROS_UFCA(APTR, intr->is_Data, A1),
 181                     AROS_UFCA(APTR, intr->is_Code, A5),
 182                     AROS_UFCA(struct ExecBase *, SysBase, A6));
 183
 184                     /* Get out and start loop *all* over again *from scratch*! */
 185                     break;
 186                 }
 187             }
 188
 189             if (!intr) break;
 190         }
 191
 192
 193 #else
 194         /* Disable software interrupts */
 195         softblock = 1;
 196
 197         /* Clear the Software interrupt pending flag. */
 198         SysBase->SysFlags &= ~(SFF_SoftInt);
 199
 200         for(i=4; i>=0; i--)
 201         {
 202             while( (intr = (struct Interrupt *)RemHead(&SysBase->SoftInts[i].sh_List)) )
 203             {
 204                 intr->is_Node.ln_Type = NT_INTERRUPT;
 205
 206                 /* Call the software interrupt. */
 207                 AROS_UFC3(void, intr->is_Code,
 208                 AROS_UFCA(APTR, intr->is_Data, A1),
 209                 AROS_UFCA(APTR, intr->is_Code, A5),
 210                 AROS_UFCA(struct ExecBase *, SysBase, A6));
 211             }
 212         }
 213
 214         /* We now re-enable software interrupts. */
 215         softblock = 0;
 216 #endif
 217
 218     }
 219     return;
 220     AROS_USERFUNC_EXIT
 221 }