x86: seperate funcs from setup_64 to cpu common_64.c (f580366f) · Commits · e / devices / android_kernel_fairphone_FP4

arch/x86/kernel/cpu/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -6,7 +6,7 @@ obj-y := intel_cacheinfo.o addon_cpuid_features.o
	obj-y += proc.o feature_names.o		obj-y += proc.o feature_names.o

	obj-$(CONFIG_X86_32) += common.o bugs.o		obj-$(CONFIG_X86_32) += common.o bugs.o
	obj-$(CONFIG_X86_64) += bugs_64.o		obj-$(CONFIG_X86_64) += common_64.o bugs_64.o
	obj-$(CONFIG_X86_32) += amd.o		obj-$(CONFIG_X86_32) += amd.o
	obj-$(CONFIG_X86_64) += amd_64.o		obj-$(CONFIG_X86_64) += amd_64.o
	obj-$(CONFIG_X86_32) += cyrix.o		obj-$(CONFIG_X86_32) += cyrix.o

arch/x86/kernel/setup_64.c→arch/x86/kernel/cpu/common_64.c

+406 −0

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 1995 Linus Torvalds
	*/

	/*
	* This file handles the architecture-dependent parts of initialization
	*/

	#include <linux/errno.h>
	#include <linux/sched.h>
	#include <linux/kernel.h>
	#include <linux/mm.h>
	#include <linux/stddef.h>
	#include <linux/unistd.h>
	#include <linux/ptrace.h>
	#include <linux/slab.h>
	#include <linux/user.h>
	#include <linux/screen_info.h>
	#include <linux/ioport.h>
	#include <linux/delay.h>
	#include <linux/init.h>		#include <linux/init.h>
	#include <linux/initrd.h>		#include <linux/string.h>
	#include <linux/highmem.h>		#include <linux/delay.h>
	#include <linux/bootmem.h>		#include <linux/smp.h>
	#include <linux/module.h>		#include <linux/module.h>
			#include <linux/percpu.h>
			#include <linux/bootmem.h>
	#include <asm/processor.h>		#include <asm/processor.h>
	#include <linux/console.h>		#include <asm/i387.h>
	#include <linux/seq_file.h>
	#include <linux/crash_dump.h>
	#include <linux/root_dev.h>
	#include <linux/pci.h>
	#include <asm/pci-direct.h>
	#include <linux/efi.h>
	#include <linux/acpi.h>
	#include <linux/kallsyms.h>
	#include <linux/edd.h>
	#include <linux/iscsi_ibft.h>
	#include <linux/mmzone.h>
	#include <linux/kexec.h>
	#include <linux/cpufreq.h>
	#include <linux/dmi.h>
	#include <linux/dma-mapping.h>
	#include <linux/ctype.h>
	#include <linux/sort.h>
	#include <linux/uaccess.h>
	#include <linux/init_ohci1394_dma.h>
	#include <linux/kvm_para.h>

	#include <asm/mtrr.h>
	#include <asm/uaccess.h>
	#include <asm/system.h>
	#include <asm/vsyscall.h>
	#include <asm/io.h>
	#include <asm/smp.h>
	#include <asm/msr.h>		#include <asm/msr.h>
	#include <asm/desc.h>		#include <asm/io.h>
	#include <video/edid.h>
	#include <asm/e820.h>
	#include <asm/mpspec.h>
	#include <asm/dma.h>
	#include <asm/gart.h>
	#include <asm/mpspec.h>
	#include <asm/mmu_context.h>		#include <asm/mmu_context.h>
	#include <asm/proto.h>		#include <asm/mtrr.h>
	#include <asm/setup.h>
	#include <asm/numa.h>
	#include <asm/sections.h>
	#include <asm/dmi.h>
	#include <asm/cacheflush.h>
	#include <asm/mce.h>		#include <asm/mce.h>
	#include <asm/ds.h>
	#include <asm/topology.h>
	#include <asm/trampoline.h>
	#include <asm/pat.h>		#include <asm/pat.h>
			#include <asm/numa.h>
			#ifdef CONFIG_X86_LOCAL_APIC
			#include <asm/mpspec.h>
			#include <asm/apic.h>
	#include <mach_apic.h>		#include <mach_apic.h>
	#ifdef CONFIG_PARAVIRT
	#include <asm/paravirt.h>
	#else
	#define ARCH_SETUP
	#endif		#endif

	/*		#include "cpu.h"
	* Machine setup..
	*/

	struct cpuinfo_x86 boot_cpu_data __read_mostly;
	EXPORT_SYMBOL(boot_cpu_data);

	__u32 cleared_cpu_caps[NCAPINTS] __cpuinitdata;

	unsigned long mmu_cr4_features;

	/* Boot loader ID as an integer, for the benefit of proc_dointvec */
	int bootloader_type;

	unsigned long saved_video_mode;		/* We need valid kernel segments for data and code in long mode too
			* IRET will check the segment types kkeil 2000/10/28
	/*		* Also sysret mandates a special GDT layout
	* Early DMI memory
	*/		*/
	int dmi_alloc_index;		/* The TLS descriptors are currently at a different place compared to i386.
	char dmi_alloc_data[DMI_MAX_DATA];		Hopefully nobody expects them at a fixed place (Wine?) */
			DEFINE_PER_CPU(struct gdt_page, gdt_page) = { .gdt = {
			[GDT_ENTRY_KERNEL32_CS] = { { { 0x0000ffff, 0x00cf9b00 } } },
			[GDT_ENTRY_KERNEL_CS] = { { { 0x0000ffff, 0x00af9b00 } } },
			[GDT_ENTRY_KERNEL_DS] = { { { 0x0000ffff, 0x00cf9300 } } },
			[GDT_ENTRY_DEFAULT_USER32_CS] = { { { 0x0000ffff, 0x00cffb00 } } },
			[GDT_ENTRY_DEFAULT_USER_DS] = { { { 0x0000ffff, 0x00cff300 } } },
			[GDT_ENTRY_DEFAULT_USER_CS] = { { { 0x0000ffff, 0x00affb00 } } },
			} };
			EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);

	/*		__u32 cleared_cpu_caps[NCAPINTS] __cpuinitdata;
	* Setup options
	*/
	struct screen_info screen_info;
	EXPORT_SYMBOL(screen_info);
	struct sys_desc_table_struct {
	unsigned short length;
	unsigned char table[0];
	};

	struct edid_info edid_info;
	EXPORT_SYMBOL_GPL(edid_info);

	extern int root_mountflags;

	static char __initdata command_line[COMMAND_LINE_SIZE];

	static struct resource standard_io_resources[] = {
	{ .name = "dma1", .start = 0x00, .end = 0x1f,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "pic1", .start = 0x20, .end = 0x21,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "timer0", .start = 0x40, .end = 0x43,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "timer1", .start = 0x50, .end = 0x53,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "keyboard", .start = 0x60, .end = 0x60,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "keyboard", .start = 0x64, .end = 0x64,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "dma page reg", .start = 0x80, .end = 0x8f,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "pic2", .start = 0xa0, .end = 0xa1,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "dma2", .start = 0xc0, .end = 0xdf,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO },
	{ .name = "fpu", .start = 0xf0, .end = 0xff,
	.flags = IORESOURCE_BUSY \| IORESOURCE_IO }
	};

	#define IORESOURCE_RAM (IORESOURCE_BUSY \| IORESOURCE_MEM)

	static struct resource data_resource = {
	.name = "Kernel data",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
	};
	static struct resource code_resource = {
	.name = "Kernel code",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
	};
	static struct resource bss_resource = {
	.name = "Kernel bss",
	.start = 0,
	.end = 0,
	.flags = IORESOURCE_RAM,
	};

	static void __init early_cpu_init(void);
	static void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c);

	#ifdef CONFIG_PROC_VMCORE
	/* elfcorehdr= specifies the location of elf core header
	* stored by the crashed kernel. This option will be passed
	* by kexec loader to the capture kernel.
	*/
	static int __init setup_elfcorehdr(char *arg)
	{
	char *end;
	if (!arg)
	return -EINVAL;
	elfcorehdr_addr = memparse(arg, &end);
	return end > arg ? 0 : -EINVAL;
	}
	early_param("elfcorehdr", setup_elfcorehdr);
	#endif

	#ifndef CONFIG_NUMA
	static void __init
	contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
	{
	unsigned long bootmap_size, bootmap;

	bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
	bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size,
	PAGE_SIZE);
	if (bootmap == -1L)
	panic("Cannot find bootmem map of size %ld\n", bootmap_size);
	bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
	e820_register_active_regions(0, start_pfn, end_pfn);
	free_bootmem_with_active_regions(0, end_pfn);
	early_res_to_bootmem(0, end_pfn<<PAGE_SHIFT);
	reserve_bootmem(bootmap, bootmap_size, BOOTMEM_DEFAULT);
	}
	#endif

	#if defined(CONFIG_EDD) \|\| defined(CONFIG_EDD_MODULE)
	struct edd edd;
	#ifdef CONFIG_EDD_MODULE
	EXPORT_SYMBOL(edd);
	#endif
	/**
	* copy_edd() - Copy the BIOS EDD information
	* from boot_params into a safe place.
	*
	*/
	static inline void copy_edd(void)
	{
	memcpy(edd.mbr_signature, boot_params.edd_mbr_sig_buffer,
	sizeof(edd.mbr_signature));
	memcpy(edd.edd_info, boot_params.eddbuf, sizeof(edd.edd_info));
	edd.mbr_signature_nr = boot_params.edd_mbr_sig_buf_entries;
	edd.edd_info_nr = boot_params.eddbuf_entries;
	}
	#else
	static inline void copy_edd(void)
	{
	}
	#endif

	/* Overridden in paravirt.c if CONFIG_PARAVIRT */
	void __attribute__((weak)) __init memory_setup(void)
	{
	machine_specific_memory_setup();
	}

	/* Current gdt points %fs at the "master" per-cpu area: after this,		/* Current gdt points %fs at the "master" per-cpu area: after this,
	* it's on the real one. */		* it's on the real one. */
	@@ -242,235 +51,6 @@ void switch_to_new_gdt(void)
	load_gdt(&gdt_descr);		load_gdt(&gdt_descr);
	}		}

	/*
	* setup_arch - architecture-specific boot-time initializations
	*
	* Note: On x86_64, fixmaps are ready for use even before this is called.
	*/
	void __init setup_arch(char **cmdline_p)
	{
	unsigned i;

	printk(KERN_INFO "Command line: %s\n", boot_command_line);

	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
	screen_info = boot_params.screen_info;
	edid_info = boot_params.edid_info;
	saved_video_mode = boot_params.hdr.vid_mode;
	bootloader_type = boot_params.hdr.type_of_loader;

	#ifdef CONFIG_BLK_DEV_RAM
	rd_image_start = boot_params.hdr.ram_size & RAMDISK_IMAGE_START_MASK;
	rd_prompt = ((boot_params.hdr.ram_size & RAMDISK_PROMPT_FLAG) != 0);
	rd_doload = ((boot_params.hdr.ram_size & RAMDISK_LOAD_FLAG) != 0);
	#endif
	#ifdef CONFIG_EFI
	if (!strncmp((char *)&boot_params.efi_info.efi_loader_signature,
	"EL64", 4)) {
	efi_enabled = 1;
	efi_reserve_early();
	}
	#endif

	ARCH_SETUP

	setup_memory_map();
	copy_edd();

	if (!boot_params.hdr.root_flags)
	root_mountflags &= ~MS_RDONLY;
	init_mm.start_code = (unsigned long) &_text;
	init_mm.end_code = (unsigned long) &_etext;
	init_mm.end_data = (unsigned long) &_edata;
	init_mm.brk = (unsigned long) &_end;

	code_resource.start = virt_to_phys(&_text);
	code_resource.end = virt_to_phys(&_etext)-1;
	data_resource.start = virt_to_phys(&_etext);
	data_resource.end = virt_to_phys(&_edata)-1;
	bss_resource.start = virt_to_phys(&__bss_start);
	bss_resource.end = virt_to_phys(&__bss_stop)-1;

	early_cpu_init();
	early_identify_cpu(&boot_cpu_data);

	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
	*cmdline_p = command_line;

	parse_setup_data();

	parse_early_param();

	if (acpi_mps_check()) {
	disable_apic = 1;
	clear_cpu_cap(&boot_cpu_data, X86_FEATURE_APIC);
	}

	#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
	if (init_ohci1394_dma_early)
	init_ohci1394_dma_on_all_controllers();
	#endif

	finish_e820_parsing();

	/* after parse_early_param, so could debug it */
	insert_resource(&iomem_resource, &code_resource);
	insert_resource(&iomem_resource, &data_resource);
	insert_resource(&iomem_resource, &bss_resource);

	early_gart_iommu_check();

	e820_register_active_regions(0, 0, -1UL);
	/*
	* partially used pages are not usable - thus
	* we are rounding upwards:
	*/
	end_pfn = e820_end_of_ram();

	/* pre allocte 4k for mptable mpc */
	early_reserve_e820_mpc_new();
	/* update e820 for memory not covered by WB MTRRs */
	mtrr_bp_init();
	if (mtrr_trim_uncached_memory(end_pfn)) {
	remove_all_active_ranges();
	e820_register_active_regions(0, 0, -1UL);
	end_pfn = e820_end_of_ram();
	}

	num_physpages = end_pfn;

	check_efer();

	max_pfn_mapped = init_memory_mapping(0, (end_pfn << PAGE_SHIFT));
	if (efi_enabled)
	efi_init();

	vsmp_init();

	dmi_scan_machine();

	io_delay_init();

	#ifdef CONFIG_KVM_CLOCK
	kvmclock_init();
	#endif

	/*
	* Initialize the ACPI boot-time table parser (gets the RSDP and SDT).
	* Call this early for SRAT node setup.
	*/
	acpi_boot_table_init();

	/* How many end-of-memory variables you have, grandma! */
	max_low_pfn = end_pfn;
	max_pfn = end_pfn;
	high_memory = (void )__va(end_pfn PAGE_SIZE - 1) + 1;

	/* Remove active ranges so rediscovery with NUMA-awareness happens */
	remove_all_active_ranges();

	#ifdef CONFIG_ACPI_NUMA
	/*
	* Parse SRAT to discover nodes.
	*/
	acpi_numa_init();
	#endif

	#ifdef CONFIG_NUMA
	numa_initmem_init(0, end_pfn);
	#else
	contig_initmem_init(0, end_pfn);
	#endif

	dma32_reserve_bootmem();

	#ifdef CONFIG_ACPI_SLEEP
	/*
	* Reserve low memory region for sleep support.
	*/
	acpi_reserve_bootmem();
	#endif

	#ifdef CONFIG_X86_MPPARSE
	/*
	* Find and reserve possible boot-time SMP configuration:
	*/
	find_smp_config();
	#endif
	#ifdef CONFIG_BLK_DEV_INITRD
	if (boot_params.hdr.type_of_loader && boot_params.hdr.ramdisk_image) {
	unsigned long ramdisk_image = boot_params.hdr.ramdisk_image;
	unsigned long ramdisk_size = boot_params.hdr.ramdisk_size;
	unsigned long ramdisk_end = ramdisk_image + ramdisk_size;
	unsigned long end_of_mem = end_pfn << PAGE_SHIFT;

	if (ramdisk_end <= end_of_mem) {
	/*
	* don't need to reserve again, already reserved early
	* in x86_64_start_kernel, and early_res_to_bootmem
	* convert that to reserved in bootmem
	*/
	initrd_start = ramdisk_image + PAGE_OFFSET;
	initrd_end = initrd_start+ramdisk_size;
	} else {
	free_bootmem(ramdisk_image, ramdisk_size);
	printk(KERN_ERR "initrd extends beyond end of memory "
	"(0x%08lx > 0x%08lx)\ndisabling initrd\n",
	ramdisk_end, end_of_mem);
	initrd_start = 0;
	}
	}
	#endif
	reserve_crashkernel();

	reserve_ibft_region();

	paging_init();
	map_vsyscall();

	early_quirks();

	/*
	* Read APIC and some other early information from ACPI tables.
	*/
	acpi_boot_init();

	init_cpu_to_node();

	#ifdef CONFIG_X86_MPPARSE
	/*
	* get boot-time SMP configuration:
	*/
	if (smp_found_config)
	get_smp_config();
	#endif
	init_apic_mappings();
	ioapic_init_mappings();

	kvm_guest_init();

	/*
	* We trust e820 completely. No explicit ROM probing in memory.
	*/
	e820_reserve_resources();
	e820_mark_nosave_regions(end_pfn);

	/* request I/O space for devices used on all i[345]86 PCs */
	for (i = 0; i < ARRAY_SIZE(standard_io_resources); i++)
	request_resource(&ioport_resource, &standard_io_resources[i]);

	e820_setup_gap();

	#ifdef CONFIG_VT
	#if defined(CONFIG_VGA_CONSOLE)
	if (!efi_enabled \|\| (efi_mem_type(0xa0000) != EFI_CONVENTIONAL_MEMORY))
	conswitchp = &vga_con;
	#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
	#endif
	#endif
	}

	struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};		struct cpu_dev *cpu_devs[X86_VENDOR_NUM] = {};

	static void __cpuinit default_init(struct cpuinfo_x86 *c)		static void __cpuinit default_init(struct cpuinfo_x86 *c)
	@@ -626,7 +206,9 @@ static void __init early_cpu_support_print(void)
	}		}
	}		}

	static void __init early_cpu_init(void)		static void __cpuinit early_identify_cpu(struct cpuinfo_x86 *c);

			void __init early_cpu_init(void)
	{		{
	struct cpu_vendor_dev *cvdev;		struct cpu_vendor_dev *cvdev;

	@@ -635,6 +217,7 @@ static void __init early_cpu_init(void)
	cvdev++)		cvdev++)
	cpu_devs[cvdev->vendor] = cvdev->cpu_dev;		cpu_devs[cvdev->vendor] = cvdev->cpu_dev;
	early_cpu_support_print();		early_cpu_support_print();
			early_identify_cpu(&boot_cpu_data);
	}		}

	/* Do some early cpuid on the boot CPU to get some parameter that are		/* Do some early cpuid on the boot CPU to get some parameter that are

include/asm-x86/processor.h

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -153,6 +153,7 @@ static inline int hlt_works(int cpu)

	extern void cpu_detect(struct cpuinfo_x86 *c);		extern void cpu_detect(struct cpuinfo_x86 *c);

			extern void early_cpu_init(void);
	extern void identify_cpu(struct cpuinfo_x86 *);		extern void identify_cpu(struct cpuinfo_x86 *);
	extern void identify_boot_cpu(void);		extern void identify_boot_cpu(void);
	extern void identify_secondary_cpu(struct cpuinfo_x86 *);		extern void identify_secondary_cpu(struct cpuinfo_x86 *);