arch/arm-efika/boot/boot.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: boot.c
   6     Lang: english
   7 */
   8
   9 #include <inttypes.h>
  10 #include <asm/cpu.h>
  11 #include <asm/arm/mmu.h>
  12 #include <utility/tagitem.h>
  13 #include <aros/macros.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16
  17 #include "boot.h"
  18 #include "serialdebug.h"
  19 #include "atags.h"
  20 #include "elf.h"
  21
  22 asm("   .section .aros.startup          \n"
  23 "               .globl bootstrap                        \n"
  24 "               .type bootstrap,%function       \n"
  25 "bootstrap:                                                     \n"
  26 "               movw    r0,#:lower16:tmp_stack_ptr\n"
  27 "               movt    r0,#:upper16:tmp_stack_ptr\n"
  28 "               ldr             sp,[r0,#0]                      \n"
  29 "               b               boot                            \n"
  30 );
  31
  32 static __used unsigned char __stack[BOOT_STACK_SIZE];
  33 static __used void * tmp_stack_ptr = &__stack[BOOT_STACK_SIZE-16];
  34
  35 static struct TagItem tags[128];
  36 static struct TagItem *tag = &tags[0];
  37 static unsigned long mem_upper;
  38 static unsigned long mem_lower;
  39 static void *pkg_image;
  40 static uint32_t pkg_size;
  41
  42 #define MAX_PAGE_TABLES 10
  43
  44 static pde_t page_dir[4096] __attribute__((aligned(16384)));
  45 static pte_t page_tables[MAX_PAGE_TABLES][256] __attribute__((aligned(1024)));
  46
  47 static void parse_atags(struct tag *tags)
  48 {
  49         struct tag *t = NULL;
  50
  51         kprintf("[BOOT] Parsing ATAGS\n");
  52
  53         for_each_tag(t, tags)
  54         {
  55                 kprintf("[BOOT]   %08x (%04x): ", t->hdr.tag, t->hdr.size);
  56                 switch (t->hdr.tag)
  57                 {
  58                 case ATAG_MEM:
  59                         kprintf("Memory (%08x-%08x)\n", t->u.mem.start, t->u.mem.size + t->u.mem.start - 1);
  60                 tag->ti_Tag = KRN_MEMLower;
  61                 tag->ti_Data = t->u.mem.start;
  62                 tag++;
  63                 tag->ti_Tag = KRN_MEMUpper;
  64                 tag->ti_Data = t->u.mem.start + t->u.mem.size;
  65                 tag++;
  66
  67                 mem_upper = t->u.mem.start + t->u.mem.size;
  68                 mem_lower = t->u.mem.start;
  69
  70                         break;
  71                 case ATAG_CMDLINE:
  72                 {
  73                         char *cmdline = malloc(strlen(t->u.cmdline.cmdline) + 1);
  74                         strcpy(cmdline, t->u.cmdline.cmdline);
  75                         kprintf("CMDLine: \"%s\"\n", cmdline);
  76
  77                         tag->ti_Tag = KRN_CmdLine;
  78                 tag->ti_Data = (intptr_t)cmdline;
  79                 tag++;
  80                 }
  81                         break;
  82                 case ATAG_INITRD2:
  83                         kprintf("RAMDISK: (%08x-%08x)\n", t->u.initrd.start, t->u.initrd.size + t->u.initrd.start - 1);
  84                         pkg_image = (void *)t->u.initrd.start;
  85                         pkg_size = t->u.initrd.size;
  86                         break;
  87                 default:
  88                         kprintf("IGN...\n");
  89                         break;
  90                 }
  91         }
  92 }
  93
  94 void setup_mmu(uintptr_t kernel_phys, uintptr_t kernel_virt, uintptr_t length)
  95 {
  96     int i;
  97     uintptr_t first_1M_page = kernel_virt & 0xfff00000;
  98     uintptr_t last_1M_page = ((kernel_virt + length + 0x000fffff) & 0xfff00000) - 1;
  99
 100     kprintf("[BOOT] Preparing initial MMU map\n");
 101
 102     /* Clear page dir */
 103     for (i=0; i < 4096; i++)
 104         page_dir[i].raw = 0;
 105
 106     /* 1:1 memory mapping */
 107     for (i=(mem_lower >> 20); i < (mem_upper >> 20); i++)
 108     {
 109         page_dir[i].section.type = PDE_TYPE_SECTION;
 110         page_dir[i].section.b = 0;
 111         page_dir[i].section.c = 1;      /* Cacheable */
 112         page_dir[i].section.ap = 3;     /* All can read&write */
 113         page_dir[i].section.base_address = i;
 114     }
 115
 116     /* 0x70000000 - 0x7fffffff */
 117     for (i = (0x70000000 >> 20); i < (0x80000000 >> 20); i++)
 118     {
 119         page_dir[i].section.type = PDE_TYPE_SECTION;
 120         page_dir[i].section.b = 1;      /* Shared device */
 121         page_dir[i].section.c = 0;      /* Non-Cacheable */
 122         page_dir[i].section.ap = 3;     /* All can read&write */
 123         page_dir[i].section.base_address = i;
 124     }
 125
 126     kprintf("[BOOT] Preparing mapping for kernel (%d bytes, pages %08x to %08x)\n",
 127             length, first_1M_page, last_1M_page);
 128
 129     int fp = first_1M_page >> 20;
 130     int lp = last_1M_page >> 20;
 131     int used_pte = 0;
 132
 133     if (lp == fp) lp++;
 134
 135     for (i = fp; i < lp; i++)
 136     {
 137         if (used_pte >= MAX_PAGE_TABLES)
 138         {
 139             kprintf("[BOOT] Run out of free page tables. Kernel larger than 10MB?\n");
 140             for(;;);
 141         }
 142
 143         page_dir[i].coarse.type = PDE_TYPE_COARSE;
 144         page_dir[i].coarse.domain = 0;
 145         page_dir[i].coarse.sbz = 0;
 146         page_dir[i].coarse.imp = 0;
 147         page_dir[i].coarse.base_address = (intptr_t)&page_tables[used_pte] >> 10;
 148
 149         int j;
 150         for (j = 0; j < 256; j++)
 151         {
 152             uintptr_t synth_addr = (i << 20) + (j << 12);
 153
 154             if (synth_addr < kernel_virt)
 155                 page_tables[used_pte][j].raw = 0;
 156             else if (synth_addr < kernel_virt + length)
 157             {
 158                 page_tables[used_pte][j].raw = 0;
 159                 page_tables[used_pte][j].page.base_address = (synth_addr - kernel_virt + kernel_phys) >> 12;
 160                 page_tables[used_pte][j].page.b = 0;
 161                 page_tables[used_pte][j].page.c = 1;
 162                 page_tables[used_pte][j].page.ap = 3;
 163                 page_tables[used_pte][j].page.type = PTE_TYPE_PAGE;
 164             }
 165             else
 166                 page_tables[used_pte][j].raw = 0;
 167         }
 168
 169         used_pte++;
 170     }
 171
 172 }
 173
 174 void boot(uintptr_t dummy, uintptr_t arch, struct tag * atags)
 175 {
 176         uint32_t tmp;
 177         void (*entry)(struct TagItem *tags);
 178
 179         /* Enable NEON and VFP */
 180     asm volatile ("mrc p15, 0, %0, c1, c0, 2":"=r"(tmp));
 181     tmp |= 3 << 20;
 182     tmp |= 3 << 22;
 183     asm volatile ("mcr p15, 0, %0, c1, c0, 2"::"r"(tmp));
 184
 185     fmxr(cr8, fmrx(cr8) | 1 << 30);
 186
 187     kprintf("[BOOT] AROS for EfikaMX bootstrap\n");
 188
 189     asm volatile ("mrc p15, 0, %0, c1, c0, 0":"=r"(tmp));
 190     kprintf("[BOOT] control register %08x\n", tmp);
 191     tmp &= ~2;          /* Disable MMU and caches */
 192     tmp |= 1 << 13;     /* Exception vectors at 0xffff0000 */
 193     asm volatile ("mcr p15, 0, %0, c1, c0, 0"::"r"(tmp));
 194
 195     asm volatile ("mrc p15, 0, %0, c1, c0, 0":"=r"(tmp));
 196         kprintf("[BOOT] control register %08x\n", tmp);
 197
 198     tag->ti_Tag = KRN_BootLoader;
 199     tag->ti_Data = (IPTR)"Bootstrap/EfikaMX ARM";
 200     tag++;
 201
 202     parse_atags(atags);
 203
 204     kprintf("[BOOT] Bootstrap @ %08x-%08x\n", &__bootstrap_start, &__bootstrap_end);
 205     kprintf("[BOOT] Topmost address for kernel: %p\n", mem_upper);
 206
 207     if (mem_upper)
 208     {
 209         mem_upper = mem_upper & ~4095;
 210
 211         unsigned long kernel_phys = mem_upper;
 212         unsigned long kernel_virt = kernel_phys;
 213
 214         unsigned long total_size_ro, total_size_rw;
 215         uint32_t size_ro, size_rw;
 216
 217         /* Calculate total size of kernel and modules */
 218
 219         getElfSize(&_binary_kernel_bin_start, &size_rw, &size_ro);
 220
 221         total_size_ro = size_ro = (size_ro + 4095) & ~4095;
 222         total_size_rw = size_rw = (size_rw + 4095) & ~4095;
 223
 224         if (pkg_image && pkg_size)
 225         {
 226                 uint8_t *base = pkg_image;
 227
 228                 if (base[0] == 0x7f && base[1] == 'E' && base[2] == 'L' && base[3] == 'F')
 229                 {
 230                         kprintf("[BOOT] Kernel image is ELF file\n");
 231
 232                         getElfSize(base, &size_rw, &size_ro);
 233
 234                 total_size_ro += (size_ro + 4095) & ~4095;
 235                 total_size_rw += (size_rw + 4095) & ~4095;
 236                 }
 237                 else if (base[0] == 'P' && base[1] == 'K' && base[2] == 'G' && base[3] == 0x01)
 238                 {
 239                         kprintf("[BOOT] Kernel image is a package:\n");
 240
 241                         uint8_t *file = base+4;
 242                         uint32_t total_length = AROS_BE2LONG(*(uint32_t*)file); /* Total length of the module */
 243                         const uint8_t *file_end = base+total_length;
 244                         uint32_t len;
 245
 246                         kprintf("[BOOT] Package size: %dKB\n", total_length >> 10);
 247
 248                         file = base + 8;
 249
 250                         while(file < file_end)
 251                         {
 252                                 const char *filename = remove_path(file+4);
 253
 254                                 /* get text length */
 255                                 len = AROS_BE2LONG(*(uint32_t*)file);
 256                                 /* display the file name */
 257                                 kprintf("[BOOT]    %s \n", filename);
 258
 259                                 file += len + 5;
 260
 261                                 len = AROS_BE2LONG(*(uint32_t *)file);
 262                                 file += 4;
 263
 264                                 /* load it */
 265                                 getElfSize(file, &size_rw, &size_ro);
 266
 267                                 total_size_ro += (size_ro + 4095) & ~4095;
 268                                 total_size_rw += (size_rw + 4095) & ~4095;
 269
 270                                 /* go to the next file */
 271                                 file += len;
 272                         }
 273                 }
 274         }
 275
 276         kernel_phys = mem_upper - total_size_ro - total_size_rw;
 277         kernel_virt = 0xffff0000 - total_size_ro - total_size_rw;
 278
 279         kprintf("[BOOT] Physical address of kernel: %p\n", kernel_phys);
 280         kprintf("[BOOT] Virtual address of kernel: %p\n", kernel_virt);
 281
 282         entry = (void (*)(struct TagItem))kernel_virt;
 283
 284         initAllocator(kernel_phys, kernel_phys  + total_size_ro, kernel_virt - kernel_phys);
 285
 286         tag->ti_Tag = KRN_KernelLowest;
 287         tag->ti_Data = kernel_phys;
 288         tag++;
 289
 290         tag->ti_Tag = KRN_KernelHighest;
 291         tag->ti_Data = kernel_phys + ((total_size_ro + 4095) & ~4095) + ((total_size_rw + 4095) & ~4095);
 292         tag++;
 293
 294         loadElf(&_binary_kernel_bin_start);
 295
 296         if (pkg_image && pkg_size)
 297         {
 298                 uint8_t *base = pkg_image;
 299
 300                 if (base[0] == 0x7f && base[1] == 'E' && base[2] == 'L' && base[3] == 'F')
 301                 {
 302                         kprintf("[BOOT] Kernel image is ELF file\n");
 303
 304                 /* load it */
 305                 loadElf(base);
 306                 }
 307                 else if (base[0] == 'P' && base[1] == 'K' && base[2] == 'G' && base[3] == 0x01)
 308                 {
 309                         kprintf("[BOOT] Kernel image is a package:\n");
 310
 311                         uint8_t *file = base+4;
 312                         uint32_t total_length = AROS_BE2LONG(*(uint32_t*)file); /* Total length of the module */
 313                         const uint8_t *file_end = base+total_length;
 314                         uint32_t len;
 315
 316                         kprintf("[BOOT] Package size: %dKB\n", total_length >> 10);
 317
 318                         file = base + 8;
 319
 320                         while(file < file_end)
 321                         {
 322                                 const char *filename = remove_path(file+4);
 323
 324                                 /* get text length */
 325                                 len = AROS_BE2LONG(*(uint32_t*)file);
 326                                 /* display the file name */
 327                                 kprintf("[BOOT]    %s ", filename);
 328
 329                                 file += len + 5;
 330
 331                                 len = AROS_BE2LONG(*(uint32_t *)file);
 332                                 file += 4;
 333
 334                                 /* load it */
 335                                 loadElf(file);
 336
 337                                 /* go to the next file */
 338                                 file += len;
 339                         }
 340                 }
 341         }
 342
 343         arm_flush_cache(kernel_phys, total_size_ro + total_size_rw);
 344
 345         tag->ti_Tag = KRN_KernelBss;
 346         tag->ti_Data = (IPTR)tracker;
 347         tag++;
 348
 349
 350         kprintf("[BOOT] First level MMU page at %08x\n", page_dir);
 351
 352         setup_mmu(kernel_phys, kernel_virt, total_size_ro + total_size_rw);
 353     }
 354
 355     tag->ti_Tag = TAG_DONE;
 356     tag->ti_Data = 0;
 357
 358     kprintf("[BOOT] Kernel taglist contains %d entries\n", ((intptr_t)tag - (intptr_t)tags)/sizeof(struct TagItem));
 359     kprintf("[BOOT] Bootstrap wasted %d bytes of memory for kernels use\n", mem_used()   );
 360
 361
 362     /* Write page_dir address to ttbr0 */
 363     asm volatile ("mcr p15, 0, %0, c2, c0, 0"::"r"(page_dir));
 364     /* Write ttbr control N = 0 (use only ttbr0) */
 365     asm volatile ("mcr p15, 0, %0, c2, c0, 2"::"r"(0));
 366
 367     asm volatile ("mrc p15, 0, %0, c1, c0, 0":"=r"(tmp));
 368     kprintf("[BOOT] control register %08x\n", tmp);
 369     tmp |= 1;          /* Enable MMU */
 370     asm volatile ("mcr p15, 0, %0, c1, c0, 0"::"r"(tmp));
 371
 372     asm volatile ("mrc p15, 0, %0, c1, c0, 0":"=r"(tmp));
 373     kprintf("[BOOT] control register %08x\n", tmp);
 374
 375     kprintf("[BOOT] Heading over to AROS kernel @ %08x\n", entry);
 376
 377     entry(tags);
 378
 379     kprintf("[BOOT] Back? Something wrong happened...\n");
 380
 381     while(1);
 382 }