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