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