/* * This file is subject to the terms and conditions of the GNU General Public * License.  See the file "COPYING" in the main directory of this archive * for more details. * * Copyright (C) 1995 Linus Torvalds * Copyright (C) 1995 Waldorf Electronics * Copyright (C) 1994, 95, 96, 97, 98, 99, 2000, 01, 02, 03  Ralf Baechle * Copyright (C) 1996 Stoned Elipot * Copyright (C) 1999 Silicon Graphics, Inc. * Copyright (C) 2000, 2001, 2002, 2007	 Maciej W. Rozycki */#include <linux/init.h>#include <linux/ioport.h>#include <linux/export.h>#include <linux/screen_info.h>#include <linux/memblock.h>#include <linux/bootmem.h>#include <linux/initrd.h>#include <linux/root_dev.h>#include <linux/highmem.h>#include <linux/console.h>#include <linux/pfn.h>#include <linux/debugfs.h>#include <linux/kexec.h>#include <linux/sizes.h>#include <linux/device.h>#include <linux/dma-contiguous.h>#include <linux/decompress/generic.h>#include <linux/of_fdt.h> #include <asm/addrspace.h>#include <asm/bootinfo.h>#include <asm/bugs.h>#include <asm/cache.h>#include <asm/cdmm.h>#include <asm/cpu.h>#include <asm/debug.h>#include <asm/dma-coherence.h>#include <asm/sections.h>#include <asm/setup.h>#include <asm/smp-ops.h>#include <asm/prom.h> #ifdef CONFIG_MIPS_ELF_APPENDED_DTBconst char __section(.appended_dtb) __appended_dtb[0x100000];#endif /* CONFIG_MIPS_ELF_APPENDED_DTB */ struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly; EXPORT_SYMBOL(cpu_data); #ifdef CONFIG_VTstruct screen_info screen_info;#endif /* * Setup information * * These are initialized so they are in the .data section */unsigned long mips_machtype __read_mostly = MACH_UNKNOWN; EXPORT_SYMBOL(mips_machtype); struct boot_mem_map boot_mem_map; static char __initdata command_line[COMMAND_LINE_SIZE];char __initdata arcs_cmdline[COMMAND_LINE_SIZE]; #ifdef CONFIG_CMDLINE_BOOLstatic char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;#endif /* * mips_io_port_base is the begin of the address space to which x86 style * I/O ports are mapped. */const unsigned long mips_io_port_base = -1;EXPORT_SYMBOL(mips_io_port_base); static struct resource code_resource = { .name = "Kernel code", };static struct resource data_resource = { .name = "Kernel data", };static struct resource bss_resource = { .name = "Kernel bss", }; static void *detect_magic __initdata = detect_memory_region; #ifdef CONFIG_MIPS_AUTO_PFN_OFFSETunsigned long ARCH_PFN_OFFSET;EXPORT_SYMBOL(ARCH_PFN_OFFSET);#endif void __init add_memory_region(phys_addr_t start, phys_addr_t size, long type){	int x = boot_mem_map.nr_map;	int i; 	/*	 * If the region reaches the top of the physical address space, adjust	 * the size slightly so that (start + size) doesn't overflow	 */	if (start + size - 1 == PHYS_ADDR_MAX)		--size; 	/* Sanity check */	if (start + size < start) {		pr_warn("Trying to add an invalid memory region, skipped\n");		return;	} 	/*	 * Try to merge with existing entry, if any.	 */	for (i = 0; i < boot_mem_map.nr_map; i++) {		struct boot_mem_map_entry *entry = boot_mem_map.map + i;		unsigned long top; 		if (entry->type != type)			continue; 		if (start + size < entry->addr)			continue;			/* no overlap */ 		if (entry->addr + entry->size < start)			continue;			/* no overlap */ 		top = max(entry->addr + entry->size, start + size);		entry->addr = min(entry->addr, start);		entry->size = top - entry->addr; 		return;	} 	if (boot_mem_map.nr_map == BOOT_MEM_MAP_MAX) {		pr_err("Ooops! Too many entries in the memory map!\n");		return;	} 	boot_mem_map.map[x].addr = start;	boot_mem_map.map[x].size = size;	boot_mem_map.map[x].type = type;	boot_mem_map.nr_map++;} void __init detect_memory_region(phys_addr_t start, phys_addr_t sz_min, phys_addr_t sz_max){	void *dm = &detect_magic;	phys_addr_t size; 	for (size = sz_min; size < sz_max; size <<= 1) {		if (!memcmp(dm, dm + size, sizeof(detect_magic)))			break;	} 	pr_debug("Memory: %lluMB of RAM detected at 0x%llx (min: %lluMB, max: %lluMB)\n",		((unsigned long long) size) / SZ_1M,		(unsigned long long) start,		((unsigned long long) sz_min) / SZ_1M,		((unsigned long long) sz_max) / SZ_1M); 	add_memory_region(start, size, BOOT_MEM_RAM);} static bool __init __maybe_unused memory_region_available(phys_addr_t start,							  phys_addr_t size){	int i;	bool in_ram = false, free = true; 	for (i = 0; i < boot_mem_map.nr_map; i++) {		phys_addr_t start_, end_; 		start_ = boot_mem_map.map[i].addr;		end_ = boot_mem_map.map[i].addr + boot_mem_map.map[i].size; 		switch (boot_mem_map.map[i].type) {		case BOOT_MEM_RAM:			if (start >= start_ && start + size <= end_)				in_ram = true;			break;		case BOOT_MEM_RESERVED:			if ((start >= start_ && start < end_) ||			    (start < start_ && start + size >= start_))				free = false;			break;		default:			continue;		}	} 	return in_ram && free;} static void __init print_memory_map(void){	int i;	const int field = 2 * sizeof(unsigned long); 	for (i = 0; i < boot_mem_map.nr_map; i++) {		printk(KERN_INFO " memory: %0*Lx @ %0*Lx ",		       field, (unsigned long long) boot_mem_map.map[i].size,		       field, (unsigned long long) boot_mem_map.map[i].addr); 		switch (boot_mem_map.map[i].type) {		case BOOT_MEM_RAM:			printk(KERN_CONT "(usable)\n");			break;		case BOOT_MEM_INIT_RAM:			printk(KERN_CONT "(usable after init)\n");			break;		case BOOT_MEM_ROM_DATA:			printk(KERN_CONT "(ROM data)\n");			break;		case BOOT_MEM_RESERVED:			printk(KERN_CONT "(reserved)\n");			break;		default:			printk(KERN_CONT "type %lu\n", boot_mem_map.map[i].type);			break;		}	}} /* * Manage initrd */#ifdef CONFIG_BLK_DEV_INITRD static int __init rd_start_early(char *p){	unsigned long start = memparse(p, &p); #ifdef CONFIG_64BIT	/* Guess if the sign extension was forgotten by bootloader */	if (start < XKPHYS)		start = (int)start;#endif	initrd_start = start;	initrd_end += start;	return 0;}early_param("rd_start", rd_start_early); static int __init rd_size_early(char *p){	initrd_end += memparse(p, &p);	return 0;}early_param("rd_size", rd_size_early); /* it returns the next free pfn after initrd */static unsigned long __init init_initrd(void){	unsigned long end; 	/*	 * Board specific code or command line parser should have	 * already set up initrd_start and initrd_end. In these cases	 * perfom sanity checks and use them if all looks good.	 */	if (!initrd_start || initrd_end <= initrd_start)		goto disable; 	if (initrd_start & ~PAGE_MASK) {		pr_err("initrd start must be page aligned\n");		goto disable;	}	if (initrd_start < PAGE_OFFSET) {		pr_err("initrd start < PAGE_OFFSET\n");		goto disable;	} 	/*	 * Sanitize initrd addresses. For example firmware	 * can't guess if they need to pass them through	 * 64-bits values if the kernel has been built in pure	 * 32-bit. We need also to switch from KSEG0 to XKPHYS	 * addresses now, so the code can now safely use __pa().	 */	end = __pa(initrd_end);	initrd_end = (unsigned long)__va(end);	initrd_start = (unsigned long)__va(__pa(initrd_start)); 	ROOT_DEV = Root_RAM0;	return PFN_UP(end);disable:	initrd_start = 0;	initrd_end = 0;	return 0;} /* In some conditions (e.g. big endian bootloader with a little endian   kernel), the initrd might appear byte swapped.  Try to detect this and   byte swap it if needed.  */static void __init maybe_bswap_initrd(void){#if defined(CONFIG_CPU_CAVIUM_OCTEON)	u64 buf; 	/* Check for CPIO signature */	if (!memcmp((void *)initrd_start, "070701", 6))		return; 	/* Check for compressed initrd */	if (decompress_method((unsigned char *)initrd_start, 8, NULL))		return; 	/* Try again with a byte swapped header */	buf = swab64p((u64 *)initrd_start);	if (!memcmp(&buf, "070701", 6) ||	    decompress_method((unsigned char *)(&buf), 8, NULL)) {		unsigned long i; 		pr_info("Byteswapped initrd detected\n");		for (i = initrd_start; i < ALIGN(initrd_end, 8); i += 8)			swab64s((u64 *)i);	}#endif} static void __init finalize_initrd(void){	unsigned long size = initrd_end - initrd_start; 	if (size == 0) {		printk(KERN_INFO "Initrd not found or empty");		goto disable;	}	if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) {		printk(KERN_ERR "Initrd extends beyond end of memory");		goto disable;	} 	maybe_bswap_initrd(); 	reserve_bootmem(__pa(initrd_start), size, BOOTMEM_DEFAULT);	initrd_below_start_ok = 1; 	pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n",		initrd_start, size);	return;disable:	printk(KERN_CONT " - disabling initrd\n");	initrd_start = 0;	initrd_end = 0;} #else  /* !CONFIG_BLK_DEV_INITRD */ static unsigned long __init init_initrd(void){	return 0;} #define finalize_initrd()	do {} while (0) #endif /* * Initialize the bootmem allocator. It also setup initrd related data * if needed. */#if defined(CONFIG_SGI_IP27) || (defined(CONFIG_CPU_LOONGSON3) && defined(CONFIG_NUMA)) static void __init bootmem_init(void){	init_initrd();	finalize_initrd();} #else  /* !CONFIG_SGI_IP27 */ static unsigned long __init bootmap_bytes(unsigned long pages){	unsigned long bytes = DIV_ROUND_UP(pages, 8); 	return ALIGN(bytes, sizeof(long));} static void __init bootmem_init(void){	unsigned long reserved_end;	unsigned long mapstart = ~0UL;	unsigned long bootmap_size;	phys_addr_t ramstart = PHYS_ADDR_MAX;	bool bootmap_valid = false;	int i; 	/*	 * Sanity check any INITRD first. We don't take it into account	 * for bootmem setup initially, rely on the end-of-kernel-code	 * as our memory range starting point. Once bootmem is inited we	 * will reserve the area used for the initrd.	 */	init_initrd();	reserved_end = (unsigned long) PFN_UP(__pa_symbol(&_end)); 	/*	 * max_low_pfn is not a number of pages. The number of pages	 * of the system is given by 'max_low_pfn - min_low_pfn'.	 */	min_low_pfn = ~0UL;	max_low_pfn = 0; 	/*	 * Find the highest page frame number we have available	 * and the lowest used RAM address	 */	for (i = 0; i < boot_mem_map.nr_map; i++) {		unsigned long start, end; 		if (boot_mem_map.map[i].type != BOOT_MEM_RAM)			continue; 		start = PFN_UP(boot_mem_map.map[i].addr);		end = PFN_DOWN(boot_mem_map.map[i].addr				+ boot_mem_map.map[i].size); 		ramstart = min(ramstart, boot_mem_map.map[i].addr); #ifndef CONFIG_HIGHMEM		/*		 * Skip highmem here so we get an accurate max_low_pfn if low		 * memory stops short of high memory.		 * If the region overlaps HIGHMEM_START, end is clipped so		 * max_pfn excludes the highmem portion.		 */		if (start >= PFN_DOWN(HIGHMEM_START))			continue;		if (end > PFN_DOWN(HIGHMEM_START))			end = PFN_DOWN(HIGHMEM_START);#endif 		if (end > max_low_pfn)			max_low_pfn = end;		if (start < min_low_pfn)			min_low_pfn = start;		if (end <= reserved_end)			continue;#ifdef CONFIG_BLK_DEV_INITRD		/* Skip zones before initrd and initrd itself */		if (initrd_end && end <= (unsigned long)PFN_UP(__pa(initrd_end)))			continue;#endif		if (start >= mapstart)			continue;		mapstart = max(reserved_end, start);	} 	if (min_low_pfn >= max_low_pfn)		panic("Incorrect memory mapping !!!"); #ifdef CONFIG_MIPS_AUTO_PFN_OFFSET	ARCH_PFN_OFFSET = PFN_UP(ramstart);#else	/*	 * Reserve any memory between the start of RAM and PHYS_OFFSET	 */	if (ramstart > PHYS_OFFSET)		add_memory_region(PHYS_OFFSET, ramstart - PHYS_OFFSET,				  BOOT_MEM_RESERVED); 	if (min_low_pfn > ARCH_PFN_OFFSET) {		pr_info("Wasting %lu bytes for tracking %lu unused pages\n",			(min_low_pfn - ARCH_PFN_OFFSET) * sizeof(struct page),			min_low_pfn - ARCH_PFN_OFFSET);	} else if (ARCH_PFN_OFFSET - min_low_pfn > 0UL) {		pr_info("%lu free pages won't be used\n",			ARCH_PFN_OFFSET - min_low_pfn);	}	min_low_pfn = ARCH_PFN_OFFSET;#endif 	/*	 * Determine low and high memory ranges	 */	max_pfn = max_low_pfn;	if (max_low_pfn > PFN_DOWN(HIGHMEM_START)) {#ifdef CONFIG_HIGHMEM		highstart_pfn = PFN_DOWN(HIGHMEM_START);		highend_pfn = max_low_pfn;#endif		max_low_pfn = PFN_DOWN(HIGHMEM_START);	} #ifdef CONFIG_BLK_DEV_INITRD	/*	 * mapstart should be after initrd_end	 */	if (initrd_end)		mapstart = max(mapstart, (unsigned long)PFN_UP(__pa(initrd_end)));#endif 	/*	 * check that mapstart doesn't overlap with any of	 * memory regions that have been reserved through eg. DTB	 */	bootmap_size = bootmap_bytes(max_low_pfn - min_low_pfn); 	bootmap_valid = memory_region_available(PFN_PHYS(mapstart),

Lines 1–500 of 1099. Load more