1/* 2 * Copyright 2008-2010, Fran��ois Revol, revol@free.fr. All rights reserved. 3 * Copyright 2004-2007, Axel D��rfler, axeld@pinc-software.de. 4 * Based on code written by Travis Geiselbrecht for NewOS. 5 * 6 * Distributed under the terms of the MIT License. 7 */ 8 9 10#include "atari_memory_map.h" 11#include "toscalls.h" 12#include "mmu.h" 13 14#include <boot/platform.h> 15#include <boot/stdio.h> 16#include <boot/kernel_args.h> 17#include <boot/stage2.h> 18#include <arch/cpu.h> 19#include <arch_kernel.h> 20#include <kernel.h> 21 22#include <OS.h> 23 24#include <string.h> 25 26 27//XXX: x86 28/** The (physical) memory layout of the boot loader is currently as follows: 29 * 0x0500 - 0x10000 protected mode stack 30 * 0x0500 - 0x09000 real mode stack 31 * 0x10000 - ? code (up to ~500 kB) 32 * 0x90000 1st temporary page table (identity maps 0-4 MB) 33 * 0x91000 2nd (4-8 MB) 34 * 0x92000 - 0x92000 further page tables 35 * 0x9e000 - 0xa0000 SMP trampoline code 36 * [0xa0000 - 0x100000 BIOS/ROM/reserved area] 37 * 0x100000 page directory 38 * ... boot loader heap (32 kB) 39 * ... free physical memory 40 * 41 * The first 8 MB are identity mapped (0x0 - 0x0800000); paging is turned 42 * on. The kernel is mapped at 0x80000000, all other stuff mapped by the 43 * loader (kernel args, modules, driver settings, ...) comes after 44 * 0x81000000 which means that there is currently only 1 MB reserved for 45 * the kernel itself (see kMaxKernelSize). 46 */ 47 48// notes m68k: 49/** The (physical) memory layout of the boot loader is currently as follows: 50 * 0x0800 - 0x10000 supervisor mode stack (1) XXX: more ? x86 starts at 500 51 * 0x10000 - ? code (up to ~500 kB) 52 * 0x100000 or FAST_RAM_BASE if any: 53 * ... page root directory 54 * ... interrupt vectors (VBR) 55 * ... page directory 56 * ... boot loader heap (32 kB) 57 * ... free physical memory 58 * 0xdNNNNN video buffer usually there, as per v_bas_ad 59 * (=Logbase() but Physbase() is better) 60 * 61 * The first 32 MB (2) are identity mapped (0x0 - 0x1000000); paging 62 * is turned on. The kernel is mapped at 0x80000000, all other stuff 63 * mapped by the loader (kernel args, modules, driver settings, ...) 64 * comes after 0x81000000 which means that there is currently only 65 * 1 MB reserved for the kernel itself (see kMaxKernelSize). 66 * 67 * (1) no need for user stack, we are already in supervisor mode in the 68 * loader. 69 * (2) maps the whole regular ST space; transparent translation registers 70 * have larger granularity anyway. 71 */ 72#warning M68K: check for Physbase() < ST_RAM_TOP 73 74//#define TRACE_MMU 75#ifdef TRACE_MMU 76# define TRACE(x) dprintf x 77#else 78# define TRACE(x) ; 79#endif 80 81 82// since the page root directory doesn't take a full page (1k) 83// we stuff some other stuff after it, like the interrupt vectors (1k) 84#define VBR_PAGE_OFFSET 1024 85 86static const uint32 kDefaultPageTableFlags = 0x07; // present, user, R/W 87static const size_t kMaxKernelSize = 0x200000; // 2 MB for the kernel 88 89// working page directory and page table 90addr_t gPageRoot = 0; 91 92static addr_t sNextPhysicalAddress = 0x100000; 93static addr_t sNextVirtualAddress = KERNEL_BASE + kMaxKernelSize; 94static addr_t sMaxVirtualAddress = KERNEL_BASE /*+ 0x400000*/; 95 96#if 0 97static addr_t sNextPageTableAddress = 0x90000; 98static const uint32 kPageTableRegionEnd = 0x9e000; 99 // we need to reserve 2 pages for the SMP trampoline code XXX:no 100#endif 101 102static const struct boot_mmu_ops *gMMUOps; 103 104static addr_t 105get_next_virtual_address(size_t size) 106{ 107 addr_t address = sNextVirtualAddress; 108 sNextVirtualAddress += size; 109 110 TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address)); 111 return address; 112} 113 114 115static addr_t 116get_next_physical_address(size_t size) 117{ 118 addr_t address = sNextPhysicalAddress; 119 sNextPhysicalAddress += size; 120 121 TRACE(("%s(%d): %08x\n", __FUNCTION__, size, address)); 122 return address; 123} 124 125 126static addr_t 127get_next_virtual_page() 128{ 129 TRACE(("%s\n", __FUNCTION__)); 130 return get_next_virtual_address(B_PAGE_SIZE); 131} 132 133 134static addr_t 135get_next_physical_page() 136{ 137 TRACE(("%s\n", __FUNCTION__)); 138 return get_next_physical_address(B_PAGE_SIZE); 139} 140 141 142// allocate a page worth of page dir or tables 143extern "C" addr_t 144mmu_get_next_page_tables() 145{ 146#if 0 147 TRACE(("mmu_get_next_page_tables, sNextPageTableAddress %p, kPageTableRegionEnd %p\n", 148 sNextPageTableAddress, kPageTableRegionEnd)); 149 150 addr_t address = sNextPageTableAddress; 151 if (address >= kPageTableRegionEnd) 152 return (uint32 *)get_next_physical_page(); 153 154 sNextPageTableAddress += B_PAGE_SIZE; 155 return (uint32 *)address; 156#endif 157 addr_t tbl = get_next_physical_page(); 158 if (!tbl) 159 return tbl; 160 // shouldn't we fill this ? 161 //gKernelArgs.arch_args.pgtables[gKernelArgs.arch_args.num_pgtables++] = (uint32)pageTable; 162 163#if 0 164 // clear them 165 uint32 *p = (uint32 *)tbl; 166 for (int32 i = 0; i < 1024; i++) 167 p[i] = 0; 168#endif 169 return tbl; 170} 171 172#if 0 173/** Adds a new page table for the specified base address */ 174 175static void 176add_page_table(addr_t base) 177{ 178 TRACE(("add_page_table(base = %p)\n", (void *)base)); 179#if 0 180 181 // Get new page table and clear it out 182 uint32 *pageTable = mmu_get_next_page_tables(); 183 if (pageTable > (uint32 *)(8 * 1024 * 1024)) 184 panic("tried to add page table beyond the indentity mapped 8 MB region\n"); 185 186 gKernelArgs.arch_args.pgtables[gKernelArgs.arch_args.num_pgtables++] = (uint32)pageTable; 187 188 for (int32 i = 0; i < 1024; i++) 189 pageTable[i] = 0; 190 191 // put the new page table into the page directory 192 gPageRoot[base/(4*1024*1024)] = (uint32)pageTable | kDefaultPageTableFlags; 193#endif 194} 195#endif 196 197 198static void 199unmap_page(addr_t virtualAddress) 200{ 201 gMMUOps->unmap_page(virtualAddress); 202} 203 204 205/** Creates an entry to map the specified virtualAddress to the given 206 * physicalAddress. 207 * If the mapping goes beyond the current page table, it will allocate 208 * a new one. If it cannot map the requested page, it panics. 209 */ 210 211static void 212map_page(addr_t virtualAddress, addr_t physicalAddress, uint32 flags) 213{ 214 TRACE(("map_page: vaddr 0x%lx, paddr 0x%lx\n", virtualAddress, physicalAddress)); 215 216 if (virtualAddress < KERNEL_BASE) 217 panic("map_page: asked to map invalid page %p!\n", (void *)virtualAddress); 218 219 // slow but I'm too lazy to fix the code below 220 gMMUOps->add_page_table(virtualAddress); 221#if 0 222 if (virtualAddress >= sMaxVirtualAddress) { 223 // we need to add a new page table 224 225 gMMUOps->add_page_table(sMaxVirtualAddress); 226 // 64 pages / page table 227 sMaxVirtualAddress += B_PAGE_SIZE * 64; 228 229 if (virtualAddress >= sMaxVirtualAddress) 230 panic("map_page: asked to map a page to %p\n", (void *)virtualAddress); 231 } 232#endif 233 234 physicalAddress &= ~(B_PAGE_SIZE - 1); 235 236 // map the page to the correct page table 237 gMMUOps->map_page(virtualAddress, physicalAddress, flags); 238} 239 240 241static void 242init_page_directory(void) 243{ 244 TRACE(("init_page_directory\n")); 245 246 // allocate a new pg root dir 247 gPageRoot = get_next_physical_page(); 248 gKernelArgs.arch_args.phys_pgroot = (uint32)gPageRoot; 249 gKernelArgs.arch_args.phys_vbr = (uint32)gPageRoot + VBR_PAGE_OFFSET; 250 251 // set the root pointers 252 gMMUOps->load_rp(gPageRoot); 253 // allocate second level tables for kernel space 254 // this will simplify mmu code a lot, and only wastes 32KB 255 gMMUOps->allocate_kernel_pgdirs(); 256 // enable mmu translation 257 gMMUOps->enable_paging(); 258 //XXX: check for errors 259 260 //gKernelArgs.arch_args.num_pgtables = 0; 261 gMMUOps->add_page_table(KERNEL_BASE); 262 263#if 0 264 265 266 // clear out the pgdir 267 for (int32 i = 0; i < 1024; i++) { 268 gPageRoot[i] = 0; 269 } 270 271 // Identity map the first 8 MB of memory so that their 272 // physical and virtual address are the same. 273 // These page tables won't be taken over into the kernel. 274 275 // make the first page table at the first free spot 276 uint32 *pageTable = mmu_get_next_page_tables(); 277 278 for (int32 i = 0; i < 1024; i++) { 279 pageTable[i] = (i * 0x1000) | kDefaultPageFlags; 280 } 281 282 gPageRoot[0] = (uint32)pageTable | kDefaultPageFlags; 283 284 // make the second page table 285 pageTable = mmu_get_next_page_tables(); 286 287 for (int32 i = 0; i < 1024; i++) { 288 pageTable[i] = (i * 0x1000 + 0x400000) | kDefaultPageFlags; 289 } 290 291 gPageRoot[1] = (uint32)pageTable | kDefaultPageFlags; 292 293 gKernelArgs.arch_args.num_pgtables = 0; 294 add_page_table(KERNEL_BASE); 295 296 // switch to the new pgdir and enable paging 297 asm("movl %0, %%eax;" 298 "movl %%eax, %%cr3;" : : "m" (gPageRoot) : "eax"); 299 // Important. Make sure supervisor threads can fault on read only pages... 300 asm("movl %%eax, %%cr0" : : "a" ((1 << 31) | (1 << 16) | (1 << 5) | 1)); 301#endif 302} 303 304 305// #pragma mark - 306 307 308extern "C" addr_t 309mmu_map_physical_memory(addr_t physicalAddress, size_t size, uint32 flags) 310{ 311 addr_t address = sNextVirtualAddress; 312 addr_t pageOffset = physicalAddress & (B_PAGE_SIZE - 1); 313 314 physicalAddress -= pageOffset; 315 316 for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) { 317 map_page(get_next_virtual_page(), physicalAddress + offset, flags); 318 } 319 320 return address + pageOffset; 321} 322 323 324extern "C" void * 325mmu_allocate(void *virtualAddress, size_t size) 326{ 327 TRACE(("mmu_allocate: requested vaddr: %p, next free vaddr: 0x%lx, size: %ld\n", 328 virtualAddress, sNextVirtualAddress, size)); 329 330 size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE; 331 // get number of pages to map 332 333 if (virtualAddress != NULL) { 334 // This special path is almost only useful for loading the 335 // kernel into memory; it will only allow you to map the 336 // 1 MB following the kernel base address. 337 // Also, it won't check for already mapped addresses, so 338 // you better know why you are here :) 339 addr_t address = (addr_t)virtualAddress; 340 341 // is the address within the valid range? 342 if (address < KERNEL_BASE || address + size >= KERNEL_BASE + kMaxKernelSize) 343 return NULL; 344 345 for (uint32 i = 0; i < size; i++) { 346 map_page(address, get_next_physical_page(), kDefaultPageFlags); 347 address += B_PAGE_SIZE; 348 } 349 350 TRACE(("mmu_allocate(KERNEL, %d): done\n", size)); 351 return virtualAddress; 352 } 353 354 void *address = (void *)sNextVirtualAddress; 355 356 for (uint32 i = 0; i < size; i++) { 357 map_page(get_next_virtual_page(), get_next_physical_page(), kDefaultPageFlags); 358 } 359 360 TRACE(("mmu_allocate(NULL, %d): %p\n", size, address)); 361 return address; 362} 363 364 365/** This will unmap the allocated chunk of memory from the virtual 366 * address space. It might not actually free memory (as its implementation 367 * is very simple), but it might. 368 */ 369 370extern "C" void 371mmu_free(void *virtualAddress, size_t size) 372{ 373 TRACE(("mmu_free(virtualAddress = %p, size: %ld)\n", virtualAddress, size)); 374 375 addr_t address = (addr_t)virtualAddress; 376 size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE; 377 // get number of pages to map 378 379 // is the address within the valid range? 380 if (address < KERNEL_BASE) { 381 panic("mmu_free: asked to unmap out of range region (%p, size %lx)\n", 382 (void *)address, size); 383 } 384 385 // unmap all pages within the range 386 for (uint32 i = 0; i < size; i++) { 387 unmap_page(address); 388 address += B_PAGE_SIZE; 389 } 390 391 if (address == sNextVirtualAddress) { 392 // we can actually reuse the virtual address space 393 sNextVirtualAddress -= size; 394 } 395} 396 397 398/** Sets up the final and kernel accessible GDT and IDT tables. 399 * BIOS calls won't work any longer after this function has 400 * been called. 401 */ 402 403extern "C" void 404mmu_init_for_kernel(void) 405{ 406 TRACE(("mmu_init_for_kernel\n")); 407 408 409 410 411 // remove identity mapping of ST space 412 // actually done by the kernel when it's done using query_early 413 //gMMUOps->set_tt(0, NULL, 0, 0); 414 415#if 0 416 // set up a new idt 417 { 418 struct gdt_idt_descr idtDescriptor; 419 uint32 *idt; 420 421 // find a new idt 422 idt = (uint32 *)get_next_physical_page(); 423 gKernelArgs.arch_args.phys_idt = (uint32)idt; 424 425 TRACE(("idt at %p\n", idt)); 426 427 // map the idt into virtual space 428 gKernelArgs.arch_args.vir_idt = (uint32)get_next_virtual_page(); 429 map_page(gKernelArgs.arch_args.vir_idt, (uint32)idt, kDefaultPageFlags); 430 431 // clear it out 432 uint32* virtualIDT = (uint32*)gKernelArgs.arch_args.vir_idt; 433 for (int32 i = 0; i < IDT_LIMIT / 4; i++) { 434 virtualIDT[i] = 0; 435 } 436 437 // load the idt 438 idtDescriptor.limit = IDT_LIMIT - 1; 439 idtDescriptor.base = (uint32 *)gKernelArgs.arch_args.vir_idt; 440 441 asm("lidt %0;" 442 : : "m" (idtDescriptor)); 443 444 TRACE(("idt at virtual address 0x%lx\n", gKernelArgs.arch_args.vir_idt)); 445 } 446 447 // set up a new gdt 448 { 449 struct gdt_idt_descr gdtDescriptor; 450 segment_descriptor *gdt; 451 452 // find a new gdt 453 gdt = (segment_descriptor *)get_next_physical_page(); 454 gKernelArgs.arch_args.phys_gdt = (uint32)gdt; 455 456 TRACE(("gdt at %p\n", gdt)); 457 458 // map the gdt into virtual space 459 gKernelArgs.arch_args.vir_gdt = (uint32)get_next_virtual_page(); 460 map_page(gKernelArgs.arch_args.vir_gdt, (uint32)gdt, kDefaultPageFlags); 461 462 // put standard segment descriptors in it 463 segment_descriptor* virtualGDT 464 = (segment_descriptor*)gKernelArgs.arch_args.vir_gdt; 465 clear_segment_descriptor(&virtualGDT[0]); 466 467 // seg 0x08 - kernel 4GB code 468 set_segment_descriptor(&virtualGDT[1], 0, 0xffffffff, DT_CODE_READABLE, 469 DPL_KERNEL); 470 471 // seg 0x10 - kernel 4GB data 472 set_segment_descriptor(&virtualGDT[2], 0, 0xffffffff, DT_DATA_WRITEABLE, 473 DPL_KERNEL); 474 475 // seg 0x1b - ring 3 user 4GB code 476 set_segment_descriptor(&virtualGDT[3], 0, 0xffffffff, DT_CODE_READABLE, 477 DPL_USER); 478 479 // seg 0x23 - ring 3 user 4GB data 480 set_segment_descriptor(&virtualGDT[4], 0, 0xffffffff, DT_DATA_WRITEABLE, 481 DPL_USER); 482 483 // virtualGDT[5] and above will be filled later by the kernel 484 // to contain the TSS descriptors, and for TLS (one for every CPU) 485 486 // load the GDT 487 gdtDescriptor.limit = GDT_LIMIT - 1; 488 gdtDescriptor.base = (uint32 *)gKernelArgs.arch_args.vir_gdt; 489 490 asm("lgdt %0;" 491 : : "m" (gdtDescriptor)); 492 493 TRACE(("gdt at virtual address %p\n", (void *)gKernelArgs.arch_args.vir_gdt)); 494 } 495#endif 496 497 // save the memory we've physically allocated 498 gKernelArgs.physical_allocated_range[0].size = sNextPhysicalAddress - gKernelArgs.physical_allocated_range[0].start; 499 500 // save the memory we've virtually allocated (for the kernel and other stuff) 501 gKernelArgs.virtual_allocated_range[0].start = KERNEL_BASE; 502 gKernelArgs.virtual_allocated_range[0].size = sNextVirtualAddress - KERNEL_BASE; 503 gKernelArgs.num_virtual_allocated_ranges = 1; 504 505 // sort the address ranges 506 sort_address_ranges(gKernelArgs.physical_memory_range, 507 gKernelArgs.num_physical_memory_ranges); 508 sort_address_ranges(gKernelArgs.physical_allocated_range, 509 gKernelArgs.num_physical_allocated_ranges); 510 sort_address_ranges(gKernelArgs.virtual_allocated_range, 511 gKernelArgs.num_virtual_allocated_ranges); 512 513#ifdef TRACE_MMU 514 { 515 uint32 i; 516 517 dprintf("phys memory ranges:\n"); 518 for (i = 0; i < gKernelArgs.num_physical_memory_ranges; i++) { 519 dprintf(" base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n", 520 gKernelArgs.physical_memory_range[i].start, 521 gKernelArgs.physical_memory_range[i].size); 522 } 523 524 dprintf("allocated phys memory ranges:\n"); 525 for (i = 0; i < gKernelArgs.num_physical_allocated_ranges; i++) { 526 dprintf(" base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n", 527 gKernelArgs.physical_allocated_range[i].start, 528 gKernelArgs.physical_allocated_range[i].size); 529 } 530 531 dprintf("allocated virt memory ranges:\n"); 532 for (i = 0; i < gKernelArgs.num_virtual_allocated_ranges; i++) { 533 dprintf(" base 0x%08" B_PRIx64 ", length 0x%08" B_PRIx64 "\n", 534 gKernelArgs.virtual_allocated_range[i].start, 535 gKernelArgs.virtual_allocated_range[i].size); 536 } 537 } 538#endif 539} 540 541 542extern "C" void 543mmu_init(void) 544{ 545 TRACE(("mmu_init\n")); 546 switch (gKernelArgs.arch_args.mmu_type) { 547#if 0 548 case 68851: 549 gMMUOps = &k851MMUOps; 550 break; 551#endif 552 case 68030: 553 gMMUOps = &k030MMUOps; 554 break; 555 case 68040: 556 gMMUOps = &k040MMUOps; 557 break; 558#if 0 559 case 68060: 560 gMMUOps = &k060MMUOps; 561 break; 562#endif 563 default: 564 panic("unknown mmu type %d\n", gKernelArgs.arch_args.mmu_type); 565 } 566 567 gMMUOps->initialize(); 568 569 addr_t fastram_top = 0; 570 if (*TOSVARramvalid == TOSVARramvalid_MAGIC) 571 fastram_top = *TOSVARramtop; 572 if (fastram_top) { 573 // we have some fastram, use it first 574 sNextPhysicalAddress = ATARI_FASTRAM_BASE; 575 } 576 577 gKernelArgs.physical_allocated_range[0].start = sNextPhysicalAddress; 578 gKernelArgs.physical_allocated_range[0].size = 0; 579 gKernelArgs.num_physical_allocated_ranges = 1; 580 // remember the start of the allocated physical pages 581 582 TRACE(("mmu_init: enabling transparent translation\n")); 583 // enable transparent translation of the first 256 MB 584 gMMUOps->set_tt(0, ATARI_CHIPRAM_BASE, 0x10000000, 0); 585 // enable transparent translation of the 16MB ST shadow range for I/O 586 gMMUOps->set_tt(1, ATARI_SHADOW_BASE, 0x01000000, 0); 587 588 TRACE(("mmu_init: init rtdir\n")); 589 init_page_directory(); 590#if 0//XXX:HOLE 591 592 // Map the page directory into kernel space at 0xffc00000-0xffffffff 593 // this enables a mmu trick where the 4 MB region that this pgdir entry 594 // represents now maps the 4MB of potential pagetables that the pgdir 595 // points to. Thrown away later in VM bringup, but useful for now. 596 gPageRoot[1023] = (uint32)gPageRoot | kDefaultPageFlags; 597#endif 598 599 // also map it on the next vpage 600 gKernelArgs.arch_args.vir_pgroot = get_next_virtual_page(); 601 map_page(gKernelArgs.arch_args.vir_pgroot, (uint32)gPageRoot, kDefaultPageFlags); 602 603 // set virtual addr for interrupt vector table 604 gKernelArgs.arch_args.vir_vbr = gKernelArgs.arch_args.vir_pgroot 605 + VBR_PAGE_OFFSET; 606 607 // map in a kernel stack 608 gKernelArgs.cpu_kstack[0].start = (addr_t)mmu_allocate(NULL, 609 KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE); 610 gKernelArgs.cpu_kstack[0].size = KERNEL_STACK_SIZE 611 + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE; 612 613 TRACE(("kernel stack at 0x%lx to 0x%lx\n", gKernelArgs.cpu_kstack[0].start, 614 gKernelArgs.cpu_kstack[0].start + gKernelArgs.cpu_kstack[0].size)); 615 616 // st ram as 1st range 617 gKernelArgs.physical_memory_range[0].start = ATARI_CHIPRAM_BASE; 618 gKernelArgs.physical_memory_range[0].size = *TOSVARphystop - ATARI_CHIPRAM_BASE; 619 gKernelArgs.num_physical_memory_ranges = 1; 620 621 // fast ram as 2nd range 622 if (fastram_top) { 623 gKernelArgs.physical_memory_range[1].start = 624 ATARI_FASTRAM_BASE; 625 gKernelArgs.physical_memory_range[1].size = 626 fastram_top - ATARI_FASTRAM_BASE; 627 gKernelArgs.num_physical_memory_ranges++; 628 629 } 630 631 // mark the video area allocated 632 addr_t video_base = *TOSVAR_memtop; 633 video_base &= ~(B_PAGE_SIZE-1); 634 gKernelArgs.physical_allocated_range[gKernelArgs.num_physical_allocated_ranges].start = video_base; 635 gKernelArgs.physical_allocated_range[gKernelArgs.num_physical_allocated_ranges].size = *TOSVARphystop - video_base; 636 gKernelArgs.num_physical_allocated_ranges++; 637 638 639 gKernelArgs.arch_args.plat_args.atari.nat_feat.nf_page = 640 get_next_physical_page() /*| 0xff000000*/; 641 642} 643 644 645// #pragma mark - 646 647 648extern "C" status_t 649platform_allocate_region(void **_address, size_t size, uint8 protection, 650 bool /*exactAddress*/) 651{ 652 void *address = mmu_allocate(*_address, size); 653 if (address == NULL) 654 return B_NO_MEMORY; 655 656 *_address = address; 657 return B_OK; 658} 659 660 661extern "C" status_t 662platform_free_region(void *address, size_t size) 663{ 664 mmu_free(address, size); 665 return B_OK; 666} 667 668 669void 670platform_release_heap(struct stage2_args *args, void *base) 671{ 672 // It will be freed automatically, since it is in the 673 // identity mapped region, and not stored in the kernel's 674 // page tables. 675} 676 677 678status_t 679platform_init_heap(struct stage2_args *args, void **_base, void **_top) 680{ 681 void *heap = (void *)get_next_physical_address(args->heap_size); 682 if (heap == NULL) 683 return B_NO_MEMORY; 684 685 *_base = heap; 686 *_top = (void *)((int8 *)heap + args->heap_size); 687 return B_OK; 688} 689 690 691