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