arch/ppc-chrp/efika/kernel/kernel_init.c

   1 /*
   2  * kernel_init.c
   3  *
   4  *  Created on: Aug 19, 2008
   5  *      Author: misc
   6  */
   7
   8 #define DEBUG 1
   9
  10 #include <aros/kernel.h>
  11 #include <aros/symbolsets.h>
  12 #include <exec/memory.h>
  13 #include <exec/tasks.h>
  14 #include <exec/alerts.h>
  15 #include <exec/execbase.h>
  16 #include <asm/io.h>
  17 #include <asm/mpc5200b.h>
  18 #include <proto/kernel.h>
  19 #include <strings.h>
  20
  21 #include <proto/exec.h>
  22
  23 #include "exec_intern.h"
  24 #include "etask.h"
  25
  26 #include "kernel_intern.h"
  27 #include LC_LIBDEFS_FILE
  28 #include "syscall.h"
  29 #include "memory.h"
  30
  31 static void __attribute__((used)) kernel_cstart(struct TagItem *msg);
  32 struct OFWNode *krnCopyOFWTree(struct OFWNode *orig);
  33 int exec_main(struct TagItem *msg, void *entry);
  34
  35 asm(".section .aros.init,\"ax\"\n\t"
  36     ".globl start\n\t"
  37     ".type start,@function\n"
  38     "start:\n\t"
  39
  40     "mr %r29,%r3\n\t"   /* Keep it for later */
  41
  42         "li %r0,0x2000\n\t"
  43         "mtmsr %r0\n\t"         /* Disable address translation */
  44         "sync; isync\n\t"
  45
  46 /* Set up BAT registers with a very simple map. */
  47 /* IBAT0 virtual 0xff800000 into physical 0x07800000, size 8MB, read only, super only, cached */
  48         "lis %r0, 0xff80; "
  49         "ori %r0, %r0, 0x2 | 0xfc; "
  50         "mtspr 528,%r0; "               /* Clear all BAT entries */
  51         "lis %r0, 0x0780;"
  52         "ori %r0,%r0,0x01 | 0x10; "
  53         "mtspr 529, %r0;"
  54
  55 /* IBAT1 virtual 0x07800000 into physical 0x07800000, size 8MB, read only, super only, cached */
  56         "lis %r0, 0x0780; "
  57         "ori %r0, %r0, 0x2 | 0xfc; "
  58         "mtspr 530,%r0; "               /* Clear all BAT entries */
  59         "lis %r0, 0x0780;"
  60         "ori %r0,%r0,0x01 | 0x10; "
  61         "mtspr 531, %r0;"
  62
  63 /* Clear IBAT1 - IBAT7 */
  64         "lis %r0, 0; "
  65         "mtspr 532, %r0;"
  66         "mtspr 533, %r0;"
  67         "mtspr 534, %r0;"
  68         "mtspr 535, %r0;"
  69
  70         "mtspr 560, %r0;"
  71         "mtspr 561, %r0;"
  72         "mtspr 562, %r0;"
  73         "mtspr 563, %r0;"
  74         "mtspr 564, %r0;"
  75         "mtspr 565, %r0;"
  76         "mtspr 566, %r0;"
  77         "mtspr 567, %r0;"
  78
  79 /* DBAT0 virtual 0xff000000, physical 0x07000000, size 8MB, read write, super only, cached */
  80         "lis %r0, 0xff00; "
  81         "ori %r0, %r0, 0x2 | 0xfc; "
  82         "mtspr 536,%r0; "               /* Clear all BAT entries */
  83         "lis %r0, 0x0700;"
  84         "ori %r0,%r0,0x02 | 0x10; "
  85         "mtspr 537, %r0;"
  86 /* DBAT1 virtual 0xff800000, physical 0x07800000, size 8MB, read only, super only, cached */
  87         "lis %r0, 0xff80; "
  88         "ori %r0, %r0, 0x2 | 0xfc; "
  89         "mtspr 538,%r0; "               /* Clear all BAT entries */
  90         "lis %r0, 0x0780;"
  91         "ori %r0,%r0,0x01 | 0x10; "
  92         "mtspr 539, %r0;"
  93 /* DBAT2 virtual 0x00000000, physical 0x00000000, 128MB, read write, super only, cached */
  94         "lis %r0, 0x0000; "
  95         "ori %r0, %r0, 0x2 | 0x1ffc; "
  96         "mtspr 540,%r0; "               /* Clear all BAT entries */
  97         "lis %r0, 0x0000;"
  98         "ori %r0,%r0,0x02 | 0x10; "
  99         "mtspr 541, %r0;"
 100 /* DBAT3 virtual 0xf0000000, physical 0xf0000000, 128KB, read write, super only, not cached */
 101         "lis %r0, 0xf000; "
 102         "ori %r0, %r0, 0x3; "
 103         "mtspr 542,%r0; "
 104         "lis %r0, 0xf000;"
 105         "ori %r0,%r0,0x0a | 0x20; "
 106         "mtspr 543, %r0;"
 107
 108 /* Clear DBAT3 - DBAT7 */
 109         "lis %r0, 0; "
 110
 111         "mtspr 568, %r0;"
 112         "mtspr 569, %r0;"
 113         "mtspr 570, %r0;"
 114         "mtspr 571, %r0;"
 115         "mtspr 572, %r0;"
 116         "mtspr 573, %r0;"
 117         "mtspr 574, %r0;"
 118         "mtspr 575, %r0;"
 119
 120         "mttbl %r0; mttbu %r0; mttbl %r0;"
 121
 122         /* Enable address translation again. All accesses will be done through BAT registers */
 123         "li %r0, 0x2030;"
 124         "mtmsr %r0;sync;isync;"
 125
 126         "lis %r9,tmp_stack_end@ha\n\t"      /* Use temporary stack while clearing BSS */
 127         "lwz %r1,tmp_stack_end@l(%r9)\n\t"
 128         "mr %r3,%r29\n\t"
 129         "bl __clear_bss\n\t"                /* Clear BSS */
 130
 131         "lis %r11,target_address@ha\n\t"    /* Load the address of init code in C */
 132         "mr %r3,%r29\n\t"                   /* restore the message */
 133         "lwz %r11,target_address@l(%r11)\n\t"
 134         "lis %r9,stack_end@ha\n\t"          /* Use brand new stack to do evil things */
 135         "mtctr %r11\n\t"
 136         "lwz %r1,stack_end@l(%r9)\n\t"
 137
 138         "bctr\n\t"                          /* And start the game... */
 139
 140         ".string \"Native/CORE v3 (" __DATE__ ")\""
 141         "\n\t.text\n\t"
 142 );
 143
 144 static void __attribute__((used)) __clear_bss(struct TagItem *msg)
 145 {
 146     struct KernelBSS *bss;
 147
 148     bss =(struct KernelBSS *)krnGetTagData(KRN_KernelBss, 0, msg);
 149
 150     if (bss)
 151     {
 152         while (bss->addr && bss->len)
 153         {
 154             bzero(bss->addr, bss->len);
 155             bss++;
 156         }
 157     }
 158 }
 159
 160 static __attribute__((used,section(".data"),aligned(16))) union {
 161     struct TagItem bootup_tags[64];
 162     uint32_t  tmp_stack[128];
 163 } tmp_struct;
 164 static const uint32_t *tmp_stack_end __attribute__((used, section(".text"))) = &tmp_struct.tmp_stack[124];
 165 static uint32_t stack[STACK_SIZE] __attribute__((used,aligned(16)));
 166 static uint32_t stack_super[STACK_SIZE] __attribute__((used,aligned(16)));
 167 static const uint32_t *stack_end __attribute__((used, section(".text"))) = &stack[STACK_SIZE-4];
 168 static const void *target_address __attribute__((used, section(".text"))) = (void*)kernel_cstart;
 169 static uint8_t *mmu_dir;
 170 static uint32_t *MBAR;
 171
 172 /* Variables which should go to the .data section */
 173 static struct OFWNode *ofw_root_node __attribute__((used,section(".data"))) = NULL;
 174 struct TagItem *BootMsg __attribute__((used,section(".data"))) = NULL;
 175 static uint8_t *memlo __attribute__((used,section(".data"))) = NULL;
 176
 177 module_t *modlist;
 178 uint32_t modlength;
 179
 180 static void __attribute__((used)) kernel_cstart(struct TagItem *msg)
 181 {
 182         D(bug("[KRN] EFika5200B Kernel build on %s\n", __DATE__));
 183         struct TagItem *tmp = tmp_struct.bootup_tags;
 184         struct TagItem *src = msg;
 185         struct OFWNode *node;
 186
 187         wrspr(SPRG0, (uint32_t)&stack_super[STACK_SIZE-4]);
 188         wrspr(SPRG4, 0);
 189         wrspr(SPRG5, 0);
 190         wrmsr(rdmsr() | MSR_FP);
 191
 192         /* MMU directory - 1MB is recommended size for systems with 128MB ram
 193          * USE PHYSICAL ADDRESS HERE! */
 194         mmu_dir = (uint8_t *)0x07000000;
 195
 196         D(bug("[KRN] BootMsg @ %p\n", msg));
 197
 198         if (msg == BootMsg)
 199         {
 200                 D(bug("[KRN] Reboot detected\n"));
 201         }
 202         else
 203         {
 204                 /* Set the memlo pointer right after MMU dir */
 205                 memlo = 0xff100000;
 206
 207                 D(bug("[KRN] Copying TagList and data\n"));
 208
 209                 while(msg->ti_Tag != TAG_DONE)
 210                 {
 211                         *tmp = *msg;
 212
 213                         if (tmp->ti_Tag == KRN_CmdLine)
 214                         {
 215                                 tmp->ti_Data = (intptr_t)memlo;
 216                                 memlo += (strlen(msg->ti_Data) + 4) & ~3;
 217                                 memcpy(tmp->ti_Data, msg->ti_Data, strlen(msg->ti_Data)+1);
 218                                 D(bug("[KRN] CmdLine: '%s'\n", tmp->ti_Data));
 219                         }
 220                         else if (tmp->ti_Tag == KRN_KernelBss)
 221                         {
 222                                 struct KernelBSS *bss_in, *bss_out;
 223
 224                                 bss_out = (struct KernelBSS *)memlo;
 225                                 bss_in = msg->ti_Data;
 226
 227                                 tmp->ti_Data = (intptr_t)bss_out;
 228
 229                                 while(bss_in->addr && bss_in->len)
 230                                 {
 231                                         *bss_out++ = *bss_in++;
 232                                 }
 233                                 *bss_out++ = *bss_in++;
 234
 235                                 memlo = (uint8_t *)bss_out;
 236                         }
 237                         else if (tmp->ti_Tag == KRN_OpenFirmwareTree)
 238                         {
 239                                 ofw_root_node = krnCopyOFWTree((struct OFWNode *)msg->ti_Data);
 240                                 tmp->ti_Data = (intptr_t)ofw_root_node;
 241                         }
 242                         else if (tmp->ti_Tag == KRN_DebugInfo)
 243                         {
 244                                 int i;
 245                                 struct MinList *mlist = tmp->ti_Data;
 246
 247                                 D(bug("[KRN] DebugInfo at %08x\n", modlist));
 248
 249                                 module_t *mod = (module_t *)memlo;
 250
 251                                 ListLength(mlist, modlength);
 252                                 modlist = mod;
 253
 254                                 memlo = &mod[modlength];
 255
 256                                 D(bug("[KRN] Bootstrap loaded debug info for %d modules\n", modlength));
 257
 258                                 /* Copy the module entries */
 259                                 for (i=0; i < modlength; i++)
 260                                 {
 261                                         module_t *m = REMHEAD(mlist);
 262                                         symbol_t *sym;
 263
 264                                         mod[i].m_lowest = m->m_lowest;
 265                                         mod[i].m_highest = m->m_highest;
 266                                         mod[i].m_str = NULL;
 267                                         NEWLIST(&mod[i].m_symbols);
 268                                         mod[i].m_name = (char *)memlo;
 269                                         memlo += (strlen(m->m_name) + 4) & ~3;
 270                                         strcpy(mod[i].m_name, m->m_name);
 271
 272                                         ForeachNode(&m->m_symbols, sym)
 273                                         {
 274                                                 symbol_t *newsym = memlo;
 275                                                 memlo += sizeof(symbol_t);
 276
 277                                                 newsym->s_name = memlo;
 278                                                 memlo += (strlen(sym->s_name)+4)&~3;
 279                                                 strcpy(newsym->s_name, sym->s_name);
 280
 281                                                 newsym->s_lowest = sym->s_lowest;
 282                                                 newsym->s_highest = sym->s_highest;
 283
 284                                                 ADDTAIL(&mod[i].m_symbols, newsym);
 285                                         }
 286                                 }
 287
 288                                 D(bug("[KRN] Debug info uses %d KB of memory\n", ((intptr_t)memlo - (intptr_t)mod) >> 10));
 289                         }
 290
 291                         tmp++;
 292                         msg++;
 293                 }
 294                 *tmp = *msg;
 295
 296                 memlo = (char *)(((intptr_t)memlo + 4095) & ~4095);
 297
 298                 BootMsg = tmp_struct.bootup_tags;
 299         }
 300
 301         intr_init();
 302         mmu_init(mmu_dir, 0x100000);
 303
 304         /*
 305          * Find the "/builtin" node in ofw tree and read it's reg property. It is
 306          * the only way to obtain the value of MBAR register (that is, location of
 307          * the CPU in-chip peripherials
 308          */
 309         ForeachNode(&ofw_root_node->on_children, node)
 310         {
 311                 if (!strcmp(node->on_name, "builtin"))
 312                         break;
 313         }
 314
 315         if (node)
 316         {
 317                 struct OFWProperty *prop = NULL;
 318
 319                 ForeachNode(&node->on_properties, prop)
 320                 {
 321                         if (!strcmp(prop->op_name,"reg"))
 322                                 break;
 323                 }
 324
 325                 if (prop)
 326                 {
 327                         MBAR = *(uint32_t**)prop->op_value;
 328
 329                         D(bug("[KRN] MBAR at %08x\n", MBAR));
 330                 }
 331         }
 332
 333         /* Enable dynamic power management */
 334         wrspr(1008, 0x0010c000);
 335         D(bug("[KRN] HID0=%08x HID1=%08x\n", rdspr(1008), rdspr(1009)));
 336
 337         ictl_init(MBAR);
 338
 339         D(bug("[KRN] Mapping 00003000-06ffffff range for public use\n"));
 340         mmu_map_area(0x00003000, 0x00003000, 0x06ffd000, (2 << 3) | 2); // PP = 10, WIMG = 0010
 341
 342         D(bug("[KRN] Mapping %08x-%08x range for MBAR\n", MBAR, MBAR + 0xc000 - 1));
 343         mmu_map_area((uint64_t)MBAR & 0xffffffff, (uint64_t)MBAR & 0xffffffff, 0x0000c000, (5 << 3) | 2); // PP = 10, WIMG = 0101
 344
 345         D(bug("[KRN] Mapping %08x-%08x range for public read-only access\n", 0xff100000, memlo - 1));
 346         mmu_map_area(0xff100000, 0x07100000, (intptr_t)memlo - 0xff100000, (2 << 3) | 1); // PP = 01, WIMG = 0010
 347
 348         uintptr_t krn_base = krnGetTagData(KRN_KernelBase, 0, BootMsg);
 349         uintptr_t krn_lowest = krnGetTagData(KRN_KernelLowest, 0, BootMsg) & ~4095;
 350         uintptr_t krn_highest = (krnGetTagData(KRN_KernelHighest, 0, BootMsg) + 4095) & ~4095;
 351
 352         D(bug("[KRN] Mapping %08x-%08x range for supervisor\n", memlo, (krn_lowest ^ 0xf8000000)-1));
 353         mmu_map_area((uint32_t)memlo, (uint32_t)memlo ^ 0xf8000000, (krn_lowest ^ 0xf8000000) - (intptr_t)memlo, (2 << 3) | 0); // PP = 00, WIMG = 0010
 354
 355         D(bug("[KRN] Mapping %08x-%08x range for read-write\n", krn_lowest^0xf8000000, (krn_base ^ 0xf8000000)-1));
 356         mmu_map_area((uint32_t)krn_lowest^0xf8000000, (uint32_t)krn_lowest, (krn_base - krn_lowest), (2 << 3) | 2); // PP = 10, WIMG = 0010
 357
 358         D(bug("[KRN] Mapping %08x-%08x range for read-only\n", krn_base^0xf8000000, (krn_highest ^ 0xf8000000)-1));
 359         mmu_map_area((uint32_t)krn_base^0xf8000000, (uint32_t)krn_base, (krn_highest - krn_base), (2 << 3) | 3); // PP = 11, WIMG = 0010
 360
 361         D(bug("[KRN] Mapping %08x-%08x range for supervisor\n", krn_highest ^ 0xf8000000, 0xffffffff));
 362         mmu_map_area((uint32_t)krn_highest^0xf8000000, (uint32_t)krn_highest, -(krn_highest^0xf8000000), (2 << 3) | 0); // PP = 00, WIMG = 0010
 363
 364     /* Prepare the MemHeader structure for this region */
 365         struct MemHeader *mh = (struct MemHeader *)memlo;
 366         mh->mh_First = (struct MemChunk *)((uint8_t *)mh + MEMHEADER_TOTAL);
 367         mh->mh_Free = ((krn_lowest^0xf8000000) - MEMHEADER_TOTAL - (intptr_t)memlo) & ~(MEMCHUNK_TOTAL-1);
 368         mh->mh_First->mc_Next = NULL;
 369         mh->mh_First->mc_Bytes = mh->mh_Free;
 370
 371         D(bug("[KRN] Supervisor mem: %dKB free\n", mh->mh_Free >> 10));
 372
 373     exec_main(BootMsg, NULL);
 374
 375         goSuper();
 376         D(bug("[KRN] Uhm? Nothing to do?\n[KRN] STOPPED\n"));
 377         /* Dead end */
 378         while(1) {
 379                 wrmsr(rdmsr() | MSR_EE);
 380                 wrmsr(rdmsr() | MSR_POW);
 381         }
 382 }
 383
 384
 385 AROS_LH0I(struct TagItem *, KrnGetBootInfo,
 386          struct KernelBase *, KernelBase, 10, Kernel)
 387 {
 388     AROS_LIBFUNC_INIT
 389
 390     return BootMsg;
 391
 392     AROS_LIBFUNC_EXIT
 393 }
 394
 395 AROS_LH0(void *, KrnCreateContext,
 396          struct KernelBase *, KernelBase, 10, Kernel)
 397 {
 398     AROS_LIBFUNC_INIT
 399
 400     context_t *ctx;
 401
 402     uint32_t oldmsr = goSuper();
 403
 404     ctx = Allocate(KernelBase->kb_SupervisorMem, sizeof(context_t));
 405     bzero(ctx, sizeof(context_t));
 406
 407     wrmsr(oldmsr);
 408
 409     if (!ctx)
 410         ctx = AllocMem(sizeof(context_t), MEMF_PUBLIC|MEMF_CLEAR);
 411
 412     return ctx;
 413
 414     AROS_LIBFUNC_EXIT
 415 }
 416
 417 AROS_LH1(void, KrnDeleteContext,
 418                 AROS_LHA(void *, context, A0),
 419          struct KernelBase *, KernelBase, 10, Kernel)
 420 {
 421     AROS_LIBFUNC_INIT
 422
 423     /* Was context in supervisor space? Deallocate it there :) */
 424     if ((intptr_t)context & 0xf0000000)
 425     {
 426         uint32_t oldmsr = goSuper();
 427
 428         Deallocate(KernelBase->kb_SupervisorMem, context, sizeof(context_t));
 429
 430         wrmsr(oldmsr);
 431     }
 432     else
 433         FreeMem(context, sizeof(context_t));
 434
 435     /* Was this context owning a FPU? Make FPU totally free then */
 436     if (KernelBase->kb_FPUOwner == context)
 437         KernelBase->kb_FPUOwner = NULL;
 438
 439     AROS_LIBFUNC_EXIT
 440 }
 441
 442
 443 struct OFWNode *krnCopyOFWTree(struct OFWNode *orig)
 444 {
 445         uint32_t node_length = sizeof(struct OFWNode) + strlen(orig->on_name) + 1;
 446         struct OFWNode *new_node = (struct OFWNode *)memlo;
 447         struct OFWNode *child;
 448         struct OFWProperty *prop, *new_prop;
 449         memlo += (node_length + 3) & ~3;
 450
 451         new_node->on_name = new_node->on_storage;
 452         memcpy(new_node->on_name, orig->on_name, strlen(orig->on_name) + 1);
 453         NEWLIST(&new_node->on_children);
 454         NEWLIST(&new_node->on_properties);
 455
 456         ForeachNode(&orig->on_properties, prop)
 457         {
 458                 uint32_t prop_name_length = strlen(prop->op_name) + 1;
 459                 uint32_t prop_length = sizeof(struct OFWProperty) + prop_name_length + prop->op_length;
 460
 461                 new_prop = (struct OFWProperty *)memlo;
 462                 memlo += (prop_length + 3) & ~3;
 463
 464                 new_prop->op_name = new_prop->op_storage;
 465                 new_prop->op_value = &new_prop->op_storage[prop_name_length];
 466                 new_prop->op_length = prop->op_length;
 467
 468                 memcpy(new_prop->op_name, prop->op_name, strlen(prop->op_name)+1);
 469                 memcpy(new_prop->op_value, prop->op_value, prop->op_length);
 470
 471                 ADDTAIL(&new_node->on_properties, new_prop);
 472         }
 473
 474         ForeachNode(&orig->on_children, child)
 475                 ADDTAIL(&new_node->on_children, krnCopyOFWTree(child));
 476
 477         return new_node;
 478 }
 479
 480 uint64_t tbu1;
 481 uint64_t tbu2;
 482 uint64_t last_calc;
 483 uint64_t idle_time;
 484 uint32_t cpu_usage;
 485 struct Task *idle_task;
 486
 487 /* As soon as IdleTask gets CPU again, it records the current cycle count */
 488 AROS_UFH1(void, idleCount,
 489     AROS_UFHA(struct ExecBase *, SysBase, A6))
 490 {
 491     AROS_USERFUNC_INIT
 492
 493     tbu1 = mftbu();
 494     SysBase->IdleCount++;
 495
 496     AROS_USERFUNC_EXIT
 497 }
 498
 499 /*
 500  * When CPU time gets lost, the cycle count spent in idle task is summed
 501  * with the total idle time
 502  */
 503 AROS_UFH1(void, idleOff,
 504     AROS_UFHA(struct ExecBase *, SysBase, A6))
 505 {
 506     AROS_USERFUNC_INIT
 507
 508     tbu2 = mftbu();
 509     idle_time += tbu2 - tbu1;
 510
 511     AROS_USERFUNC_EXIT
 512 }
 513
 514 /*
 515  * Idle task on Efika does not do much. It enters supervisor mode, enables
 516  * interrupts (so that it survived even in Disable()'d state) and then enters
 517  * power save mode. Once woken up, a Reschedule is forced.
 518  */
 519 void idleTask(struct ExecBase *SysBase, struct KernelBase *KernelBase)
 520 {
 521         D(bug("[KRN] IdleTask entered\n"));
 522
 523         while(1)
 524         {
 525             if (0)
 526             {
 527                 /* Superstate() done quickly */
 528                 int i;
 529                 uint32_t msr = goSuper();
 530                 uint32_t msr_sup = rdmsr() | MSR_EE | MSR_POW;
 531                 /* Enable external/decrementer interrupts */
 532                 asm volatile("sync");
 533                 /* Sleep! */
 534                 wrmsr(msr_sup);
 535                 /* Changing the POW bit needs a context synchronization now. */
 536                 asm volatile("isync");
 537
 538                 /* CPU needs few cycles to enter sleep state */
 539                 for (i=0; i < 10; i++)
 540                     asm volatile("nop");
 541
 542                 /* Userstate() */
 543                 wrmsr(msr);
 544                 /* And reschedule! */
 545                 KrnSchedule();
 546             }
 547         }
 548 }
 549
 550 extern void *priv_KernelBase;
 551 struct MemHeader KernelMemory;
 552
 553 void *(*__AllocMem)();
 554
 555 #define ExecAllocMem(bytesize, requirements)        \
 556 AROS_CALL2(void *, __AllocMem,                      \
 557                 AROS_LCA(ULONG, byteSize,     D0),                      \
 558                 AROS_LCA(ULONG, requirements, D1),                      \
 559                 struct ExecBase *, SysBase)
 560
 561 AROS_LH2(APTR, AllocMem,
 562         AROS_LHA(ULONG, byteSize,     D0),
 563         AROS_LHA(ULONG, requirements, D1),
 564         struct ExecBase *, SysBase, 33, Kernel)
 565 {
 566         AROS_LIBFUNC_INIT
 567
 568         return ExecAllocMem(bytesize, requirements & ~MEMF_CHIP);
 569
 570         AROS_LIBFUNC_EXIT
 571 }
 572
 573
 574 static int Kernel_Init(LIBBASETYPEPTR LIBBASE)
 575 {
 576     int i;
 577     struct ExecBase *SysBase = getSysBase();
 578     int realchip = 0;
 579
 580         uintptr_t krn_lowest = (krnGetTagData(KRN_KernelLowest, 0, BootMsg) & ~4095) ^ 0xf8000000;
 581         uintptr_t krn_highest = ((krnGetTagData(KRN_KernelHighest, 0, BootMsg) + 4095) & ~4095) ^ 0xf8000000;
 582         char *cmd = krnGetTagData(KRN_CmdLine, 0, BootMsg);
 583
 584     KernelMemory.mh_Node.ln_Name = "Kernel";
 585     KernelMemory.mh_Node.ln_Type = NT_MEMORY;
 586     KernelMemory.mh_Node.ln_Pri = -128;
 587     KernelMemory.mh_Attributes = MEMF_KICK;
 588     KernelMemory.mh_First = NULL;
 589     KernelMemory.mh_Free = 0;
 590     KernelMemory.mh_Lower = krn_lowest;
 591     KernelMemory.mh_Upper = krn_highest;
 592
 593     Forbid();
 594         Enqueue(&SysBase->MemList, &KernelMemory.mh_Node);
 595     Permit();
 596
 597     NEWLIST(&LIBBASE->kb_Modules);
 598     NEWLIST(&LIBBASE->kb_DeadTasks);
 599
 600     /* Check whether the user passed realchip parameter. */
 601     if (cmd)
 602     {
 603         while(cmd[0])
 604         {
 605                 uint32_t temp = strcspn(cmd, " ");
 606
 607                 if (strncmp(cmd, "realchip", 8) == 0)
 608                 {
 609                         realchip=1;
 610                 }
 611
 612                 cmd = stpblk(cmd+temp);
 613         }
 614     }
 615
 616     /*
 617      * If no realchip parameter was given, the AllocMem function will be patched with a stub
 618      * which *always* clears the MEMF_CHIP flag.
 619      */
 620     if (!realchip)
 621     {
 622         __AllocMem = SetFunction(SysBase, -33*LIB_VECTSIZE, AROS_SLIB_ENTRY(AllocMem, Kernel));
 623     }
 624
 625     /*
 626      * Set the KernelBase into SPRG4. At this stage the SPRG5 should be already set by
 627      * exec.library itself.
 628      */
 629     wrspr(SPRG4, LIBBASE);
 630
 631     LIBBASE->kb_FPUOwner = NULL;
 632
 633     D(bug("[KRN] Kernel resource post-exec init.\n"));
 634
 635     for (i=0; i < 21; i++)
 636         NEWLIST(&LIBBASE->kb_Exceptions[i]);
 637
 638     for (i=0; i < 64; i++)
 639         NEWLIST(&LIBBASE->kb_Interrupts[i]);
 640
 641     /* Prepare private memory block */
 642     LIBBASE->kb_SupervisorMem = (struct MemHeader *)memlo;
 643
 644         /*
 645      * kernel.resource is ready to run. Enable external interrupts and leave
 646      * supervisor mode
 647      */
 648     wrmsr(rdmsr() | (MSR_EE|MSR_FP));
 649     D(bug("[KRN] Interrupts enabled\n"));
 650
 651     asm volatile("mtdec %0"::"r"(33000000/1000));
 652
 653     wrmsr(rdmsr() | (MSR_PR));
 654     D(bug("[KRN] Entered user mode\n"));
 655
 656     priv_KernelBase = LIBBASE;
 657
 658     {
 659         /* Add idle task now. */
 660         struct Task *t;
 661         struct MemList *ml;
 662         uint8_t *s;
 663         struct TagItem tags[] = {
 664                         { TASKTAG_ARG1,   (IPTR)SysBase },
 665                         { TASKTAG_ARG2,   (IPTR)LIBBASE },
 666                         { TAG_DONE,       0UL }};
 667
 668         /* Allocate MemEntry for this task and stack */
 669         ml = (struct MemList *)AllocMem(sizeof(struct MemList)+sizeof(struct MemEntry),
 670                         MEMF_PUBLIC|MEMF_CLEAR);
 671         t = (struct Task *)    AllocMem(sizeof(struct Task), MEMF_CLEAR|MEMF_PUBLIC);
 672         s = (uint8_t *)          AllocMem(4096,      MEMF_CLEAR|MEMF_PUBLIC);
 673
 674         if( !ml || !t || !s )
 675         {
 676                 bug("ERROR: Cannot create Idle Task!\n");
 677                 Alert( AT_DeadEnd | AG_NoMemory | AN_ExecLib );
 678         }
 679
 680         ml->ml_NumEntries = 2;
 681         ml->ml_ME[0].me_Addr = t;
 682         ml->ml_ME[0].me_Length = sizeof(struct Task);
 683         ml->ml_ME[1].me_Addr = s;
 684         ml->ml_ME[1].me_Length = 4096;
 685
 686         NEWLIST(&t->tc_MemEntry);
 687         AddHead(&t->tc_MemEntry, &ml->ml_Node);
 688         t->tc_SPLower = s;
 689         t->tc_SPUpper = s + 4096 - SP_OFFSET;
 690 #if AROS_STACK_GROWS_DOWNWARDS
 691         t->tc_SPReg = (char *)t->tc_SPUpper - SP_OFFSET;
 692 #else
 693         t->tc_SPReg = (char *)t->tc_SPLower + SP_OFFSET;
 694 #endif
 695
 696         t->tc_Node.ln_Name = "Idle Task";
 697         t->tc_Node.ln_Pri = -128;
 698         t->tc_Launch = &idleCount;
 699         t->tc_Switch = &idleOff;
 700         t->tc_Flags = TF_LAUNCH | TF_SWITCH;
 701         NewAddTask(t, &idleTask, NULL, &tags);
 702         idle_task = t;
 703     }
 704
 705     return TRUE;
 706 }
 707
 708 ADD2INITLIB(Kernel_Init, 0)