arch/arm-native/kernel/kernel_startup.c

   1 /*
   2     Copyright © 2013-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 1
   7
   8 #include <aros/kernel.h>
   9 #include <aros/symbolsets.h>
  10
  11 #include <aros/arm/cpucontext.h>
  12
  13 #include <aros/cpu.h>
  14
  15 #include <exec/memory.h>
  16 #include <exec/memheaderext.h>
  17 #include <exec/tasks.h>
  18 #include <exec/alerts.h>
  19 #include <exec/execbase.h>
  20 #include <asm/io.h>
  21 #include <proto/kernel.h>
  22 #include <proto/exec.h>
  23 #include <strings.h>
  24
  25 #include "exec_intern.h"
  26 #include "etask.h"
  27
  28 #include "tlsf.h"
  29
  30 #include "kernel_intern.h"
  31 #include "kernel_debug.h"
  32 #include "kernel_romtags.h"
  33
  34 #include "exec_platform.h"
  35
  36 extern struct TagItem *BootMsg;
  37
  38 void __attribute__((used)) kernel_cstart(struct TagItem *msg);
  39
  40 uint32_t stack[AROS_STACKSIZE] __attribute__((used,aligned(16)));
  41 static uint32_t stack_super[AROS_STACKSIZE] __attribute__((used,aligned(16)));
  42
  43 static uint32_t stack_fiq[1024] __attribute__((used,aligned(16)));
  44
  45 asm (
  46     ".section .aros.init,\"ax\"\n\t"
  47     ".globl start\n\t"
  48     ".type start,%function\n"
  49     "start:\n"
  50     "           push {r0}                    \n"
  51     "           bl      __clear_bss          \n"
  52     "           pop {r0}                     \n"
  53     "           cps     #0x1f                \n" /* system mode */
  54     "           ldr     sp, stack_end        \n"
  55     "           cps     #0x11                \n" /* fiq mode */
  56     "           ldr     sp, stack_fiq_end    \n"
  57     "           cps     #0x13                \n" /* SVC (supervisor) mode */
  58     "           ldr     sp, stack_super_end  \n"
  59     "           b       kernel_cstart        \n"
  60
  61     ".string \"Native/CORE v3 (" __DATE__ ")\"" "\n\t\n\t"
  62 );
  63
  64 static uint32_t * const stack_end __attribute__((used, section(".aros.init"))) = &stack[AROS_STACKSIZE - sizeof(IPTR)];
  65 static uint32_t * const stack_super_end __attribute__((used, section(".aros.init"))) = &stack_super[AROS_STACKSIZE - sizeof(IPTR)];
  66 static uint32_t * const stack_fiq_end __attribute__((used, section(".aros.init"))) = &stack_fiq[1024 - sizeof(IPTR)];
  67
  68
  69 struct ARM_Implementation __arm_arosintern  __attribute__((aligned(4), section(".data"))) = {0,0,NULL,NULL};
  70 struct ExecBase *SysBase __attribute__((section(".data"))) = NULL;
  71
  72 static void __attribute__((used)) __clear_bss(struct TagItem *msg)
  73 {
  74     struct KernelBSS *bss = (struct KernelBSS *)krnGetTagData(KRN_KernelBss, 0, msg);
  75     register unsigned int dest;
  76     unsigned int length;
  77
  78     if (bss)
  79     {
  80         while (bss->addr && bss->len)
  81         {
  82             dest = (unsigned int)bss->addr;
  83             length = bss->len;
  84
  85             // If the start address is unaligned, fill in the first 1-3 bytes until it is
  86             while((dest & 3) && length)
  87             {
  88                 *((unsigned char *)dest) = 0;
  89                 dest++;
  90                 length--;
  91             }
  92
  93             // Fill in the remaining 32-bit word-aligned memory locations
  94             while(length & 0xfffffffc)
  95             {
  96                 *((unsigned int *)dest) = 0;
  97                 dest += 4;
  98                 length -= 4;
  99             }
 100
 101             // Deal with the remaining 1-3 bytes, if any
 102             while(length)
 103             {
 104                 dest++;
 105                 length--;
 106                 *((unsigned char *)dest) = 0;
 107             }
 108             bss++;
 109         }
 110     }
 111 }
 112
 113 void __attribute__((used)) kernel_cstart(struct TagItem *msg)
 114 {
 115     UWORD *ranges[3];
 116     struct MinList memList;
 117     struct MemHeader *mh;
 118     struct MemChunk *mc;
 119     long unsigned int memlower = 0, memupper = 0, protlower = 0, protupper = 0;
 120     char *cmdline = NULL;
 121     BootMsg = msg;
 122     tls_t *__tls;
 123
 124     // Probe the ARM core
 125     cpu_Probe(&__arm_arosintern);
 126
 127     // Probe the ARM Implementation/Platform
 128     __arm_arosintern.ARMI_Platform = 0;
 129     while(msg->ti_Tag != TAG_DONE)
 130     {
 131         switch (msg->ti_Tag)
 132         {
 133         case KRN_Platform:
 134             __arm_arosintern.ARMI_Platform = msg->ti_Data;
 135             break;
 136         }
 137         msg++;
 138     }
 139     msg = BootMsg;
 140
 141     platform_Init(&__arm_arosintern, msg);
 142
 143     if (__arm_arosintern.ARMI_LED_Toggle)
 144     {
 145         if (__arm_arosintern.ARMI_Delay)
 146             __arm_arosintern.ARMI_Delay(100000);
 147         __arm_arosintern.ARMI_LED_Toggle(ARM_LED_POWER, ARM_LED_OFF);
 148     }
 149
 150     cpu_Init(&__arm_arosintern, msg);
 151
 152     if (__arm_arosintern.ARMI_LED_Toggle)
 153     {
 154         if (__arm_arosintern.ARMI_Delay)
 155             __arm_arosintern.ARMI_Delay(100000);
 156         __arm_arosintern.ARMI_LED_Toggle(ARM_LED_POWER, ARM_LED_ON);
 157     }
 158
 159     /* NB: the bootstrap has conveniently setup the framebuffer
 160             and initialised the serial port and led for us */
 161
 162     while(msg->ti_Tag != TAG_DONE)
 163     {
 164         switch (msg->ti_Tag)
 165         {
 166         case KRN_CmdLine:
 167 //            RelocateStringData(tag);
 168             cmdline = (char *)msg->ti_Data;
 169             break;
 170         case KRN_MEMLower:
 171             memlower = msg->ti_Data;
 172             break;
 173         case KRN_MEMUpper:
 174             memupper = msg->ti_Data;
 175             break;
 176         case KRN_ProtAreaStart:
 177             protlower = msg->ti_Data;
 178             break;
 179         case KRN_ProtAreaEnd:
 180             // Page align
 181             protupper = (msg->ti_Data + 4095) & ~4095;
 182             break;
 183         case KRN_KernelBase:
 184             /*
 185              * KRN_KernelBase is actually a border between read-only
 186              * (code) and read-write (data) sections of the kickstart.
 187              * read-write section goes to lower addresses from this one,
 188              * so we align it upwards in order not to make part of RW data
 189              * read-only.
 190              */
 191 //            addr = AROS_ROUNDUP2(msg->ti_Data, PAGE_SIZE);
 192             break;
 193         }
 194         msg++;
 195     }
 196     msg = BootMsg;
 197
 198     __tls = (void *)protupper;
 199     protupper += (sizeof(tls_t) + 4095) & ~4095;
 200
 201     __tls->KernelBase = NULL;
 202     __tls->SysBase = NULL;
 203     __tls->ThisTask = NULL;
 204
 205     D(bug("[Kernel] AROS ARM Native Kernel built on %s\n", __DATE__));
 206
 207     D(bug("[Kernel] Entered kernel_cstart @ 0x%p, BootMsg @ 0x%p\n", kernel_cstart, BootMsg));
 208
 209     asm volatile("mcr p15, 0, %0, c13, c0, 3" : : "r"(__tls));
 210
 211     D(
 212         if (__arm_arosintern.ARMI_PutChar)
 213         {
 214             bug("[Kernel] Using PutChar implementation @ %p\n", __arm_arosintern.ARMI_PutChar);
 215         }
 216         bug("[Kernel] Boot CPU TLS @ 0x%p\n", __tls);
 217     )
 218
 219     core_SetupIntr();
 220
 221     if (__arm_arosintern.ARMI_LED_Toggle)
 222         __arm_arosintern.ARMI_LED_Toggle(ARM_LED_POWER, ARM_LED_OFF);
 223
 224     D(bug("[Kernel] Platform initialised\n"));
 225
 226     if (__arm_arosintern.ARMI_Delay)
 227             __arm_arosintern.ARMI_Delay(1500);
 228
 229     if (__arm_arosintern.ARMI_LED_Toggle)
 230         __arm_arosintern.ARMI_LED_Toggle(ARM_LED_POWER, ARM_LED_ON);
 231
 232     D(bug("[Kernel] Preparing memory 0x%p -> 0x%p\n", memlower, memupper));
 233     D(bug("[Kernel] - protected area 0x%p -> 0x%p)\n", protlower, protupper));
 234
 235     NEWLIST(&memList);
 236
 237     if (memlower >= protlower)
 238         memlower = protupper;
 239
 240     mh = (struct MemHeader *)memlower;
 241
 242     if (cmdline && strstr(cmdline, "notlsf"))
 243     {
 244 #if (0)
 245         krnCreateMemHeader("System Memory", 0, mh, (memupper - memlower), MEMF_FAST | MEMF_PUBLIC | MEMF_KICK | MEMF_LOCAL);
 246
 247         if (memlower < protlower)
 248         {
 249 //            AllocAbs(protupper-protlower, (void *)protlower);
 250         }
 251 #endif
 252     }
 253     else
 254     {
 255         /* Initialize TLSF memory allocator */
 256         krnCreateTLSFMemHeader("System Memory", 0, mh, (memupper - memlower), MEMF_FAST | MEMF_PUBLIC | MEMF_KICK | MEMF_LOCAL);
 257         if (memlower < protlower)
 258         {
 259             /* Protect the bootstrap area from further use. AllocAbs will do the trick */
 260             ((struct MemHeaderExt *)mh)->mhe_AllocAbs((struct MemHeaderExt *)mh, protupper-protlower, (void *)protlower);
 261         }
 262     }
 263
 264     ranges[0] = (UWORD *)krnGetTagData(KRN_KernelLowest, 0, msg);
 265     ranges[1] = (UWORD *)krnGetTagData(KRN_KernelHighest, 0, msg);
 266     ranges[2] = (UWORD *)-1;
 267
 268     D(bug("[Kernel] Preparing ExecBase (memheader @ 0x%p)\n", mh));
 269     krnPrepareExecBase(ranges, mh, BootMsg);
 270
 271     __tls->SysBase = SysBase;
 272     D(bug("[Kernel] SysBase @ 0x%p\n", SysBase));
 273
 274     /*
 275      * Make kickstart code area read-only.
 276      * We do it only after ExecBase creation because SysBase pointer is put
 277      * into .rodata. This way we prevent it from ocassional modification by buggy software.
 278      */
 279 //    core_ProtKernelArea(addr, kick_highest - addr, 1, 0, 1);
 280
 281     D(bug("[Kernel] InitCode(RTF_SINGLETASK) ... \n"));
 282     InitCode(RTF_SINGLETASK, 0);
 283
 284     D(bug("[Kernel] Dropping into USER mode ... \n"));
 285     asm("cps %[mode_user]\n" : : [mode_user] "I" (CPUMODE_USER)); /* switch to user mode */
 286
 287     D(bug("[Kernel] InitCode(RTF_COLDSTART) ...\n"));
 288     InitCode(RTF_COLDSTART, 0);
 289
 290     /* The above should not return */
 291     krnPanic(KernelBase, "System Boot Failed!");
 292 }
 293
 294 DEFINESET(ARMPLATFORMS);