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 highest = 0; 275 unsigned long mapstart = -1UL; 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 * Find the highest page frame number we have available. 288 */ 289 for (i = 0; i < boot_mem_map.nr_map; i++) { 290 unsigned long start, end; 291 292 if (boot_mem_map.map[i].type != BOOT_MEM_RAM) 293 continue; 294 295 start = PFN_UP(boot_mem_map.map[i].addr); 296 end = PFN_DOWN(boot_mem_map.map[i].addr 297 + boot_mem_map.map[i].size); 298 299 if (end > highest) 300 highest = end; 301 if (end <= reserved_end) 302 continue; 303 if (start >= mapstart) 304 continue; 305 mapstart = max(reserved_end, start); 306 } 307 308 /* 309 * Determine low and high memory ranges 310 */ 311 if (highest > PFN_DOWN(HIGHMEM_START)) { 312 #ifdef CONFIG_HIGHMEM 313 highstart_pfn = PFN_DOWN(HIGHMEM_START); 314 highend_pfn = highest; 315 #endif 316 highest = PFN_DOWN(HIGHMEM_START); 317 } 318 319 /* 320 * Initialize the boot-time allocator with low memory only. 321 */ 322 bootmap_size = init_bootmem(mapstart, highest); 323 324 /* 325 * Register fully available low RAM pages with the bootmem allocator. 326 */ 327 for (i = 0; i < boot_mem_map.nr_map; i++) { 328 unsigned long start, end, size; 329 330 /* 331 * Reserve usable memory. 332 */ 333 if (boot_mem_map.map[i].type != BOOT_MEM_RAM) 334 continue; 335 336 start = PFN_UP(boot_mem_map.map[i].addr); 337 end = PFN_DOWN(boot_mem_map.map[i].addr 338 + boot_mem_map.map[i].size); 339 /* 340 * We are rounding up the start address of usable memory 341 * and at the end of the usable range downwards. 342 */ 343 if (start >= max_low_pfn) 344 continue; 345 if (start < reserved_end) 346 start = reserved_end; 347 if (end > max_low_pfn) 348 end = max_low_pfn; 349 350 /* 351 * ... finally, is the area going away? 352 */ 353 if (end <= start) 354 continue; 355 size = end - start; 356 357 /* Register lowmem ranges */ 358 free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT); 359 memory_present(0, start, end); 360 } 361 362 /* 363 * Reserve the bootmap memory. 364 */ 365 reserve_bootmem(PFN_PHYS(mapstart), bootmap_size); 366 367 /* 368 * Reserve initrd memory if needed. 369 */ 370 finalize_initrd(); 371 } 372 373 #endif /* CONFIG_SGI_IP27 */ 374 375 /* 376 * arch_mem_init - initialize memory managment subsystem 377 * 378 * o plat_mem_setup() detects the memory configuration and will record detected 379 * memory areas using add_memory_region. 380 * 381 * At this stage the memory configuration of the system is known to the 382 * kernel but generic memory managment system is still entirely uninitialized. 383 * 384 * o bootmem_init() 385 * o sparse_init() 386 * o paging_init() 387 * 388 * At this stage the bootmem allocator is ready to use. 389 * 390 * NOTE: historically plat_mem_setup did the entire platform initialization. 391 * This was rather impractical because it meant plat_mem_setup had to 392 * get away without any kind of memory allocator. To keep old code from 393 * breaking plat_setup was just renamed to plat_setup and a second platform 394 * initialization hook for anything else was introduced. 395 */ 396 397 static int usermem __initdata = 0; 398 399 static int __init early_parse_mem(char *p) 400 { 401 unsigned long start, size; 402 403 /* 404 * If a user specifies memory size, we 405 * blow away any automatically generated 406 * size. 407 */ 408 if (usermem == 0) { 409 boot_mem_map.nr_map = 0; 410 usermem = 1; 411 } 412 start = 0; 413 size = memparse(p, &p); 414 if (*p == '@') 415 start = memparse(p + 1, &p); 416 417 add_memory_region(start, size, BOOT_MEM_RAM); 418 return 0; 419 } 420 early_param("mem", early_parse_mem); 421 422 static void __init arch_mem_init(char **cmdline_p) 423 { 424 extern void plat_mem_setup(void); 425 426 /* call board setup routine */ 427 plat_mem_setup(); 428 429 printk("Determined physical RAM map:\n"); 430 print_memory_map(); 431 432 strlcpy(command_line, arcs_cmdline, sizeof(command_line)); 433 strlcpy(saved_command_line, command_line, COMMAND_LINE_SIZE); 434 435 *cmdline_p = command_line; 436 437 parse_early_param(); 438 439 if (usermem) { 440 printk("User-defined physical RAM map:\n"); 441 print_memory_map(); 442 } 443 444 bootmem_init(); 445 sparse_init(); 446 paging_init(); 447 } 448 449 static void __init resource_init(void) 450 { 451 int i; 452 453 if (UNCAC_BASE != IO_BASE) 454 return; 455 456 code_resource.start = __pa_symbol(&_text); 457 code_resource.end = __pa_symbol(&_etext) - 1; 458 data_resource.start = __pa_symbol(&_etext); 459 data_resource.end = __pa_symbol(&_edata) - 1; 460 461 /* 462 * Request address space for all standard RAM. 463 */ 464 for (i = 0; i < boot_mem_map.nr_map; i++) { 465 struct resource *res; 466 unsigned long start, end; 467 468 start = boot_mem_map.map[i].addr; 469 end = boot_mem_map.map[i].addr + boot_mem_map.map[i].size - 1; 470 if (start >= HIGHMEM_START) 471 continue; 472 if (end >= HIGHMEM_START) 473 end = HIGHMEM_START - 1; 474 475 res = alloc_bootmem(sizeof(struct resource)); 476 switch (boot_mem_map.map[i].type) { 477 case BOOT_MEM_RAM: 478 case BOOT_MEM_ROM_DATA: 479 res->name = "System RAM"; 480 break; 481 case BOOT_MEM_RESERVED: 482 default: 483 res->name = "reserved"; 484 } 485 486 res->start = start; 487 res->end = end; 488 489 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; 490 request_resource(&iomem_resource, res); 491 492 /* 493 * We don't know which RAM region contains kernel data, 494 * so we try it repeatedly and let the resource manager 495 * test it. 496 */ 497 request_resource(res, &code_resource); 498 request_resource(res, &data_resource); 499 } 500 } 501 502 void __init setup_arch(char **cmdline_p) 503 { 504 cpu_probe(); 505 prom_init(); 506 cpu_report(); 507 508 #if defined(CONFIG_VT) 509 #if defined(CONFIG_VGA_CONSOLE) 510 conswitchp = &vga_con; 511 #elif defined(CONFIG_DUMMY_CONSOLE) 512 conswitchp = &dummy_con; 513 #endif 514 #endif 515 516 arch_mem_init(cmdline_p); 517 518 resource_init(); 519 #ifdef CONFIG_SMP 520 plat_smp_setup(); 521 #endif 522 } 523 524 int __init fpu_disable(char *s) 525 { 526 int i; 527 528 for (i = 0; i < NR_CPUS; i++) 529 cpu_data[i].options &= ~MIPS_CPU_FPU; 530 531 return 1; 532 } 533 534 __setup("nofpu", fpu_disable); 535 536 int __init dsp_disable(char *s) 537 { 538 cpu_data[0].ases &= ~MIPS_ASE_DSP; 539 540 return 1; 541 } 542 543 __setup("nodsp", dsp_disable); 544