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("[Kernel] 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("[Kernel] ## SWI %d @ 0x%p\n", swi_no, addr));
 104
 105     if (((char*)addr < &__text_start) || ((char*)addr >= &__text_end))
 106     {
 107         D(bug("[Kernel] ## 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("[Kernel] ## CLI...\n"));
 119                 ((uint32_t *)regs)[16] |= (1 << 7);
 120                 break;
 121             }
 122
 123             case SC_STI:
 124             {
 125                 D(bug("[Kernel] ## STI...\n"));
 126                 ((uint32_t *)regs)[16] &= ~(1 << 7);
 127                 break;
 128             }
 129
 130             case SC_SUPERSTATE:
 131             {
 132                 D(bug("[Kernel] ## SUPERSTATE... (0x%p ->", ((uint32_t *)regs)[16]));
 133                 ((uint32_t *)regs)[16] &= ~(CPUMODE_MASK);
 134                 ((uint32_t *)regs)[16] |= (0x80 | CPUMODE_SYSTEM);
 135                 D(bug(" 0x%p)\n", ((uint32_t *)regs)[16]));
 136                 break;
 137             }
 138
 139             case SC_GETCPUNUMBER:
 140             {
 141                 ((uint32_t *)regs)[0] = GetCPUNumber();
 142                 break;
 143             }
 144
 145             case SC_ISSUPERSTATE:
 146             {
 147                 D(bug("[Kernel] ## ISSUPERSTATE... "));
 148                 ((uint32_t *)regs)[0] = !(((((uint32_t *)regs)[16] & CPUMODE_MASK) == CPUMODE_USER));
 149                 D(bug("%d\n", ((uint32_t *)regs)[0]));
 150                 break;
 151             }
 152
 153             case SC_REBOOT:
 154             {
 155                 D(bug("[Kernel] ## REBOOT...\n"));
 156                 asm volatile ("mov pc, #0\n"); // Jump to the reset vector..
 157                 break;
 158             }
 159
 160             case SC_CACHECLEARE:
 161             {
 162                 D(bug("[Kernel] ## CACHECLEARE...\n"));
 163                 void * address = ((void **)regs)[0];
 164                 uint32_t length = ((uint32_t *)regs)[1];
 165                 uint32_t flags = ((uint32_t *)regs)[2];
 166
 167                 cache_clear_e(address, length, flags);
 168
 169                 break;
 170             }
 171
 172             /*
 173              * Execure core_SysCall only when we will go back to user mode. Default core_SysCall does
 174              * not check this condition and could execute Cause() handler before IRQ is entirely handled.
 175              */
 176
 177             default:
 178             {
 179                 uint32_t mode = (((uint32_t *)regs)[16]) & 0x1f;
 180                 if (mode == 0x10 || mode == 0x1f)
 181                     core_SysCall(swi_no, regs);
 182                 break;
 183             }
 184         }
 185     }
 186     else
 187     {
 188         D(bug("[Kernel] ## SWI : ILLEGAL SWI!\n"));
 189         return;
 190     }
 191
 192     D(bug("[Kernel] ## SWI returning ..\n"));
 193 }