/* * Architecture-specific setup. * * Copyright (C) 1998-2001, 2003-2004 Hewlett-Packard Co *	David Mosberger-Tang <davidm@hpl.hp.com> *	Stephane Eranian <eranian@hpl.hp.com> * Copyright (C) 2000, 2004 Intel Corp * 	Rohit Seth <rohit.seth@intel.com> * 	Suresh Siddha <suresh.b.siddha@intel.com> * 	Gordon Jin <gordon.jin@intel.com> * Copyright (C) 1999 VA Linux Systems * Copyright (C) 1999 Walt Drummond <drummond@valinux.com> * * 12/26/04 S.Siddha, G.Jin, R.Seth *			Add multi-threading and multi-core detection * 11/12/01 D.Mosberger Convert get_cpuinfo() to seq_file based show_cpuinfo(). * 04/04/00 D.Mosberger renamed cpu_initialized to cpu_online_map * 03/31/00 R.Seth	cpu_initialized and current->processor fixes * 02/04/00 D.Mosberger	some more get_cpuinfo fixes... * 02/01/00 R.Seth	fixed get_cpuinfo for SMP * 01/07/99 S.Eranian	added the support for command line argument * 06/24/99 W.Drummond	added boot_cpu_data. * 05/28/05 Z. Menyhart	Dynamic stride size for "flush_icache_range()" */#include <linux/module.h>#include <linux/init.h> #include <linux/acpi.h>#include <linux/bootmem.h>#include <linux/console.h>#include <linux/delay.h>#include <linux/kernel.h>#include <linux/reboot.h>#include <linux/sched.h>#include <linux/seq_file.h>#include <linux/string.h>#include <linux/threads.h>#include <linux/screen_info.h>#include <linux/dmi.h>#include <linux/serial.h>#include <linux/serial_core.h>#include <linux/efi.h>#include <linux/initrd.h>#include <linux/pm.h>#include <linux/cpufreq.h>#include <linux/kexec.h>#include <linux/crash_dump.h> #include <asm/machvec.h>#include <asm/mca.h>#include <asm/meminit.h>#include <asm/page.h>#include <asm/paravirt.h>#include <asm/paravirt_patch.h>#include <asm/patch.h>#include <asm/pgtable.h>#include <asm/processor.h>#include <asm/sal.h>#include <asm/sections.h>#include <asm/setup.h>#include <asm/smp.h>#include <asm/tlbflush.h>#include <asm/unistd.h>#include <asm/hpsim.h> #if defined(CONFIG_SMP) && (IA64_CPU_SIZE > PAGE_SIZE)# error "struct cpuinfo_ia64 too big!"#endif #ifdef CONFIG_SMPunsigned long __per_cpu_offset[NR_CPUS];EXPORT_SYMBOL(__per_cpu_offset);#endif DEFINE_PER_CPU(struct cpuinfo_ia64, ia64_cpu_info);DEFINE_PER_CPU(unsigned long, local_per_cpu_offset);unsigned long ia64_cycles_per_usec;struct ia64_boot_param *ia64_boot_param;struct screen_info screen_info;unsigned long vga_console_iobase;unsigned long vga_console_membase; static struct resource data_resource = {	.name	= "Kernel data",	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM}; static struct resource code_resource = {	.name	= "Kernel code",	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM}; static struct resource bss_resource = {	.name	= "Kernel bss",	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM}; unsigned long ia64_max_cacheline_size; unsigned long ia64_iobase;	/* virtual address for I/O accesses */EXPORT_SYMBOL(ia64_iobase);struct io_space io_space[MAX_IO_SPACES];EXPORT_SYMBOL(io_space);unsigned int num_io_spaces; /* * "flush_icache_range()" needs to know what processor dependent stride size to use * when it makes i-cache(s) coherent with d-caches. */#define	I_CACHE_STRIDE_SHIFT	5	/* Safest way to go: 32 bytes by 32 bytes */unsigned long ia64_i_cache_stride_shift = ~0;/* * "clflush_cache_range()" needs to know what processor dependent stride size to * use when it flushes cache lines including both d-cache and i-cache. *//* Safest way to go: 32 bytes by 32 bytes */#define	CACHE_STRIDE_SHIFT	5unsigned long ia64_cache_stride_shift = ~0; /* * The merge_mask variable needs to be set to (max(iommu_page_size(iommu)) - 1).  This * mask specifies a mask of address bits that must be 0 in order for two buffers to be * mergeable by the I/O MMU (i.e., the end address of the first buffer and the start * address of the second buffer must be aligned to (merge_mask+1) in order to be * mergeable).  By default, we assume there is no I/O MMU which can merge physically * discontiguous buffers, so we set the merge_mask to ~0UL, which corresponds to a iommu * page-size of 2^64. */unsigned long ia64_max_iommu_merge_mask = ~0UL;EXPORT_SYMBOL(ia64_max_iommu_merge_mask); /* * We use a special marker for the end of memory and it uses the extra (+1) slot */struct rsvd_region rsvd_region[IA64_MAX_RSVD_REGIONS + 1] __initdata;int num_rsvd_regions __initdata;  /* * Filter incoming memory segments based on the primitive map created from the boot * parameters. Segments contained in the map are removed from the memory ranges. A * caller-specified function is called with the memory ranges that remain after filtering. * This routine does not assume the incoming segments are sorted. */int __initfilter_rsvd_memory (u64 start, u64 end, void *arg){	u64 range_start, range_end, prev_start;	void (*func)(unsigned long, unsigned long, int);	int i; #if IGNORE_PFN0	if (start == PAGE_OFFSET) {		printk(KERN_WARNING "warning: skipping physical page 0\n");		start += PAGE_SIZE;		if (start >= end) return 0;	}#endif	/*	 * lowest possible address(walker uses virtual)	 */	prev_start = PAGE_OFFSET;	func = arg; 	for (i = 0; i < num_rsvd_regions; ++i) {		range_start = max(start, prev_start);		range_end   = min(end, rsvd_region[i].start); 		if (range_start < range_end)			call_pernode_memory(__pa(range_start), range_end - range_start, func); 		/* nothing more available in this segment */		if (range_end == end) return 0; 		prev_start = rsvd_region[i].end;	}	/* end of memory marker allows full processing inside loop body */	return 0;} /* * Similar to "filter_rsvd_memory()", but the reserved memory ranges * are not filtered out. */int __initfilter_memory(u64 start, u64 end, void *arg){	void (*func)(unsigned long, unsigned long, int); #if IGNORE_PFN0	if (start == PAGE_OFFSET) {		printk(KERN_WARNING "warning: skipping physical page 0\n");		start += PAGE_SIZE;		if (start >= end)			return 0;	}#endif	func = arg;	if (start < end)		call_pernode_memory(__pa(start), end - start, func);	return 0;} static void __initsort_regions (struct rsvd_region *rsvd_region, int max){	int j; 	/* simple bubble sorting */	while (max--) {		for (j = 0; j < max; ++j) {			if (rsvd_region[j].start > rsvd_region[j+1].start) {				struct rsvd_region tmp;				tmp = rsvd_region[j];				rsvd_region[j] = rsvd_region[j + 1];				rsvd_region[j + 1] = tmp;			}		}	}} /* merge overlaps */static int __initmerge_regions (struct rsvd_region *rsvd_region, int max){	int i;	for (i = 1; i < max; ++i) {		if (rsvd_region[i].start >= rsvd_region[i-1].end)			continue;		if (rsvd_region[i].end > rsvd_region[i-1].end)			rsvd_region[i-1].end = rsvd_region[i].end;		--max;		memmove(&rsvd_region[i], &rsvd_region[i+1],			(max - i) * sizeof(struct rsvd_region));	}	return max;} /* * Request address space for all standard resources */static int __init register_memory(void){	code_resource.start = ia64_tpa(_text);	code_resource.end   = ia64_tpa(_etext) - 1;	data_resource.start = ia64_tpa(_etext);	data_resource.end   = ia64_tpa(_edata) - 1;	bss_resource.start  = ia64_tpa(__bss_start);	bss_resource.end    = ia64_tpa(_end) - 1;	efi_initialize_iomem_resources(&code_resource, &data_resource,			&bss_resource); 	return 0;} __initcall(register_memory);  #ifdef CONFIG_KEXEC /* * This function checks if the reserved crashkernel is allowed on the specific * IA64 machine flavour. Machines without an IO TLB use swiotlb and require * some memory below 4 GB (i.e. in 32 bit area), see the implementation of * lib/swiotlb.c. The hpzx1 architecture has an IO TLB but cannot use that * in kdump case. See the comment in sba_init() in sba_iommu.c. * * So, the only machvec that really supports loading the kdump kernel * over 4 GB is "sn2". */static int __init check_crashkernel_memory(unsigned long pbase, size_t size){	if (ia64_platform_is("sn2") || ia64_platform_is("uv"))		return 1;	else		return pbase < (1UL << 32);} static void __init setup_crashkernel(unsigned long total, int *n){	unsigned long long base = 0, size = 0;	int ret; 	ret = parse_crashkernel(boot_command_line, total,			&size, &base);	if (ret == 0 && size > 0) {		if (!base) {			sort_regions(rsvd_region, *n);			*n = merge_regions(rsvd_region, *n);			base = kdump_find_rsvd_region(size,					rsvd_region, *n);		} 		if (!check_crashkernel_memory(base, size)) {			pr_warning("crashkernel: There would be kdump memory "				"at %ld GB but this is unusable because it "				"must\nbe below 4 GB. Change the memory "				"configuration of the machine.\n",				(unsigned long)(base >> 30));			return;		} 		if (base != ~0UL) {			printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "					"for crashkernel (System RAM: %ldMB)\n",					(unsigned long)(size >> 20),					(unsigned long)(base >> 20),					(unsigned long)(total >> 20));			rsvd_region[*n].start =				(unsigned long)__va(base);			rsvd_region[*n].end =				(unsigned long)__va(base + size);			(*n)++;			crashk_res.start = base;			crashk_res.end = base + size - 1;		}	}	efi_memmap_res.start = ia64_boot_param->efi_memmap;	efi_memmap_res.end = efi_memmap_res.start +		ia64_boot_param->efi_memmap_size;	boot_param_res.start = __pa(ia64_boot_param);	boot_param_res.end = boot_param_res.start +		sizeof(*ia64_boot_param);}#elsestatic inline void __init setup_crashkernel(unsigned long total, int *n){}#endif /** * reserve_memory - setup reserved memory areas * * Setup the reserved memory areas set aside for the boot parameters, * initrd, etc.  There are currently %IA64_MAX_RSVD_REGIONS defined, * see arch/ia64/include/asm/meminit.h if you need to define more. */void __initreserve_memory (void){	int n = 0;	unsigned long total_memory; 	/*	 * none of the entries in this table overlap	 */	rsvd_region[n].start = (unsigned long) ia64_boot_param;	rsvd_region[n].end   = rsvd_region[n].start + sizeof(*ia64_boot_param);	n++; 	rsvd_region[n].start = (unsigned long) __va(ia64_boot_param->efi_memmap);	rsvd_region[n].end   = rsvd_region[n].start + ia64_boot_param->efi_memmap_size;	n++; 	rsvd_region[n].start = (unsigned long) __va(ia64_boot_param->command_line);	rsvd_region[n].end   = (rsvd_region[n].start				+ strlen(__va(ia64_boot_param->command_line)) + 1);	n++; 	rsvd_region[n].start = (unsigned long) ia64_imva((void *)KERNEL_START);	rsvd_region[n].end   = (unsigned long) ia64_imva(_end);	n++; 	n += paravirt_reserve_memory(&rsvd_region[n]); #ifdef CONFIG_BLK_DEV_INITRD	if (ia64_boot_param->initrd_start) {		rsvd_region[n].start = (unsigned long)__va(ia64_boot_param->initrd_start);		rsvd_region[n].end   = rsvd_region[n].start + ia64_boot_param->initrd_size;		n++;	}#endif #ifdef CONFIG_CRASH_DUMP	if (reserve_elfcorehdr(&rsvd_region[n].start,			       &rsvd_region[n].end) == 0)		n++;#endif 	total_memory = efi_memmap_init(&rsvd_region[n].start, &rsvd_region[n].end);	n++; 	setup_crashkernel(total_memory, &n); 	/* end of memory marker */	rsvd_region[n].start = ~0UL;	rsvd_region[n].end   = ~0UL;	n++; 	num_rsvd_regions = n;	BUG_ON(IA64_MAX_RSVD_REGIONS + 1 < n); 	sort_regions(rsvd_region, num_rsvd_regions);	num_rsvd_regions = merge_regions(rsvd_region, num_rsvd_regions);}  /** * find_initrd - get initrd parameters from the boot parameter structure * * Grab the initrd start and end from the boot parameter struct given us by * the boot loader. */void __initfind_initrd (void){#ifdef CONFIG_BLK_DEV_INITRD	if (ia64_boot_param->initrd_start) {		initrd_start = (unsigned long)__va(ia64_boot_param->initrd_start);		initrd_end   = initrd_start+ia64_boot_param->initrd_size; 		printk(KERN_INFO "Initial ramdisk at: 0x%lx (%llu bytes)\n",		       initrd_start, ia64_boot_param->initrd_size);	}#endif} static void __initio_port_init (void){	unsigned long phys_iobase; 	/*	 * Set `iobase' based on the EFI memory map or, failing that, the	 * value firmware left in ar.k0.	 *	 * Note that in ia32 mode, IN/OUT instructions use ar.k0 to compute	 * the port's virtual address, so ia32_load_state() loads it with a	 * user virtual address.  But in ia64 mode, glibc uses the	 * *physical* address in ar.k0 to mmap the appropriate area from	 * /dev/mem, and the inX()/outX() interfaces use MMIO.  In both	 * cases, user-mode can only use the legacy 0-64K I/O port space.	 *	 * ar.k0 is not involved in kernel I/O port accesses, which can use	 * any of the I/O port spaces and are done via MMIO using the	 * virtual mmio_base from the appropriate io_space[].	 */	phys_iobase = efi_get_iobase();	if (!phys_iobase) {		phys_iobase = ia64_get_kr(IA64_KR_IO_BASE);		printk(KERN_INFO "No I/O port range found in EFI memory map, "			"falling back to AR.KR0 (0x%lx)\n", phys_iobase);	}	ia64_iobase = (unsigned long) ioremap(phys_iobase, 0);	ia64_set_kr(IA64_KR_IO_BASE, __pa(ia64_iobase)); 	/* setup legacy IO port space */	io_space[0].mmio_base = ia64_iobase;	io_space[0].sparse = 1;	num_io_spaces = 1;} /** * early_console_setup - setup debugging console * * Consoles started here require little enough setup that we can start using * them very early in the boot process, either right after the machine * vector initialization, or even before if the drivers can detect their hw. * * Returns non-zero if a console couldn't be setup. */static inline int __initearly_console_setup (char *cmdline){	int earlycons = 0; #ifdef CONFIG_SERIAL_SGI_L1_CONSOLE	{		extern int sn_serial_console_early_setup(void);		if (!sn_serial_console_early_setup())			earlycons++;	}#endif#ifdef CONFIG_EFI_PCDP	if (!efi_setup_pcdp_console(cmdline))		earlycons++;#endif	if (!simcons_register())		earlycons++; 	return (earlycons) ? 0 : -1;} static inline voidmark_bsp_online (void){#ifdef CONFIG_SMP	/* If we register an early console, allow CPU 0 to printk */	set_cpu_online(smp_processor_id(), true);#endif} static __initdata int nomca;static __init int setup_nomca(char *s){	nomca = 1;	return 0;}early_param("nomca", setup_nomca); #ifdef CONFIG_CRASH_DUMP

Lines 1–500 of 1070. Load more