1/* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 1995 Linus Torvalds 7 * Copyright (C) 1995 Waldorf Electronics 8 * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 03 Ralf Baechle 9 * Copyright (C) 1996 Stoned Elipot 10 * Copyright (C) 1999 Silicon Graphics, Inc. 11 * Copyright (C) 2000, 2001, 2002, 2007 Maciej W. Rozycki 12 */ 13#include <linux/init.h> 14#include <linux/ioport.h> 15#include <linux/module.h> 16#include <linux/screen_info.h> 17#include <linux/bootmem.h> 18#include <linux/initrd.h> 19#include <linux/root_dev.h> 20#include <linux/highmem.h> 21#include <linux/console.h> 22#include <linux/pfn.h> 23#include <linux/debugfs.h> 24 25#include <asm/addrspace.h> 26#include <asm/bootinfo.h> 27#include <asm/bugs.h> 28#include <asm/cache.h> 29#include <asm/cpu.h> 30#include <asm/sections.h> 31#include <asm/setup.h> 32#include <asm/smp-ops.h> 33#include <asm/system.h> 34 35struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly; 36 37EXPORT_SYMBOL(cpu_data); 38 39#ifdef CONFIG_VT 40struct screen_info screen_info; 41#endif 42 43/* 44 * Despite it's name this variable is even if we don't have PCI 45 */ 46unsigned int PCI_DMA_BUS_IS_PHYS; 47 48EXPORT_SYMBOL(PCI_DMA_BUS_IS_PHYS); 49 50/* 51 * Setup information 52 * 53 * These are initialized so they are in the .data section 54 */ 55unsigned long mips_machtype __read_mostly = MACH_UNKNOWN; 56 57EXPORT_SYMBOL(mips_machtype); 58 59struct boot_mem_map boot_mem_map; 60 61static char __initdata command_line[COMMAND_LINE_SIZE]; 62char __initdata arcs_cmdline[COMMAND_LINE_SIZE]; 63 64#ifdef CONFIG_CMDLINE_BOOL 65static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE; 66#endif 67 68/* 69 * mips_io_port_base is the begin of the address space to which x86 style 70 * I/O ports are mapped. 71 */ 72const unsigned long mips_io_port_base __read_mostly = -1; 73EXPORT_SYMBOL(mips_io_port_base); 74 75static struct resource code_resource = { .name = "Kernel code", }; 76static struct resource data_resource = { .name = "Kernel data", }; 77 78void __init add_memory_region(phys_t start, phys_t size, long type) 79{ 80 int x = boot_mem_map.nr_map; 81 struct boot_mem_map_entry *prev = boot_mem_map.map + x - 1; 82 83 /* Sanity check */ 84 if (start + size < start) { 85 pr_warning("Trying to add an invalid memory region, skipped\n"); 86 return; 87 } 88 89 /* 90 * Try to merge with previous entry if any. This is far less than 91 * perfect but is sufficient for most real world cases. 92 */ 93 if (x && prev->addr + prev->size == start && prev->type == type) { 94 prev->size += size; 95 return; 96 } 97 98 if (x == BOOT_MEM_MAP_MAX) { 99 pr_err("Ooops! Too many entries in the memory map!\n"); 100 return; 101 } 102 103 boot_mem_map.map[x].addr = start; 104 boot_mem_map.map[x].size = size; 105 boot_mem_map.map[x].type = type; 106 boot_mem_map.nr_map++; 107} 108 109static void __init print_memory_map(void) 110{ 111 int i; 112 const int field = 2 * sizeof(unsigned long); 113 114 for (i = 0; i < boot_mem_map.nr_map; i++) { 115 printk(KERN_INFO " memory: %0*Lx @ %0*Lx ", 116 field, (unsigned long long) boot_mem_map.map[i].size, 117 field, (unsigned long long) boot_mem_map.map[i].addr); 118 119 switch (boot_mem_map.map[i].type) { 120 case BOOT_MEM_RAM: 121 printk(KERN_CONT "(usable)\n"); 122 break; 123 case BOOT_MEM_ROM_DATA: 124 printk(KERN_CONT "(ROM data)\n"); 125 break; 126 case BOOT_MEM_RESERVED: 127 printk(KERN_CONT "(reserved)\n"); 128 break; 129 default: 130 printk(KERN_CONT "type %lu\n", boot_mem_map.map[i].type); 131 break; 132 } 133 } 134} 135 136/* 137 * Manage initrd 138 */ 139#ifdef CONFIG_BLK_DEV_INITRD 140 141static int __init rd_start_early(char *p) 142{ 143 unsigned long start = memparse(p, &p); 144 145#ifdef CONFIG_64BIT 146 /* Guess if the sign extension was forgotten by bootloader */ 147 if (start < XKPHYS) 148 start = (int)start; 149#endif 150 initrd_start = start; 151 initrd_end += start; 152 return 0; 153} 154early_param("rd_start", rd_start_early); 155 156static int __init rd_size_early(char *p) 157{ 158 initrd_end += memparse(p, &p); 159 return 0; 160} 161early_param("rd_size", rd_size_early); 162 163/* it returns the next free pfn after initrd */ 164static unsigned long __init init_initrd(void) 165{ 166 unsigned long end; 167 168 /* 169 * Board specific code or command line parser should have 170 * already set up initrd_start and initrd_end. In these cases 171 * perfom sanity checks and use them if all looks good. 172 */ 173 if (!initrd_start || initrd_end <= initrd_start) 174 goto disable; 175 176 if (initrd_start & ~PAGE_MASK) { 177 pr_err("initrd start must be page aligned\n"); 178 goto disable; 179 } 180 if (initrd_start < PAGE_OFFSET) { 181 pr_err("initrd start < PAGE_OFFSET\n"); 182 goto disable; 183 } 184 185 /* 186 * Sanitize initrd addresses. For example firmware 187 * can't guess if they need to pass them through 188 * 64-bits values if the kernel has been built in pure 189 * 32-bit. We need also to switch from KSEG0 to XKPHYS 190 * addresses now, so the code can now safely use __pa(). 191 */ 192 end = __pa(initrd_end); 193 initrd_end = (unsigned long)__va(end); 194 initrd_start = (unsigned long)__va(__pa(initrd_start)); 195 196 ROOT_DEV = Root_RAM0; 197 return PFN_UP(end); 198disable: 199 initrd_start = 0; 200 initrd_end = 0; 201 return 0; 202} 203 204static void __init finalize_initrd(void) 205{ 206 unsigned long size = initrd_end - initrd_start; 207 208 if (size == 0) { 209 printk(KERN_INFO "Initrd not found or empty"); 210 goto disable; 211 } 212 if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) { 213 printk(KERN_ERR "Initrd extends beyond end of memory"); 214 goto disable; 215 } 216 217 reserve_bootmem(__pa(initrd_start), size, BOOTMEM_DEFAULT); 218 initrd_below_start_ok = 1; 219 220 pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n", 221 initrd_start, size); 222 return; 223disable: 224 printk(KERN_CONT " - disabling initrd\n"); 225 initrd_start = 0; 226 initrd_end = 0; 227} 228 229#else /* !CONFIG_BLK_DEV_INITRD */ 230 231static unsigned long __init init_initrd(void) 232{ 233 return 0; 234} 235 236#define finalize_initrd() do {} while (0) 237 238#endif 239 240/* 241 * Initialize the bootmem allocator. It also setup initrd related data 242 * if needed. 243 */ 244#ifdef CONFIG_SGI_IP27 245 246static void __init bootmem_init(void) 247{ 248 init_initrd(); 249 finalize_initrd(); 250} 251 252#else /* !CONFIG_SGI_IP27 */ 253 254static void __init bootmem_init(void) 255{ 256 unsigned long reserved_end; 257 unsigned long mapstart = ~0UL; 258 unsigned long bootmap_size; 259 int i; 260 261 /* 262 * Init any data related to initrd. It's a nop if INITRD is 263 * not selected. Once that done we can determine the low bound 264 * of usable memory. 265 */ 266 reserved_end = max(init_initrd(), 267 (unsigned long) PFN_UP(__pa_symbol(&_end))); 268 269 /* 270 * max_low_pfn is not a number of pages. The number of pages 271 * of the system is given by 'max_low_pfn - min_low_pfn'. 272 */ 273 min_low_pfn = ~0UL; 274 max_low_pfn = 0; 275 276 /* 277 * Find the highest page frame number we have available. 278 */ 279 for (i = 0; i < boot_mem_map.nr_map; i++) { 280 unsigned long start, end; 281 282 if (boot_mem_map.map[i].type != BOOT_MEM_RAM) 283 continue; 284 285 start = PFN_UP(boot_mem_map.map[i].addr); 286 end = PFN_DOWN(boot_mem_map.map[i].addr 287 + boot_mem_map.map[i].size); 288 289 if (end > max_low_pfn) 290 max_low_pfn = end; 291 if (start < min_low_pfn) 292 min_low_pfn = start; 293 if (end <= reserved_end) 294 continue; 295 if (start >= mapstart) 296 continue; 297 mapstart = max(reserved_end, start); 298 } 299 300 if (min_low_pfn >= max_low_pfn) 301 panic("Incorrect memory mapping !!!"); 302 if (min_low_pfn > ARCH_PFN_OFFSET) { 303 pr_info("Wasting %lu bytes for tracking %lu unused pages\n", 304 (min_low_pfn - ARCH_PFN_OFFSET) * sizeof(struct page), 305 min_low_pfn - ARCH_PFN_OFFSET); 306 } else if (min_low_pfn < ARCH_PFN_OFFSET) { 307 pr_info("%lu free pages won't be used\n", 308 ARCH_PFN_OFFSET - min_low_pfn); 309 } 310 min_low_pfn = ARCH_PFN_OFFSET; 311 312 /* 313 * Determine low and high memory ranges 314 */ 315 max_pfn = max_low_pfn; 316 if (max_low_pfn > PFN_DOWN(HIGHMEM_START)) { 317#ifdef CONFIG_HIGHMEM 318 highstart_pfn = PFN_DOWN(HIGHMEM_START); 319 highend_pfn = max_low_pfn; 320#endif 321 max_low_pfn = PFN_DOWN(HIGHMEM_START); 322 } 323 324 /* 325 * Initialize the boot-time allocator with low memory only. 326 */ 327 bootmap_size = init_bootmem_node(NODE_DATA(0), mapstart, 328 min_low_pfn, max_low_pfn); 329 330 331 for (i = 0; i < boot_mem_map.nr_map; i++) { 332 unsigned long start, end; 333 334 start = PFN_UP(boot_mem_map.map[i].addr); 335 end = PFN_DOWN(boot_mem_map.map[i].addr 336 + boot_mem_map.map[i].size); 337 338 if (start <= min_low_pfn) 339 start = min_low_pfn; 340 if (start >= end) 341 continue; 342 343#ifndef CONFIG_HIGHMEM 344 if (end > max_low_pfn) 345 end = max_low_pfn; 346 347 /* 348 * ... finally, is the area going away? 349 */ 350 if (end <= start) 351 continue; 352#endif 353 354 add_active_range(0, start, end); 355 } 356 357 /* 358 * Register fully available low RAM pages with the bootmem allocator. 359 */ 360 for (i = 0; i < boot_mem_map.nr_map; i++) { 361 unsigned long start, end, size; 362 363 /* 364 * Reserve usable memory. 365 */ 366 if (boot_mem_map.map[i].type != BOOT_MEM_RAM) 367 continue; 368 369 start = PFN_UP(boot_mem_map.map[i].addr); 370 end = PFN_DOWN(boot_mem_map.map[i].addr 371 + boot_mem_map.map[i].size); 372 /* 373 * We are rounding up the start address of usable memory 374 * and at the end of the usable range downwards. 375 */ 376 if (start >= max_low_pfn) 377 continue; 378 if (start < reserved_end) 379 start = reserved_end; 380 if (end > max_low_pfn) 381 end = max_low_pfn; 382 383 /* 384 * ... finally, is the area going away? 385 */ 386 if (end <= start) 387 continue; 388 size = end - start; 389 390 /* Register lowmem ranges */ 391 free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT); 392 memory_present(0, start, end); 393 } 394 395 /* 396 * Reserve the bootmap memory. 397 */ 398 reserve_bootmem(PFN_PHYS(mapstart), bootmap_size, BOOTMEM_DEFAULT); 399 400 /* 401 * Reserve initrd memory if needed. 402 */ 403 finalize_initrd(); 404} 405 406#endif /* CONFIG_SGI_IP27 */ 407 408/* 409 * arch_mem_init - initialize memory management subsystem 410 * 411 * o plat_mem_setup() detects the memory configuration and will record detected 412 * memory areas using add_memory_region. 413 * 414 * At this stage the memory configuration of the system is known to the 415 * kernel but generic memory management system is still entirely uninitialized. 416 * 417 * o bootmem_init() 418 * o sparse_init() 419 * o paging_init() 420 * 421 * At this stage the bootmem allocator is ready to use. 422 * 423 * NOTE: historically plat_mem_setup did the entire platform initialization. 424 * This was rather impractical because it meant plat_mem_setup had to 425 * get away without any kind of memory allocator. To keep old code from 426 * breaking plat_setup was just renamed to plat_setup and a second platform 427 * initialization hook for anything else was introduced. 428 */ 429 430static int usermem __initdata; 431 432static int __init early_parse_mem(char *p) 433{ 434 unsigned long start, size; 435 436 /* 437 * If a user specifies memory size, we 438 * blow away any automatically generated 439 * size. 440 */ 441 if (usermem == 0) { 442 boot_mem_map.nr_map = 0; 443 usermem = 1; 444 } 445 start = 0; 446 size = memparse(p, &p); 447 if (*p == '@') 448 start = memparse(p + 1, &p); 449 450 add_memory_region(start, size, BOOT_MEM_RAM); 451 return 0; 452} 453early_param("mem", early_parse_mem); 454 455static void __init arch_mem_init(char **cmdline_p) 456{ 457 extern void plat_mem_setup(void); 458 459 /* call board setup routine */ 460 plat_mem_setup(); 461 462 pr_info("Determined physical RAM map:\n"); 463 print_memory_map(); 464 465#ifdef CONFIG_CMDLINE_BOOL 466#ifdef CONFIG_CMDLINE_OVERRIDE 467 strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE); 468#else 469 if (builtin_cmdline[0]) { 470 strlcat(arcs_cmdline, " ", COMMAND_LINE_SIZE); 471 strlcat(arcs_cmdline, builtin_cmdline, COMMAND_LINE_SIZE); 472 } 473 strlcpy(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 474#endif 475#else 476 strlcpy(boot_command_line, arcs_cmdline, COMMAND_LINE_SIZE); 477#endif 478 strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE); 479 480 *cmdline_p = command_line; 481 482 parse_early_param(); 483 484 if (usermem) { 485 pr_info("User-defined physical RAM map:\n"); 486 print_memory_map(); 487 } 488 489 bootmem_init(); 490 sparse_init(); 491 paging_init(); 492} 493 494static void __init resource_init(void) 495{ 496 int i; 497 498 if (UNCAC_BASE != IO_BASE) 499 return; 500 501 code_resource.start = __pa_symbol(&_text); 502 code_resource.end = __pa_symbol(&_etext) - 1; 503 data_resource.start = __pa_symbol(&_etext); 504 data_resource.end = __pa_symbol(&_edata) - 1; 505 506 /* 507 * Request address space for all standard RAM. 508 */ 509 for (i = 0; i < boot_mem_map.nr_map; i++) { 510 struct resource *res; 511 unsigned long start, end; 512 513 start = boot_mem_map.map[i].addr; 514 end = boot_mem_map.map[i].addr + boot_mem_map.map[i].size - 1; 515 if (start >= HIGHMEM_START) 516 continue; 517 if (end >= HIGHMEM_START) 518 end = HIGHMEM_START - 1; 519 520 res = alloc_bootmem(sizeof(struct resource)); 521 switch (boot_mem_map.map[i].type) { 522 case BOOT_MEM_RAM: 523 case BOOT_MEM_ROM_DATA: 524 res->name = "System RAM"; 525 break; 526 case BOOT_MEM_RESERVED: 527 default: 528 res->name = "reserved"; 529 } 530 531 res->start = start; 532 res->end = end; 533 534 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 535 request_resource(&iomem_resource, res); 536 537 /* 538 * We don't know which RAM region contains kernel data, 539 * so we try it repeatedly and let the resource manager 540 * test it. 541 */ 542 request_resource(res, &code_resource); 543 request_resource(res, &data_resource); 544 } 545} 546 547void __init setup_arch(char **cmdline_p) 548{ 549 cpu_probe(); 550 prom_init(); 551 552#ifdef CONFIG_EARLY_PRINTK 553 setup_early_printk(); 554#endif 555 cpu_report(); 556 check_bugs_early(); 557 558#if defined(CONFIG_VT) 559#if defined(CONFIG_VGA_CONSOLE) 560 conswitchp = &vga_con; 561#elif defined(CONFIG_DUMMY_CONSOLE) 562 conswitchp = &dummy_con; 563#endif 564#endif 565 566 arch_mem_init(cmdline_p); 567 568 resource_init(); 569 plat_smp_setup(); 570} 571 572unsigned long kernelsp[NR_CPUS]; 573unsigned long fw_arg0, fw_arg1, fw_arg2, fw_arg3; 574 575#ifdef CONFIG_DEBUG_FS 576struct dentry *mips_debugfs_dir; 577static int __init debugfs_mips(void) 578{ 579 struct dentry *d; 580 581 d = debugfs_create_dir("mips", NULL); 582 if (!d) 583 return -ENOMEM; 584 mips_debugfs_dir = d; 585 return 0; 586} 587arch_initcall(debugfs_mips); 588#endif 589