arch/arm-native/kernel/syscall.c

   1 /*
   2     Copyright © 2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <inttypes.h>
   7 #include <aros/kernel.h>
   8 #include <aros/libcall.h>
   9
  10 #include <aros/arm/cpucontext.h>
  11
  12 #include <stddef.h>
  13 #include <string.h>
  14
  15 #include <proto/exec.h>
  16 #include <proto/kernel.h>
  17
  18 #include "kernel_cpu.h"
  19 #include "kernel_intern.h"
  20 #include "kernel_scheduler.h"
  21 #include "kernel_intr.h"
  22 #include "kernel_syscall.h"
  23
  24 extern char * __text_start;
  25 extern char * __text_end;
  26
  27 #ifndef _CUSTOM
  28 #define _CUSTOM NULL
  29 #endif
  30
  31 #define DREGS(x)
  32 #define D(x)
  33
  34 /*
  35     __vectorhand_swi:
  36
  37     this code currently assumes the caller is in user mode (and will break from any other mode)
  38
  39     r0 = passed to c handler, r1/r2 = temp
  40 */
  41 asm (
  42     ".globl __vectorhand_swi                   \n"
  43     ".type __vectorhand_swi,%function          \n"
  44     "__vectorhand_swi:                         \n"
  45     VECTCOMMON_START
  46     "           bl      handle_syscall         \n"
  47     VECTCOMMON_END
  48 );
  49
  50 void cache_clear_e(void *addr, uint32_t length, uint32_t flags)
  51 {
  52     uint32_t count = 0;
  53
  54     if (addr == NULL && length == 0xffffffff)
  55     {
  56         count = 0x8000000;
  57     }
  58     else
  59     {
  60         void *end_addr = ((uintptr_t)addr + length + 31) & ~31;
  61         addr = (void *)((uintptr_t)addr & ~31);
  62         count = (uintptr_t)(end_addr - addr) >> 5;
  63     }
  64
  65     D(bug("[KRN] CacheClearE from %p length %d count %d, flags %x\n", addr, length, count, flags));
  66
  67     while (count--)
  68     {
  69         if (flags & CACRF_ClearD)
  70         {
  71             __asm__ __volatile__("mcr p15, 0, %0, c7, c14, 1"::"r"(addr));
  72         }
  73         if (flags & CACRF_ClearI)
  74         {
  75             __asm__ __volatile__("mcr p15, 0, %0, c7, c5, 1"::"r"(addr));
  76         }
  77         if (flags & CACRF_InvalidateD)
  78         {
  79             __asm__ __volatile__("mcr p15, 0, %0, c7, c6, 1"::"r"(addr));
  80         }
  81
  82         addr += 32;
  83     }
  84
  85     __asm__ __volatile__("mcr p15, 0, %0, c7, c10, 4"::"r"(addr));
  86 }
  87
  88 void handle_syscall(void *regs)
  89 {
  90     register unsigned int addr;
  91     register unsigned int swi_no;
  92
  93     /* We determine the SWI number by reading in "tasks"
  94        program counter, subtract the instruction from it and
  95        obtain the value from there.  we also use this to check if
  96        we have been called from outwith the kernel's code (illegal!)
  97      */
  98
  99     addr = ((uint32_t *)regs)[15];
 100     addr -= 4;
 101     swi_no = *((unsigned int *)addr) & 0x00ffffff;
 102
 103     D(bug("[KRN] ## SWI %d @ 0x%p\n", swi_no, addr));
 104
 105     if (((char*)addr < &__text_start) || ((char*)addr >= &__text_end))
 106     {
 107         D(bug("[KRN] ## SWI : ILLEGAL ACCESS!\n"));
 108         return;
 109     }
 110     if (swi_no <= 0x0b || swi_no == 0x100)
 111     {
 112         DREGS(cpu_DumpRegs(regs));
 113
 114         switch (swi_no)
 115         {
 116             case SC_CLI:
 117             {
 118                 D(bug("[KRN] ## CLI...\n"));
 119                 ((uint32_t *)regs)[16] |= 0x80;
 120                 break;
 121             }
 122
 123             case SC_STI:
 124             {
 125                 D(bug("[KRN] ## STI...\n"));
 126                 ((uint32_t *)regs)[16] &= ~0x80;
 127                 break;
 128             }
 129
 130             case SC_SUPERSTATE:
 131             {
 132                 D(bug("[KRN] ## SUPERSTATE... (0x%p ->", ((uint32_t *)regs)[16]));
 133                 ((uint32_t *)regs)[16] &= ~CPUMODE_MASK;
 134                 ((uint32_t *)regs)[16] |= (0x80 | CPUMODE_SUPERVISOR);
 135                 D(bug(" 0x%p)\n", ((uint32_t *)regs)[16]));
 136                 break;
 137             }
 138
 139             case SC_ISSUPERSTATE:
 140             {
 141                 D(bug("[KRN] ## ISSUPERSTATE... "));
 142                 ((uint32_t *)regs)[0] = !(((((uint32_t *)regs)[16] & CPUMODE_MASK) == CPUMODE_USER) || ((((uint32_t *)regs)[16] & CPUMODE_MASK) == CPUMODE_SYSTEM));
 143                 D(bug("%d\n", ((uint32_t *)regs)[0]));
 144                 break;
 145             }
 146
 147             case SC_REBOOT:
 148             {
 149                 D(bug("[KRN] ## REBOOT...\n"));
 150                 asm volatile ("mov pc, #0\n"); // Jump to the reset vector..
 151                 break;
 152             }
 153
 154             case SC_CACHECLEARE:
 155             {
 156                 D(bug("[KRN] ## CACHECLEARE...\n"));
 157                 void * address = ((void **)regs)[0];
 158                 uint32_t length = ((uint32_t *)regs)[1];
 159                 uint32_t flags = ((uint32_t *)regs)[2];
 160
 161                 cache_clear_e(address, length, flags);
 162
 163                 break;
 164             }
 165
 166             /*
 167              * Execure core_SysCall only when we will go back to user mode. Default core_SysCall does
 168              * not check this condition and could execute Cause() handler before IRQ is entirely handled.
 169              */
 170             case SC_CAUSE:
 171             {
 172                 uint32_t mode = (((uint32_t *)regs)[16]) & 0x1f;
 173                 if (mode == 0x10 || mode == 0x1f)
 174                     core_SysCall(swi_no, regs);
 175                 break;
 176             }
 177
 178             default:
 179                 core_SysCall(swi_no, regs);
 180                 break;
 181         }
 182     }
 183     else
 184     {
 185         D(bug("[KRN] ## SWI : ILLEGAL SWI!\n"));
 186         return;
 187     }
 188
 189     D(bug("[KRN] ## SWI returning ..\n"));
 190 }