/* * 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 <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/sections.h>#include <asm/setup.h>#include <asm/smp-ops.h>#include <asm/prom.h> struct cpuinfo_mips cpu_data[NR_CPUS] __read_mostly; EXPORT_SYMBOL(cpu_data); #ifdef CONFIG_VTstruct screen_info screen_info;#endif /* * Despite it's name this variable is even if we don't have PCI */unsigned int PCI_DMA_BUS_IS_PHYS; EXPORT_SYMBOL(PCI_DMA_BUS_IS_PHYS); /* * 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 void *detect_magic __initdata = detect_memory_region; void __init add_memory_region(phys_addr_t start, phys_addr_t size, long type){	int x = boot_mem_map.nr_map;	int i; 	/* 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 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;} 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;	} 	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 void __init bootmem_init(void){	unsigned long reserved_end;	unsigned long mapstart = ~0UL;	unsigned long bootmap_size;	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.	 */	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); 		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		/* mapstart should be after initrd_end */		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 !!!");	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 (min_low_pfn < ARCH_PFN_OFFSET) {		pr_info("%lu free pages won't be used\n",			ARCH_PFN_OFFSET - min_low_pfn);	}	min_low_pfn = ARCH_PFN_OFFSET; 	/*	 * 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);	} 	/*	 * Initialize the boot-time allocator with low memory only.	 */	bootmap_size = init_bootmem_node(NODE_DATA(0), mapstart,					 min_low_pfn, max_low_pfn);  	for (i = 0; i < boot_mem_map.nr_map; i++) {		unsigned long start, end; 		start = PFN_UP(boot_mem_map.map[i].addr);		end = PFN_DOWN(boot_mem_map.map[i].addr				+ boot_mem_map.map[i].size); 		if (start <= min_low_pfn)			start = min_low_pfn;		if (start >= end)			continue; #ifndef CONFIG_HIGHMEM		if (end > max_low_pfn)			end = max_low_pfn; 		/*		 * ... finally, is the area going away?		 */		if (end <= start)			continue;#endif 		memblock_add_node(PFN_PHYS(start), PFN_PHYS(end - start), 0);	} 	/*	 * Register fully available low RAM pages with the bootmem allocator.	 */	for (i = 0; i < boot_mem_map.nr_map; i++) {		unsigned long start, end, size; 		start = PFN_UP(boot_mem_map.map[i].addr);		end   = PFN_DOWN(boot_mem_map.map[i].addr				    + boot_mem_map.map[i].size); 		/*		 * Reserve usable memory.		 */		switch (boot_mem_map.map[i].type) {		case BOOT_MEM_RAM:			break;		case BOOT_MEM_INIT_RAM:			memory_present(0, start, end);			continue;		default:			/* Not usable memory */			continue;		} 		/*		 * We are rounding up the start address of usable memory		 * and at the end of the usable range downwards.		 */		if (start >= max_low_pfn)			continue;		if (start < reserved_end)			start = reserved_end;		if (end > max_low_pfn)			end = max_low_pfn; 		/*		 * ... finally, is the area going away?		 */		if (end <= start)			continue;		size = end - start; 		/* Register lowmem ranges */		free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT);		memory_present(0, start, end);	} 	/*	 * Reserve the bootmap memory.	 */	reserve_bootmem(PFN_PHYS(mapstart), bootmap_size, BOOTMEM_DEFAULT); 	/*	 * Reserve initrd memory if needed.	 */	finalize_initrd();} #endif	/* CONFIG_SGI_IP27 */ /* * arch_mem_init - initialize memory management subsystem * *  o plat_mem_setup() detects the memory configuration and will record detected *    memory areas using add_memory_region. * * At this stage the memory configuration of the system is known to the * kernel but generic memory management system is still entirely uninitialized. * *  o bootmem_init() *  o sparse_init() *  o paging_init() *  o dma_continguous_reserve() * * At this stage the bootmem allocator is ready to use. * * NOTE: historically plat_mem_setup did the entire platform initialization. *	 This was rather impractical because it meant plat_mem_setup had to * get away without any kind of memory allocator.  To keep old code from * breaking plat_setup was just renamed to plat_mem_setup and a second platform * initialization hook for anything else was introduced. */ static int usermem __initdata; static int __init early_parse_mem(char *p){	phys_addr_t start, size; 	/*	 * If a user specifies memory size, we	 * blow away any automatically generated	 * size.	 */

Lines 1–500 of 804. Load more