Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit a776878d6cf8a81fa65b29aa9bd6a10a5131e71c

Authored by Linus Torvalds 2011-12-10 06:45:12 +0800

Exists in master and in 6 other branches

Merge branch 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

* 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  x86, efi: Calling __pa() with an ioremap()ed address is invalid
  x86, hpet: Immediately disable HPET timer 1 if rtc irq is masked
  x86/intel_mid: Kconfig select fix
  x86/intel_mid: Fix the Kconfig for MID selection

Showing 8 changed files Inline Diff

arch/x86/Kconfig
arch/x86/include/asm/e820.h
arch/x86/include/asm/efi.h
arch/x86/kernel/e820.c
arch/x86/kernel/hpet.c
arch/x86/kernel/setup.c
arch/x86/platform/efi/efi.c
arch/x86/platform/efi/efi_64.c

arch/x86/Kconfig

Diff comments View file @ a776878

 # Select 32 or 64 bit
 config 64BIT
 	bool "64-bit kernel" if ARCH = "x86"
 	default ARCH = "x86_64"
 	---help---
 	  Say yes to build a 64-bit kernel - formerly known as x86_64
 	  Say no to build a 32-bit kernel - formerly known as i386
 config X86_32
 	def_bool !64BIT
 	select CLKSRC_I8253
 config X86_64
 	def_bool 64BIT
 ### Arch settings
 config X86
 	def_bool y
 	select HAVE_AOUT if X86_32
 	select HAVE_UNSTABLE_SCHED_CLOCK
 	select HAVE_IDE
 	select HAVE_OPROFILE
 	select HAVE_PCSPKR_PLATFORM
 	select HAVE_PERF_EVENTS
 	select HAVE_IRQ_WORK
 	select HAVE_IOREMAP_PROT
 	select HAVE_KPROBES
 	select HAVE_MEMBLOCK
 	select ARCH_WANT_OPTIONAL_GPIOLIB
 	select ARCH_WANT_FRAME_POINTERS
 	select HAVE_DMA_ATTRS
 	select HAVE_KRETPROBES
 	select HAVE_OPTPROBES
 	select HAVE_FTRACE_MCOUNT_RECORD
 	select HAVE_C_RECORDMCOUNT
 	select HAVE_DYNAMIC_FTRACE
 	select HAVE_FUNCTION_TRACER
 	select HAVE_FUNCTION_GRAPH_TRACER
 	select HAVE_FUNCTION_GRAPH_FP_TEST
 	select HAVE_FUNCTION_TRACE_MCOUNT_TEST
 	select HAVE_FTRACE_NMI_ENTER if DYNAMIC_FTRACE
 	select HAVE_SYSCALL_TRACEPOINTS
 	select HAVE_KVM
 	select HAVE_ARCH_KGDB
 	select HAVE_ARCH_TRACEHOOK
 	select HAVE_GENERIC_DMA_COHERENT if X86_32
 	select HAVE_EFFICIENT_UNALIGNED_ACCESS
 	select USER_STACKTRACE_SUPPORT
 	select HAVE_REGS_AND_STACK_ACCESS_API
 	select HAVE_DMA_API_DEBUG
 	select HAVE_KERNEL_GZIP
 	select HAVE_KERNEL_BZIP2
 	select HAVE_KERNEL_LZMA
 	select HAVE_KERNEL_XZ
 	select HAVE_KERNEL_LZO
 	select HAVE_HW_BREAKPOINT
 	select HAVE_MIXED_BREAKPOINTS_REGS
 	select PERF_EVENTS
 	select HAVE_PERF_EVENTS_NMI
 	select ANON_INODES
 	select HAVE_ARCH_KMEMCHECK
 	select HAVE_USER_RETURN_NOTIFIER
 	select HAVE_ARCH_JUMP_LABEL
 	select HAVE_TEXT_POKE_SMP
 	select HAVE_GENERIC_HARDIRQS
 	select HAVE_SPARSE_IRQ
 	select SPARSE_IRQ
 	select GENERIC_FIND_FIRST_BIT
 	select GENERIC_IRQ_PROBE
 	select GENERIC_PENDING_IRQ if SMP
 	select GENERIC_IRQ_SHOW
 	select GENERIC_CLOCKEVENTS_MIN_ADJUST
 	select IRQ_FORCED_THREADING
 	select USE_GENERIC_SMP_HELPERS if SMP
 	select HAVE_BPF_JIT if (X86_64 && NET)
 	select CLKEVT_I8253
 	select ARCH_HAVE_NMI_SAFE_CMPXCHG
 config INSTRUCTION_DECODER
 	def_bool (KPROBES || PERF_EVENTS)
 config OUTPUT_FORMAT
 	string
 	default "elf32-i386" if X86_32
 	default "elf64-x86-64" if X86_64
 config ARCH_DEFCONFIG
 	string
 	default "arch/x86/configs/i386_defconfig" if X86_32
 	default "arch/x86/configs/x86_64_defconfig" if X86_64
 config GENERIC_CMOS_UPDATE
 	def_bool y
 config CLOCKSOURCE_WATCHDOG
 	def_bool y
 config GENERIC_CLOCKEVENTS
 	def_bool y
 config ARCH_CLOCKSOURCE_DATA
 	def_bool y
 	depends on X86_64
 config GENERIC_CLOCKEVENTS_BROADCAST
 	def_bool y
 	depends on X86_64 || (X86_32 && X86_LOCAL_APIC)
 config LOCKDEP_SUPPORT
 	def_bool y
 config STACKTRACE_SUPPORT
 	def_bool y
 config HAVE_LATENCYTOP_SUPPORT
 	def_bool y
 config MMU
 	def_bool y
 config ZONE_DMA
 	bool "DMA memory allocation support" if EXPERT
 	default y
 	help
 	  DMA memory allocation support allows devices with less than 32-bit
 	  addressing to allocate within the first 16MB of address space.
 	  Disable if no such devices will be used.
 	  If unsure, say Y.
 config SBUS
 	bool
 config NEED_DMA_MAP_STATE
        def_bool (X86_64 || INTEL_IOMMU || DMA_API_DEBUG)
 config NEED_SG_DMA_LENGTH
 	def_bool y
 config GENERIC_ISA_DMA
 	def_bool ISA_DMA_API
 config GENERIC_IOMAP
 	def_bool y
 config GENERIC_BUG
 	def_bool y
 	depends on BUG
 	select GENERIC_BUG_RELATIVE_POINTERS if X86_64
 config GENERIC_BUG_RELATIVE_POINTERS
 	bool
 config GENERIC_HWEIGHT
 	def_bool y
 config GENERIC_GPIO
 	bool
 config ARCH_MAY_HAVE_PC_FDC
 	def_bool ISA_DMA_API
 config RWSEM_GENERIC_SPINLOCK
 	def_bool !X86_XADD
 config RWSEM_XCHGADD_ALGORITHM
 	def_bool X86_XADD
 config ARCH_HAS_CPU_IDLE_WAIT
 	def_bool y
 config GENERIC_CALIBRATE_DELAY
 	def_bool y
 config GENERIC_TIME_VSYSCALL
 	bool
 	default X86_64
 config ARCH_HAS_CPU_RELAX
 	def_bool y
 config ARCH_HAS_DEFAULT_IDLE
 	def_bool y
 config ARCH_HAS_CACHE_LINE_SIZE
 	def_bool y
 config HAVE_SETUP_PER_CPU_AREA
 	def_bool y
 config NEED_PER_CPU_EMBED_FIRST_CHUNK
 	def_bool y
 config NEED_PER_CPU_PAGE_FIRST_CHUNK
 	def_bool y
 config ARCH_HIBERNATION_POSSIBLE
 	def_bool y
 config ARCH_SUSPEND_POSSIBLE
 	def_bool y
 config ZONE_DMA32
 	bool
 	default X86_64
 config ARCH_POPULATES_NODE_MAP
 	def_bool y
 config AUDIT_ARCH
 	bool
 	default X86_64
 config ARCH_SUPPORTS_OPTIMIZED_INLINING
 	def_bool y
 config ARCH_SUPPORTS_DEBUG_PAGEALLOC
 	def_bool y
 config HAVE_INTEL_TXT
 	def_bool y
 	depends on EXPERIMENTAL && INTEL_IOMMU && ACPI
 config X86_32_SMP
 	def_bool y
 	depends on X86_32 && SMP
 config X86_64_SMP
 	def_bool y
 	depends on X86_64 && SMP
 config X86_HT
 	def_bool y
 	depends on SMP
 config X86_32_LAZY_GS
 	def_bool y
 	depends on X86_32 && !CC_STACKPROTECTOR
 config ARCH_HWEIGHT_CFLAGS
 	string
 	default "-fcall-saved-ecx -fcall-saved-edx" if X86_32
 	default "-fcall-saved-rdi -fcall-saved-rsi -fcall-saved-rdx -fcall-saved-rcx -fcall-saved-r8 -fcall-saved-r9 -fcall-saved-r10 -fcall-saved-r11" if X86_64
 config KTIME_SCALAR
 	def_bool X86_32
 config ARCH_CPU_PROBE_RELEASE
 	def_bool y
 	depends on HOTPLUG_CPU
 source "init/Kconfig"
 source "kernel/Kconfig.freezer"
 menu "Processor type and features"
 source "kernel/time/Kconfig"
 config SMP
 	bool "Symmetric multi-processing support"
 	---help---
 	  This enables support for systems with more than one CPU. If you have
 	  a system with only one CPU, like most personal computers, say N. If
 	  you have a system with more than one CPU, say Y.
 	  If you say N here, the kernel will run on single and multiprocessor
 	  machines, but will use only one CPU of a multiprocessor machine. If
 	  you say Y here, the kernel will run on many, but not all,
 	  singleprocessor machines. On a singleprocessor machine, the kernel
 	  will run faster if you say N here.
 	  Note that if you say Y here and choose architecture "586" or
 	  "Pentium" under "Processor family", the kernel will not work on 486
 	  architectures. Similarly, multiprocessor kernels for the "PPro"
 	  architecture may not work on all Pentium based boards.
 	  People using multiprocessor machines who say Y here should also say
 	  Y to "Enhanced Real Time Clock Support", below. The "Advanced Power
 	  Management" code will be disabled if you say Y here.
 	  See also <file:Documentation/x86/i386/IO-APIC.txt>,
 	  <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO available at
 	  <http://www.tldp.org/docs.html#howto>.
 	  If you don't know what to do here, say N.
 config X86_X2APIC
 	bool "Support x2apic"
 	depends on X86_LOCAL_APIC && X86_64 && IRQ_REMAP
 	---help---
 	  This enables x2apic support on CPUs that have this feature.
 	  This allows 32-bit apic IDs (so it can support very large systems),
 	  and accesses the local apic via MSRs not via mmio.
 	  If you don't know what to do here, say N.
 config X86_MPPARSE
 	bool "Enable MPS table" if ACPI
 	default y
 	depends on X86_LOCAL_APIC
 	---help---
 	  For old smp systems that do not have proper acpi support. Newer systems
 	  (esp with 64bit cpus) with acpi support, MADT and DSDT will override it
 config X86_BIGSMP
 	bool "Support for big SMP systems with more than 8 CPUs"
 	depends on X86_32 && SMP
 	---help---
 	  This option is needed for the systems that have more than 8 CPUs
 if X86_32
 config X86_EXTENDED_PLATFORM
 	bool "Support for extended (non-PC) x86 platforms"
 	default y
 	---help---
 	  If you disable this option then the kernel will only support
 	  standard PC platforms. (which covers the vast majority of
 	  systems out there.)
 	  If you enable this option then you'll be able to select support
 	  for the following (non-PC) 32 bit x86 platforms:
 		AMD Elan
 		NUMAQ (IBM/Sequent)
 		RDC R-321x SoC
 		SGI 320/540 (Visual Workstation)
 		Summit/EXA (IBM x440)
 		Unisys ES7000 IA32 series
 		Moorestown MID devices
 	  If you have one of these systems, or if you want to build a
 	  generic distribution kernel, say Y here - otherwise say N.
 endif
 if X86_64
 config X86_EXTENDED_PLATFORM
 	bool "Support for extended (non-PC) x86 platforms"
 	default y
 	---help---
 	  If you disable this option then the kernel will only support
 	  standard PC platforms. (which covers the vast majority of
 	  systems out there.)
 	  If you enable this option then you'll be able to select support
 	  for the following (non-PC) 64 bit x86 platforms:
 		ScaleMP vSMP
 		SGI Ultraviolet
 	  If you have one of these systems, or if you want to build a
 	  generic distribution kernel, say Y here - otherwise say N.
 endif
 # This is an alphabetically sorted list of 64 bit extended platforms
 # Please maintain the alphabetic order if and when there are additions
 config X86_VSMP
 	bool "ScaleMP vSMP"
 	select PARAVIRT_GUEST
 	select PARAVIRT
 	depends on X86_64 && PCI
 	depends on X86_EXTENDED_PLATFORM
 	---help---
 	  Support for ScaleMP vSMP systems.  Say 'Y' here if this kernel is
 	  supposed to run on these EM64T-based machines.  Only choose this option
 	  if you have one of these machines.
 config X86_UV
 	bool "SGI Ultraviolet"
 	depends on X86_64
 	depends on X86_EXTENDED_PLATFORM
 	depends on NUMA
 	depends on X86_X2APIC
 	---help---
 	  This option is needed in order to support SGI Ultraviolet systems.
 	  If you don't have one of these, you should say N here.
 # Following is an alphabetically sorted list of 32 bit extended platforms
 # Please maintain the alphabetic order if and when there are additions
 config X86_INTEL_CE
 	bool "CE4100 TV platform"
 	depends on PCI
 	depends on PCI_GODIRECT
 	depends on X86_32
 	depends on X86_EXTENDED_PLATFORM
 	select X86_REBOOTFIXUPS
 	select OF
 	select OF_EARLY_FLATTREE
 	---help---
 	  Select for the Intel CE media processor (CE4100) SOC.
 	  This option compiles in support for the CE4100 SOC for settop
 	  boxes and media devices.
-config X86_INTEL_MID
+config X86_WANT_INTEL_MID
 	bool "Intel MID platform support"
 	depends on X86_32
 	depends on X86_EXTENDED_PLATFORM
 	---help---
 	  Select to build a kernel capable of supporting Intel MID platform
 	  systems which do not have the PCI legacy interfaces (Moorestown,
 	  Medfield). If you are building for a PC class system say N here.
-if X86_INTEL_MID
+if X86_WANT_INTEL_MID
+config X86_INTEL_MID
+	bool
 config X86_MRST
        bool "Moorestown MID platform"
 	depends on PCI
 	depends on PCI_GOANY
 	depends on X86_IO_APIC
 	select APB_TIMER
 	select I2C
 	select SPI
 	select INTEL_SCU_IPC
 	select X86_PLATFORM_DEVICES
+	select X86_INTEL_MID
 	---help---
 	  Moorestown is Intel's Low Power Intel Architecture (LPIA) based Moblin
 	  Internet Device(MID) platform. Moorestown consists of two chips:
 	  Lincroft (CPU core, graphics, and memory controller) and Langwell IOH.
 	  Unlike standard x86 PCs, Moorestown does not have many legacy devices
 	  nor standard legacy replacement devices/features. e.g. Moorestown does
 	  not contain i8259, i8254, HPET, legacy BIOS, most of the io ports.
 endif
 config X86_RDC321X
 	bool "RDC R-321x SoC"
 	depends on X86_32
 	depends on X86_EXTENDED_PLATFORM
 	select M486
 	select X86_REBOOTFIXUPS
 	---help---
 	  This option is needed for RDC R-321x system-on-chip, also known
 	  as R-8610-(G).
 	  If you don't have one of these chips, you should say N here.
 config X86_32_NON_STANDARD
 	bool "Support non-standard 32-bit SMP architectures"
 	depends on X86_32 && SMP
 	depends on X86_EXTENDED_PLATFORM
 	---help---
 	  This option compiles in the NUMAQ, Summit, bigsmp, ES7000, default
 	  subarchitectures.  It is intended for a generic binary kernel.
 	  if you select them all, kernel will probe it one by one. and will
 	  fallback to default.
 # Alphabetically sorted list of Non standard 32 bit platforms
 config X86_NUMAQ
 	bool "NUMAQ (IBM/Sequent)"
 	depends on X86_32_NON_STANDARD
 	depends on PCI
 	select NUMA
 	select X86_MPPARSE
 	---help---
 	  This option is used for getting Linux to run on a NUMAQ (IBM/Sequent)
 	  NUMA multiquad box. This changes the way that processors are
 	  bootstrapped, and uses Clustered Logical APIC addressing mode instead
 	  of Flat Logical.  You will need a new lynxer.elf file to flash your
 	  firmware with - send email to <Martin.Bligh@us.ibm.com>.
 config X86_SUPPORTS_MEMORY_FAILURE
 	def_bool y
 	# MCE code calls memory_failure():
 	depends on X86_MCE
 	# On 32-bit this adds too big of NODES_SHIFT and we run out of page flags:
 	depends on !X86_NUMAQ
 	# On 32-bit SPARSEMEM adds too big of SECTIONS_WIDTH:
 	depends on X86_64 || !SPARSEMEM
 	select ARCH_SUPPORTS_MEMORY_FAILURE
 config X86_VISWS
 	bool "SGI 320/540 (Visual Workstation)"
 	depends on X86_32 && PCI && X86_MPPARSE && PCI_GODIRECT
 	depends on X86_32_NON_STANDARD
 	---help---
 	  The SGI Visual Workstation series is an IA32-based workstation
 	  based on SGI systems chips with some legacy PC hardware attached.
 	  Say Y here to create a kernel to run on the SGI 320 or 540.
 	  A kernel compiled for the Visual Workstation will run on general
 	  PCs as well. See <file:Documentation/sgi-visws.txt> for details.
 config X86_SUMMIT
 	bool "Summit/EXA (IBM x440)"
 	depends on X86_32_NON_STANDARD
 	---help---
 	  This option is needed for IBM systems that use the Summit/EXA chipset.
 	  In particular, it is needed for the x440.
 config X86_ES7000
 	bool "Unisys ES7000 IA32 series"
 	depends on X86_32_NON_STANDARD && X86_BIGSMP
 	---help---
 	  Support for Unisys ES7000 systems.  Say 'Y' here if this kernel is
 	  supposed to run on an IA32-based Unisys ES7000 system.
 config X86_32_IRIS
 	tristate "Eurobraille/Iris poweroff module"
 	depends on X86_32
 	---help---
 	  The Iris machines from EuroBraille do not have APM or ACPI support
 	  to shut themselves down properly.  A special I/O sequence is
 	  needed to do so, which is what this module does at
 	  kernel shutdown.
 	  This is only for Iris machines from EuroBraille.
 	  If unused, say N.
 config SCHED_OMIT_FRAME_POINTER
 	def_bool y
 	prompt "Single-depth WCHAN output"
 	depends on X86
 	---help---
 	  Calculate simpler /proc/<PID>/wchan values. If this option
 	  is disabled then wchan values will recurse back to the
 	  caller function. This provides more accurate wchan values,
 	  at the expense of slightly more scheduling overhead.
 	  If in doubt, say "Y".
 menuconfig PARAVIRT_GUEST
 	bool "Paravirtualized guest support"
 	---help---
 	  Say Y here to get to see options related to running Linux under
 	  various hypervisors.  This option alone does not add any kernel code.
 	  If you say N, all options in this submenu will be skipped and disabled.
 if PARAVIRT_GUEST
 config PARAVIRT_TIME_ACCOUNTING
 	bool "Paravirtual steal time accounting"
 	select PARAVIRT
 	default n
 	---help---
 	  Select this option to enable fine granularity task steal time
 	  accounting. Time spent executing other tasks in parallel with
 	  the current vCPU is discounted from the vCPU power. To account for
 	  that, there can be a small performance impact.
 	  If in doubt, say N here.
 source "arch/x86/xen/Kconfig"
 config KVM_CLOCK
 	bool "KVM paravirtualized clock"
 	select PARAVIRT
 	select PARAVIRT_CLOCK
 	---help---
 	  Turning on this option will allow you to run a paravirtualized clock
 	  when running over the KVM hypervisor. Instead of relying on a PIT
 	  (or probably other) emulation by the underlying device model, the host
 	  provides the guest with timing infrastructure such as time of day, and
 	  system time
 config KVM_GUEST
 	bool "KVM Guest support"
 	select PARAVIRT
 	---help---
 	  This option enables various optimizations for running under the KVM
 	  hypervisor.
 source "arch/x86/lguest/Kconfig"
 config PARAVIRT
 	bool "Enable paravirtualization code"
 	---help---
 	  This changes the kernel so it can modify itself when it is run
 	  under a hypervisor, potentially improving performance significantly
 	  over full virtualization.  However, when run without a hypervisor
 	  the kernel is theoretically slower and slightly larger.
 config PARAVIRT_SPINLOCKS
 	bool "Paravirtualization layer for spinlocks"
 	depends on PARAVIRT && SMP && EXPERIMENTAL
 	---help---
 	  Paravirtualized spinlocks allow a pvops backend to replace the
 	  spinlock implementation with something virtualization-friendly
 	  (for example, block the virtual CPU rather than spinning).
 	  Unfortunately the downside is an up to 5% performance hit on
 	  native kernels, with various workloads.
 	  If you are unsure how to answer this question, answer N.
 config PARAVIRT_CLOCK
 	bool
 endif
 config PARAVIRT_DEBUG
 	bool "paravirt-ops debugging"
 	depends on PARAVIRT && DEBUG_KERNEL
 	---help---
 	  Enable to debug paravirt_ops internals.  Specifically, BUG if
 	  a paravirt_op is missing when it is called.
 config NO_BOOTMEM
 	def_bool y
 config MEMTEST
 	bool "Memtest"
 	---help---
 	  This option adds a kernel parameter 'memtest', which allows memtest
 	  to be set.
 	        memtest=0, mean disabled; -- default
 	        memtest=1, mean do 1 test pattern;
 	        ...
 	        memtest=4, mean do 4 test patterns.
 	  If you are unsure how to answer this question, answer N.
 config X86_SUMMIT_NUMA
 	def_bool y
 	depends on X86_32 && NUMA && X86_32_NON_STANDARD
 config X86_CYCLONE_TIMER
 	def_bool y
 	depends on X86_32_NON_STANDARD
 source "arch/x86/Kconfig.cpu"
 config HPET_TIMER
 	def_bool X86_64
 	prompt "HPET Timer Support" if X86_32
 	---help---
 	  Use the IA-PC HPET (High Precision Event Timer) to manage
 	  time in preference to the PIT and RTC, if a HPET is
 	  present.
 	  HPET is the next generation timer replacing legacy 8254s.
 	  The HPET provides a stable time base on SMP
 	  systems, unlike the TSC, but it is more expensive to access,
 	  as it is off-chip.  You can find the HPET spec at
 	  <http://www.intel.com/hardwaredesign/hpetspec_1.pdf>.
 	  You can safely choose Y here.  However, HPET will only be
 	  activated if the platform and the BIOS support this feature.
 	  Otherwise the 8254 will be used for timing services.
 	  Choose N to continue using the legacy 8254 timer.
 config HPET_EMULATE_RTC
 	def_bool y
 	depends on HPET_TIMER && (RTC=y || RTC=m || RTC_DRV_CMOS=m || RTC_DRV_CMOS=y)
 config APB_TIMER
        def_bool y if MRST
        prompt "Langwell APB Timer Support" if X86_MRST
        select DW_APB_TIMER
        help
          APB timer is the replacement for 8254, HPET on X86 MID platforms.
          The APBT provides a stable time base on SMP
          systems, unlike the TSC, but it is more expensive to access,
          as it is off-chip. APB timers are always running regardless of CPU
          C states, they are used as per CPU clockevent device when possible.
 # Mark as expert because too many people got it wrong.
 # The code disables itself when not needed.
 config DMI
 	default y
 	bool "Enable DMI scanning" if EXPERT
 	---help---
 	  Enabled scanning of DMI to identify machine quirks. Say Y
 	  here unless you have verified that your setup is not
 	  affected by entries in the DMI blacklist. Required by PNP
 	  BIOS code.
 config GART_IOMMU
 	bool "GART IOMMU support" if EXPERT
 	default y
 	select SWIOTLB
 	depends on X86_64 && PCI && AMD_NB
 	---help---
 	  Support for full DMA access of devices with 32bit memory access only
 	  on systems with more than 3GB. This is usually needed for USB,
 	  sound, many IDE/SATA chipsets and some other devices.
 	  Provides a driver for the AMD Athlon64/Opteron/Turion/Sempron GART
 	  based hardware IOMMU and a software bounce buffer based IOMMU used
 	  on Intel systems and as fallback.
 	  The code is only active when needed (enough memory and limited
 	  device) unless CONFIG_IOMMU_DEBUG or iommu=force is specified
 	  too.
 config CALGARY_IOMMU
 	bool "IBM Calgary IOMMU support"
 	select SWIOTLB
 	depends on X86_64 && PCI && EXPERIMENTAL
 	---help---
 	  Support for hardware IOMMUs in IBM's xSeries x366 and x460
 	  systems. Needed to run systems with more than 3GB of memory
 	  properly with 32-bit PCI devices that do not support DAC
 	  (Double Address Cycle). Calgary also supports bus level
 	  isolation, where all DMAs pass through the IOMMU.  This
 	  prevents them from going anywhere except their intended
 	  destination. This catches hard-to-find kernel bugs and
 	  mis-behaving drivers and devices that do not use the DMA-API
 	  properly to set up their DMA buffers.  The IOMMU can be
 	  turned off at boot time with the iommu=off parameter.
 	  Normally the kernel will make the right choice by itself.
 	  If unsure, say Y.
 config CALGARY_IOMMU_ENABLED_BY_DEFAULT
 	def_bool y
 	prompt "Should Calgary be enabled by default?"
 	depends on CALGARY_IOMMU
 	---help---
 	  Should Calgary be enabled by default? if you choose 'y', Calgary
 	  will be used (if it exists). If you choose 'n', Calgary will not be
 	  used even if it exists. If you choose 'n' and would like to use
 	  Calgary anyway, pass 'iommu=calgary' on the kernel command line.
 	  If unsure, say Y.
 # need this always selected by IOMMU for the VIA workaround
 config SWIOTLB
 	def_bool y if X86_64
 	---help---
 	  Support for software bounce buffers used on x86-64 systems
 	  which don't have a hardware IOMMU (e.g. the current generation
 	  of Intel's x86-64 CPUs). Using this PCI devices which can only
 	  access 32-bits of memory can be used on systems with more than
 	  3 GB of memory. If unsure, say Y.
 config IOMMU_HELPER
 	def_bool (CALGARY_IOMMU || GART_IOMMU || SWIOTLB || AMD_IOMMU)
 config MAXSMP
 	bool "Enable Maximum number of SMP Processors and NUMA Nodes"
 	depends on X86_64 && SMP && DEBUG_KERNEL && EXPERIMENTAL
 	select CPUMASK_OFFSTACK
 	---help---
 	  Enable maximum number of CPUS and NUMA Nodes for this architecture.
 	  If unsure, say N.
 config NR_CPUS
 	int "Maximum number of CPUs" if SMP && !MAXSMP
 	range 2 8 if SMP && X86_32 && !X86_BIGSMP
 	range 2 512 if SMP && !MAXSMP
 	default "1" if !SMP
 	default "4096" if MAXSMP
 	default "32" if SMP && (X86_NUMAQ || X86_SUMMIT || X86_BIGSMP || X86_ES7000)
 	default "8" if SMP
 	---help---
 	  This allows you to specify the maximum number of CPUs which this
 	  kernel will support.  The maximum supported value is 512 and the
 	  minimum value which makes sense is 2.
 	  This is purely to save memory - each supported CPU adds
 	  approximately eight kilobytes to the kernel image.
 config SCHED_SMT
 	bool "SMT (Hyperthreading) scheduler support"
 	depends on X86_HT
 	---help---
 	  SMT scheduler support improves the CPU scheduler's decision making
 	  when dealing with Intel Pentium 4 chips with HyperThreading at a
 	  cost of slightly increased overhead in some places. If unsure say
 	  N here.
 config SCHED_MC
 	def_bool y
 	prompt "Multi-core scheduler support"
 	depends on X86_HT
 	---help---
 	  Multi-core scheduler support improves the CPU scheduler's decision
 	  making when dealing with multi-core CPU chips at a cost of slightly
 	  increased overhead in some places. If unsure say N here.
 config IRQ_TIME_ACCOUNTING
 	bool "Fine granularity task level IRQ time accounting"
 	default n
 	---help---
 	  Select this option to enable fine granularity task irq time
 	  accounting. This is done by reading a timestamp on each
 	  transitions between softirq and hardirq state, so there can be a
 	  small performance impact.
 	  If in doubt, say N here.
 source "kernel/Kconfig.preempt"
 config X86_UP_APIC
 	bool "Local APIC support on uniprocessors"
 	depends on X86_32 && !SMP && !X86_32_NON_STANDARD
 	---help---
 	  A local APIC (Advanced Programmable Interrupt Controller) is an
 	  integrated interrupt controller in the CPU. If you have a single-CPU
 	  system which has a processor with a local APIC, you can say Y here to
 	  enable and use it. If you say Y here even though your machine doesn't
 	  have a local APIC, then the kernel will still run with no slowdown at
 	  all. The local APIC supports CPU-generated self-interrupts (timer,
 	  performance counters), and the NMI watchdog which detects hard
 	  lockups.
 config X86_UP_IOAPIC
 	bool "IO-APIC support on uniprocessors"
 	depends on X86_UP_APIC
 	---help---
 	  An IO-APIC (I/O Advanced Programmable Interrupt Controller) is an
 	  SMP-capable replacement for PC-style interrupt controllers. Most
 	  SMP systems and many recent uniprocessor systems have one.
 	  If you have a single-CPU system with an IO-APIC, you can say Y here
 	  to use it. If you say Y here even though your machine doesn't have
 	  an IO-APIC, then the kernel will still run with no slowdown at all.
 config X86_LOCAL_APIC
 	def_bool y
 	depends on X86_64 || SMP || X86_32_NON_STANDARD || X86_UP_APIC
 config X86_IO_APIC
 	def_bool y
 	depends on X86_64 || SMP || X86_32_NON_STANDARD || X86_UP_IOAPIC
 config X86_VISWS_APIC
 	def_bool y
 	depends on X86_32 && X86_VISWS
 config X86_REROUTE_FOR_BROKEN_BOOT_IRQS
 	bool "Reroute for broken boot IRQs"
 	depends on X86_IO_APIC
 	---help---
 	  This option enables a workaround that fixes a source of
 	  spurious interrupts. This is recommended when threaded
 	  interrupt handling is used on systems where the generation of
 	  superfluous "boot interrupts" cannot be disabled.
 	  Some chipsets generate a legacy INTx "boot IRQ" when the IRQ
 	  entry in the chipset's IO-APIC is masked (as, e.g. the RT
 	  kernel does during interrupt handling). On chipsets where this
 	  boot IRQ generation cannot be disabled, this workaround keeps
 	  the original IRQ line masked so that only the equivalent "boot
 	  IRQ" is delivered to the CPUs. The workaround also tells the
 	  kernel to set up the IRQ handler on the boot IRQ line. In this
 	  way only one interrupt is delivered to the kernel. Otherwise
 	  the spurious second interrupt may cause the kernel to bring
 	  down (vital) interrupt lines.
 	  Only affects "broken" chipsets. Interrupt sharing may be
 	  increased on these systems.
 config X86_MCE
 	bool "Machine Check / overheating reporting"
 	---help---
 	  Machine Check support allows the processor to notify the
 	  kernel if it detects a problem (e.g. overheating, data corruption).
 	  The action the kernel takes depends on the severity of the problem,
 	  ranging from warning messages to halting the machine.
 config X86_MCE_INTEL
 	def_bool y
 	prompt "Intel MCE features"
 	depends on X86_MCE && X86_LOCAL_APIC
 	---help---
 	   Additional support for intel specific MCE features such as
 	   the thermal monitor.
 config X86_MCE_AMD
 	def_bool y
 	prompt "AMD MCE features"
 	depends on X86_MCE && X86_LOCAL_APIC
 	---help---
 	   Additional support for AMD specific MCE features such as
 	   the DRAM Error Threshold.
 config X86_ANCIENT_MCE
 	bool "Support for old Pentium 5 / WinChip machine checks"
 	depends on X86_32 && X86_MCE
 	---help---
 	  Include support for machine check handling on old Pentium 5 or WinChip
 	  systems. These typically need to be enabled explicitely on the command
 	  line.
 config X86_MCE_THRESHOLD
 	depends on X86_MCE_AMD || X86_MCE_INTEL
 	def_bool y
 config X86_MCE_INJECT
 	depends on X86_MCE
 	tristate "Machine check injector support"
 	---help---
 	  Provide support for injecting machine checks for testing purposes.
 	  If you don't know what a machine check is and you don't do kernel
 	  QA it is safe to say n.
 config X86_THERMAL_VECTOR
 	def_bool y
 	depends on X86_MCE_INTEL
 config VM86
 	bool "Enable VM86 support" if EXPERT
 	default y
 	depends on X86_32
 	---help---
 	  This option is required by programs like DOSEMU to run 16-bit legacy
 	  code on X86 processors. It also may be needed by software like
 	  XFree86 to initialize some video cards via BIOS. Disabling this
 	  option saves about 6k.
 config TOSHIBA
 	tristate "Toshiba Laptop support"
 	depends on X86_32
 	---help---
 	  This adds a driver to safely access the System Management Mode of
 	  the CPU on Toshiba portables with a genuine Toshiba BIOS. It does
 	  not work on models with a Phoenix BIOS. The System Management Mode
 	  is used to set the BIOS and power saving options on Toshiba portables.
 	  For information on utilities to make use of this driver see the
 	  Toshiba Linux utilities web site at:
 	  <http://www.buzzard.org.uk/toshiba/>.
 	  Say Y if you intend to run this kernel on a Toshiba portable.
 	  Say N otherwise.
 config I8K
 	tristate "Dell laptop support"
 	select HWMON
 	---help---
 	  This adds a driver to safely access the System Management Mode
 	  of the CPU on the Dell Inspiron 8000. The System Management Mode
 	  is used to read cpu temperature and cooling fan status and to
 	  control the fans on the I8K portables.
 	  This driver has been tested only on the Inspiron 8000 but it may
 	  also work with other Dell laptops. You can force loading on other
 	  models by passing the parameter `force=1' to the module. Use at
 	  your own risk.
 	  For information on utilities to make use of this driver see the
 	  I8K Linux utilities web site at:
 	  <http://people.debian.org/~dz/i8k/>
 	  Say Y if you intend to run this kernel on a Dell Inspiron 8000.
 	  Say N otherwise.
 config X86_REBOOTFIXUPS
 	bool "Enable X86 board specific fixups for reboot"
 	depends on X86_32
 	---help---
 	  This enables chipset and/or board specific fixups to be done
 	  in order to get reboot to work correctly. This is only needed on
 	  some combinations of hardware and BIOS. The symptom, for which
 	  this config is intended, is when reboot ends with a stalled/hung
 	  system.
 	  Currently, the only fixup is for the Geode machines using
 	  CS5530A and CS5536 chipsets and the RDC R-321x SoC.
 	  Say Y if you want to enable the fixup. Currently, it's safe to
 	  enable this option even if you don't need it.
 	  Say N otherwise.
 config MICROCODE
 	tristate "/dev/cpu/microcode - microcode support"
 	select FW_LOADER
 	---help---
 	  If you say Y here, you will be able to update the microcode on
 	  certain Intel and AMD processors. The Intel support is for the
 	  IA32 family, e.g. Pentium Pro, Pentium II, Pentium III,
 	  Pentium 4, Xeon etc. The AMD support is for family 0x10 and
 	  0x11 processors, e.g. Opteron, Phenom and Turion 64 Ultra.
 	  You will obviously need the actual microcode binary data itself
 	  which is not shipped with the Linux kernel.
 	  This option selects the general module only, you need to select
 	  at least one vendor specific module as well.
 	  To compile this driver as a module, choose M here: the
 	  module will be called microcode.
 config MICROCODE_INTEL
 	bool "Intel microcode patch loading support"
 	depends on MICROCODE
 	default MICROCODE
 	select FW_LOADER
 	---help---
 	  This options enables microcode patch loading support for Intel
 	  processors.
 	  For latest news and information on obtaining all the required
 	  Intel ingredients for this driver, check:
 	  <http://www.urbanmyth.org/microcode/>.
 config MICROCODE_AMD
 	bool "AMD microcode patch loading support"
 	depends on MICROCODE
 	select FW_LOADER
 	---help---
 	  If you select this option, microcode patch loading support for AMD
 	  processors will be enabled.
 config MICROCODE_OLD_INTERFACE
 	def_bool y
 	depends on MICROCODE
 config X86_MSR
 	tristate "/dev/cpu/*/msr - Model-specific register support"
 	---help---
 	  This device gives privileged processes access to the x86
 	  Model-Specific Registers (MSRs).  It is a character device with
 	  major 202 and minors 0 to 31 for /dev/cpu/0/msr to /dev/cpu/31/msr.
 	  MSR accesses are directed to a specific CPU on multi-processor
 	  systems.
 config X86_CPUID
 	tristate "/dev/cpu/*/cpuid - CPU information support"
 	---help---
 	  This device gives processes access to the x86 CPUID instruction to
 	  be executed on a specific processor.  It is a character device
 	  with major 203 and minors 0 to 31 for /dev/cpu/0/cpuid to
 	  /dev/cpu/31/cpuid.
 choice
 	prompt "High Memory Support"
 	default HIGHMEM64G if X86_NUMAQ
 	default HIGHMEM4G
 	depends on X86_32
 config NOHIGHMEM
 	bool "off"
 	depends on !X86_NUMAQ
 	---help---
 	  Linux can use up to 64 Gigabytes of physical memory on x86 systems.
 	  However, the address space of 32-bit x86 processors is only 4
 	  Gigabytes large. That means that, if you have a large amount of
 	  physical memory, not all of it can be "permanently mapped" by the
 	  kernel. The physical memory that's not permanently mapped is called
 	  "high memory".
 	  If you are compiling a kernel which will never run on a machine with
 	  more than 1 Gigabyte total physical RAM, answer "off" here (default
 	  choice and suitable for most users). This will result in a "3GB/1GB"
 	  split: 3GB are mapped so that each process sees a 3GB virtual memory
 	  space and the remaining part of the 4GB virtual memory space is used
 	  by the kernel to permanently map as much physical memory as
 	  possible.
 	  If the machine has between 1 and 4 Gigabytes physical RAM, then
 	  answer "4GB" here.
 	  If more than 4 Gigabytes is used then answer "64GB" here. This
 	  selection turns Intel PAE (Physical Address Extension) mode on.
 	  PAE implements 3-level paging on IA32 processors. PAE is fully
 	  supported by Linux, PAE mode is implemented on all recent Intel
 	  processors (Pentium Pro and better). NOTE: If you say "64GB" here,
 	  then the kernel will not boot on CPUs that don't support PAE!
 	  The actual amount of total physical memory will either be
 	  auto detected or can be forced by using a kernel command line option
 	  such as "mem=256M". (Try "man bootparam" or see the documentation of
 	  your boot loader (lilo or loadlin) about how to pass options to the
 	  kernel at boot time.)
 	  If unsure, say "off".
 config HIGHMEM4G
 	bool "4GB"
 	depends on !X86_NUMAQ
 	---help---
 	  Select this if you have a 32-bit processor and between 1 and 4
 	  gigabytes of physical RAM.
 config HIGHMEM64G
 	bool "64GB"
 	depends on !M386 && !M486
 	select X86_PAE
 	---help---
 	  Select this if you have a 32-bit processor and more than 4
 	  gigabytes of physical RAM.
 endchoice
 choice
 	depends on EXPERIMENTAL
 	prompt "Memory split" if EXPERT
 	default VMSPLIT_3G
 	depends on X86_32
 	---help---
 	  Select the desired split between kernel and user memory.
 	  If the address range available to the kernel is less than the
 	  physical memory installed, the remaining memory will be available
 	  as "high memory". Accessing high memory is a little more costly
 	  than low memory, as it needs to be mapped into the kernel first.
 	  Note that increasing the kernel address space limits the range
 	  available to user programs, making the address space there
 	  tighter.  Selecting anything other than the default 3G/1G split
 	  will also likely make your kernel incompatible with binary-only
 	  kernel modules.
 	  If you are not absolutely sure what you are doing, leave this
 	  option alone!
 	config VMSPLIT_3G
 		bool "3G/1G user/kernel split"
 	config VMSPLIT_3G_OPT
 		depends on !X86_PAE
 		bool "3G/1G user/kernel split (for full 1G low memory)"
 	config VMSPLIT_2G
 		bool "2G/2G user/kernel split"
 	config VMSPLIT_2G_OPT
 		depends on !X86_PAE
 		bool "2G/2G user/kernel split (for full 2G low memory)"
 	config VMSPLIT_1G
 		bool "1G/3G user/kernel split"
 endchoice
 config PAGE_OFFSET
 	hex
 	default 0xB0000000 if VMSPLIT_3G_OPT
 	default 0x80000000 if VMSPLIT_2G
 	default 0x78000000 if VMSPLIT_2G_OPT
 	default 0x40000000 if VMSPLIT_1G
 	default 0xC0000000
 	depends on X86_32
 config HIGHMEM
 	def_bool y
 	depends on X86_32 && (HIGHMEM64G || HIGHMEM4G)
 config X86_PAE
 	bool "PAE (Physical Address Extension) Support"
 	depends on X86_32 && !HIGHMEM4G
 	---help---
 	  PAE is required for NX support, and furthermore enables
 	  larger swapspace support for non-overcommit purposes. It
 	  has the cost of more pagetable lookup overhead, and also
 	  consumes more pagetable space per process.
 config ARCH_PHYS_ADDR_T_64BIT
 	def_bool X86_64 || X86_PAE
 config ARCH_DMA_ADDR_T_64BIT
 	def_bool X86_64 || HIGHMEM64G
 config DIRECT_GBPAGES
 	bool "Enable 1GB pages for kernel pagetables" if EXPERT
 	default y
 	depends on X86_64
 	---help---
 	  Allow the kernel linear mapping to use 1GB pages on CPUs that
 	  support it. This can improve the kernel's performance a tiny bit by
 	  reducing TLB pressure. If in doubt, say "Y".
 # Common NUMA Features
 config NUMA
 	bool "Numa Memory Allocation and Scheduler Support"
 	depends on SMP
 	depends on X86_64 || (X86_32 && HIGHMEM64G && (X86_NUMAQ || X86_BIGSMP || X86_SUMMIT && ACPI) && EXPERIMENTAL)
 	default y if (X86_NUMAQ || X86_SUMMIT || X86_BIGSMP)
 	---help---
 	  Enable NUMA (Non Uniform Memory Access) support.
 	  The kernel will try to allocate memory used by a CPU on the
 	  local memory controller of the CPU and add some more
 	  NUMA awareness to the kernel.
 	  For 64-bit this is recommended if the system is Intel Core i7
 	  (or later), AMD Opteron, or EM64T NUMA.
 	  For 32-bit this is only needed on (rare) 32-bit-only platforms
 	  that support NUMA topologies, such as NUMAQ / Summit, or if you
 	  boot a 32-bit kernel on a 64-bit NUMA platform.
 	  Otherwise, you should say N.
 comment "NUMA (Summit) requires SMP, 64GB highmem support, ACPI"
 	depends on X86_32 && X86_SUMMIT && (!HIGHMEM64G || !ACPI)
 config AMD_NUMA
 	def_bool y
 	prompt "Old style AMD Opteron NUMA detection"
 	depends on X86_64 && NUMA && PCI
 	---help---
 	  Enable AMD NUMA node topology detection.  You should say Y here if
 	  you have a multi processor AMD system. This uses an old method to
 	  read the NUMA configuration directly from the builtin Northbridge
 	  of Opteron. It is recommended to use X86_64_ACPI_NUMA instead,
 	  which also takes priority if both are compiled in.
 config X86_64_ACPI_NUMA
 	def_bool y
 	prompt "ACPI NUMA detection"
 	depends on X86_64 && NUMA && ACPI && PCI
 	select ACPI_NUMA
 	---help---
 	  Enable ACPI SRAT based node topology detection.
 # Some NUMA nodes have memory ranges that span
 # other nodes.  Even though a pfn is valid and
 # between a node's start and end pfns, it may not
 # reside on that node.  See memmap_init_zone()
 # for details.
 config NODES_SPAN_OTHER_NODES
 	def_bool y
 	depends on X86_64_ACPI_NUMA
 config NUMA_EMU
 	bool "NUMA emulation"
 	depends on NUMA
 	---help---
 	  Enable NUMA emulation. A flat machine will be split
 	  into virtual nodes when booted with "numa=fake=N", where N is the
 	  number of nodes. This is only useful for debugging.
 config NODES_SHIFT
 	int "Maximum NUMA Nodes (as a power of 2)" if !MAXSMP
 	range 1 10
 	default "10" if MAXSMP
 	default "6" if X86_64
 	default "4" if X86_NUMAQ
 	default "3"
 	depends on NEED_MULTIPLE_NODES
 	---help---
 	  Specify the maximum number of NUMA Nodes available on the target
 	  system.  Increases memory reserved to accommodate various tables.
 config HAVE_ARCH_BOOTMEM
 	def_bool y
 	depends on X86_32 && NUMA
 config HAVE_ARCH_ALLOC_REMAP
 	def_bool y
 	depends on X86_32 && NUMA
 config ARCH_HAVE_MEMORY_PRESENT
 	def_bool y
 	depends on X86_32 && DISCONTIGMEM
 config NEED_NODE_MEMMAP_SIZE
 	def_bool y
 	depends on X86_32 && (DISCONTIGMEM || SPARSEMEM)
 config ARCH_FLATMEM_ENABLE
 	def_bool y
 	depends on X86_32 && !NUMA
 config ARCH_DISCONTIGMEM_ENABLE
 	def_bool y
 	depends on NUMA && X86_32
 config ARCH_DISCONTIGMEM_DEFAULT
 	def_bool y
 	depends on NUMA && X86_32
 config ARCH_SPARSEMEM_ENABLE
 	def_bool y
 	depends on X86_64 || NUMA || (EXPERIMENTAL && X86_32) || X86_32_NON_STANDARD
 	select SPARSEMEM_STATIC if X86_32
 	select SPARSEMEM_VMEMMAP_ENABLE if X86_64
 config ARCH_SPARSEMEM_DEFAULT
 	def_bool y
 	depends on X86_64
 config ARCH_SELECT_MEMORY_MODEL
 	def_bool y
 	depends on ARCH_SPARSEMEM_ENABLE
 config ARCH_MEMORY_PROBE
 	def_bool X86_64
 	depends on MEMORY_HOTPLUG
 config ARCH_PROC_KCORE_TEXT
 	def_bool y
 	depends on X86_64 && PROC_KCORE
 config ILLEGAL_POINTER_VALUE
        hex
        default 0 if X86_32
        default 0xdead000000000000 if X86_64
 source "mm/Kconfig"
 config HIGHPTE
 	bool "Allocate 3rd-level pagetables from highmem"
 	depends on HIGHMEM
 	---help---
 	  The VM uses one page table entry for each page of physical memory.
 	  For systems with a lot of RAM, this can be wasteful of precious
 	  low memory.  Setting this option will put user-space page table
 	  entries in high memory.
 config X86_CHECK_BIOS_CORRUPTION
 	bool "Check for low memory corruption"
 	---help---
 	  Periodically check for memory corruption in low memory, which
 	  is suspected to be caused by BIOS.  Even when enabled in the
 	  configuration, it is disabled at runtime.  Enable it by
 	  setting "memory_corruption_check=1" on the kernel command
 	  line.  By default it scans the low 64k of memory every 60
 	  seconds; see the memory_corruption_check_size and
 	  memory_corruption_check_period parameters in
 	  Documentation/kernel-parameters.txt to adjust this.
 	  When enabled with the default parameters, this option has
 	  almost no overhead, as it reserves a relatively small amount
 	  of memory and scans it infrequently.  It both detects corruption
 	  and prevents it from affecting the running system.
 	  It is, however, intended as a diagnostic tool; if repeatable
 	  BIOS-originated corruption always affects the same memory,
 	  you can use memmap= to prevent the kernel from using that
 	  memory.
 config X86_BOOTPARAM_MEMORY_CORRUPTION_CHECK
 	bool "Set the default setting of memory_corruption_check"
 	depends on X86_CHECK_BIOS_CORRUPTION
 	default y
 	---help---
 	  Set whether the default state of memory_corruption_check is
 	  on or off.
 config X86_RESERVE_LOW
 	int "Amount of low memory, in kilobytes, to reserve for the BIOS"
 	default 64
 	range 4 640
 	---help---
 	  Specify the amount of low memory to reserve for the BIOS.
 	  The first page contains BIOS data structures that the kernel
 	  must not use, so that page must always be reserved.
 	  By default we reserve the first 64K of physical RAM, as a
 	  number of BIOSes are known to corrupt that memory range
 	  during events such as suspend/resume or monitor cable
 	  insertion, so it must not be used by the kernel.
 	  You can set this to 4 if you are absolutely sure that you
 	  trust the BIOS to get all its memory reservations and usages
 	  right.  If you know your BIOS have problems beyond the
 	  default 64K area, you can set this to 640 to avoid using the
 	  entire low memory range.
 	  If you have doubts about the BIOS (e.g. suspend/resume does
 	  not work or there's kernel crashes after certain hardware
 	  hotplug events) then you might want to enable
 	  X86_CHECK_BIOS_CORRUPTION=y to allow the kernel to check
 	  typical corruption patterns.
 	  Leave this to the default value of 64 if you are unsure.
 config MATH_EMULATION
 	bool
 	prompt "Math emulation" if X86_32
 	---help---
 	  Linux can emulate a math coprocessor (used for floating point
 	  operations) if you don't have one. 486DX and Pentium processors have
 	  a math coprocessor built in, 486SX and 386 do not, unless you added
 	  a 487DX or 387, respectively. (The messages during boot time can
 	  give you some hints here ["man dmesg"].) Everyone needs either a
 	  coprocessor or this emulation.
 	  If you don't have a math coprocessor, you need to say Y here; if you
 	  say Y here even though you have a coprocessor, the coprocessor will
 	  be used nevertheless. (This behavior can be changed with the kernel
 	  command line option "no387", which comes handy if your coprocessor
 	  is broken. Try "man bootparam" or see the documentation of your boot
 	  loader (lilo or loadlin) about how to pass options to the kernel at
 	  boot time.) This means that it is a good idea to say Y here if you
 	  intend to use this kernel on different machines.
 	  More information about the internals of the Linux math coprocessor
 	  emulation can be found in <file:arch/x86/math-emu/README>.
 	  If you are not sure, say Y; apart from resulting in a 66 KB bigger
 	  kernel, it won't hurt.
 config MTRR
 	def_bool y
 	prompt "MTRR (Memory Type Range Register) support" if EXPERT
 	---help---
 	  On Intel P6 family processors (Pentium Pro, Pentium II and later)
 	  the Memory Type Range Registers (MTRRs) may be used to control
 	  processor access to memory ranges. This is most useful if you have
 	  a video (VGA) card on a PCI or AGP bus. Enabling write-combining
 	  allows bus write transfers to be combined into a larger transfer
 	  before bursting over the PCI/AGP bus. This can increase performance
 	  of image write operations 2.5 times or more. Saying Y here creates a
 	  /proc/mtrr file which may be used to manipulate your processor's
 	  MTRRs. Typically the X server should use this.
 	  This code has a reasonably generic interface so that similar
 	  control registers on other processors can be easily supported
 	  as well:
 	  The Cyrix 6x86, 6x86MX and M II processors have Address Range
 	  Registers (ARRs) which provide a similar functionality to MTRRs. For
 	  these, the ARRs are used to emulate the MTRRs.
 	  The AMD K6-2 (stepping 8 and above) and K6-3 processors have two
 	  MTRRs. The Centaur C6 (WinChip) has 8 MCRs, allowing
 	  write-combining. All of these processors are supported by this code
 	  and it makes sense to say Y here if you have one of them.
 	  Saying Y here also fixes a problem with buggy SMP BIOSes which only
 	  set the MTRRs for the boot CPU and not for the secondary CPUs. This
 	  can lead to all sorts of problems, so it's good to say Y here.
 	  You can safely say Y even if your machine doesn't have MTRRs, you'll
 	  just add about 9 KB to your kernel.
 	  See <file:Documentation/x86/mtrr.txt> for more information.
 config MTRR_SANITIZER
 	def_bool y
 	prompt "MTRR cleanup support"
 	depends on MTRR
 	---help---
 	  Convert MTRR layout from continuous to discrete, so X drivers can
 	  add writeback entries.
 	  Can be disabled with disable_mtrr_cleanup on the kernel command line.
 	  The largest mtrr entry size for a continuous block can be set with
 	  mtrr_chunk_size.
 	  If unsure, say Y.
 config MTRR_SANITIZER_ENABLE_DEFAULT
 	int "MTRR cleanup enable value (0-1)"
 	range 0 1
 	default "0"
 	depends on MTRR_SANITIZER
 	---help---
 	  Enable mtrr cleanup default value
 config MTRR_SANITIZER_SPARE_REG_NR_DEFAULT
 	int "MTRR cleanup spare reg num (0-7)"
 	range 0 7
 	default "1"
 	depends on MTRR_SANITIZER
 	---help---
 	  mtrr cleanup spare entries default, it can be changed via
 	  mtrr_spare_reg_nr=N on the kernel command line.
 config X86_PAT
 	def_bool y
 	prompt "x86 PAT support" if EXPERT
 	depends on MTRR
 	---help---
 	  Use PAT attributes to setup page level cache control.
 	  PATs are the modern equivalents of MTRRs and are much more
 	  flexible than MTRRs.
 	  Say N here if you see bootup problems (boot crash, boot hang,
 	  spontaneous reboots) or a non-working video driver.
 	  If unsure, say Y.
 config ARCH_USES_PG_UNCACHED
 	def_bool y
 	depends on X86_PAT
 config ARCH_RANDOM
 	def_bool y
 	prompt "x86 architectural random number generator" if EXPERT
 	---help---
 	  Enable the x86 architectural RDRAND instruction
 	  (Intel Bull Mountain technology) to generate random numbers.
 	  If supported, this is a high bandwidth, cryptographically
 	  secure hardware random number generator.
 config EFI
 	bool "EFI runtime service support"
 	depends on ACPI
 	---help---
 	  This enables the kernel to use EFI runtime services that are
 	  available (such as the EFI variable services).
 	  This option is only useful on systems that have EFI firmware.
 	  In addition, you should use the latest ELILO loader available
 	  at <http://elilo.sourceforge.net> in order to take advantage
 	  of EFI runtime services. However, even with this option, the
 	  resultant kernel should continue to boot on existing non-EFI
 	  platforms.
 config SECCOMP
 	def_bool y
 	prompt "Enable seccomp to safely compute untrusted bytecode"
 	---help---
 	  This kernel feature is useful for number crunching applications
 	  that may need to compute untrusted bytecode during their
 	  execution. By using pipes or other transports made available to
 	  the process as file descriptors supporting the read/write
 	  syscalls, it's possible to isolate those applications in
 	  their own address space using seccomp. Once seccomp is
 	  enabled via prctl(PR_SET_SECCOMP), it cannot be disabled
 	  and the task is only allowed to execute a few safe syscalls
 	  defined by each seccomp mode.
 	  If unsure, say Y. Only embedded should say N here.
 config CC_STACKPROTECTOR
 	bool "Enable -fstack-protector buffer overflow detection (EXPERIMENTAL)"
 	---help---
 	  This option turns on the -fstack-protector GCC feature. This
 	  feature puts, at the beginning of functions, a canary value on
 	  the stack just before the return address, and validates
 	  the value just before actually returning.  Stack based buffer
 	  overflows (that need to overwrite this return address) now also
 	  overwrite the canary, which gets detected and the attack is then
 	  neutralized via a kernel panic.
 	  This feature requires gcc version 4.2 or above, or a distribution
 	  gcc with the feature backported. Older versions are automatically
 	  detected and for those versions, this configuration option is
 	  ignored. (and a warning is printed during bootup)
 source kernel/Kconfig.hz
 config KEXEC
 	bool "kexec system call"
 	---help---
 	  kexec is a system call that implements the ability to shutdown your
 	  current kernel, and to start another kernel.  It is like a reboot
 	  but it is independent of the system firmware.   And like a reboot
 	  you can start any kernel with it, not just Linux.
 	  The name comes from the similarity to the exec system call.
 	  It is an ongoing process to be certain the hardware in a machine
 	  is properly shutdown, so do not be surprised if this code does not
 	  initially work for you.  It may help to enable device hotplugging
 	  support.  As of this writing the exact hardware interface is
 	  strongly in flux, so no good recommendation can be made.
 config CRASH_DUMP
 	bool "kernel crash dumps"
 	depends on X86_64 || (X86_32 && HIGHMEM)
 	---help---
 	  Generate crash dump after being started by kexec.
 	  This should be normally only set in special crash dump kernels
 	  which are loaded in the main kernel with kexec-tools into
 	  a specially reserved region and then later executed after
 	  a crash by kdump/kexec. The crash dump kernel must be compiled
 	  to a memory address not used by the main kernel or BIOS using
 	  PHYSICAL_START, or it must be built as a relocatable image
 	  (CONFIG_RELOCATABLE=y).
 	  For more details see Documentation/kdump/kdump.txt
 config KEXEC_JUMP
 	bool "kexec jump (EXPERIMENTAL)"
 	depends on EXPERIMENTAL
 	depends on KEXEC && HIBERNATION
 	---help---
 	  Jump between original kernel and kexeced kernel and invoke
 	  code in physical address mode via KEXEC
 config PHYSICAL_START
 	hex "Physical address where the kernel is loaded" if (EXPERT || CRASH_DUMP)
 	default "0x1000000"
 	---help---
 	  This gives the physical address where the kernel is loaded.
 	  If kernel is a not relocatable (CONFIG_RELOCATABLE=n) then
 	  bzImage will decompress itself to above physical address and
 	  run from there. Otherwise, bzImage will run from the address where
 	  it has been loaded by the boot loader and will ignore above physical
 	  address.
 	  In normal kdump cases one does not have to set/change this option
 	  as now bzImage can be compiled as a completely relocatable image
 	  (CONFIG_RELOCATABLE=y) and be used to load and run from a different
 	  address. This option is mainly useful for the folks who don't want
 	  to use a bzImage for capturing the crash dump and want to use a
 	  vmlinux instead. vmlinux is not relocatable hence a kernel needs
 	  to be specifically compiled to run from a specific memory area
 	  (normally a reserved region) and this option comes handy.
 	  So if you are using bzImage for capturing the crash dump,
 	  leave the value here unchanged to 0x1000000 and set
 	  CONFIG_RELOCATABLE=y.  Otherwise if you plan to use vmlinux
 	  for capturing the crash dump change this value to start of
 	  the reserved region.  In other words, it can be set based on
 	  the "X" value as specified in the "crashkernel=YM@XM"
 	  command line boot parameter passed to the panic-ed
 	  kernel. Please take a look at Documentation/kdump/kdump.txt
 	  for more details about crash dumps.
 	  Usage of bzImage for capturing the crash dump is recommended as
 	  one does not have to build two kernels. Same kernel can be used
 	  as production kernel and capture kernel. Above option should have
 	  gone away after relocatable bzImage support is introduced. But it
 	  is present because there are users out there who continue to use
 	  vmlinux for dump capture. This option should go away down the
 	  line.
 	  Don't change this unless you know what you are doing.
 config RELOCATABLE
 	bool "Build a relocatable kernel"
 	default y
 	---help---
 	  This builds a kernel image that retains relocation information
 	  so it can be loaded someplace besides the default 1MB.
 	  The relocations tend to make the kernel binary about 10% larger,
 	  but are discarded at runtime.
 	  One use is for the kexec on panic case where the recovery kernel
 	  must live at a different physical address than the primary
 	  kernel.
 	  Note: If CONFIG_RELOCATABLE=y, then the kernel runs from the address
 	  it has been loaded at and the compile time physical address
 	  (CONFIG_PHYSICAL_START) is ignored.
 # Relocation on x86-32 needs some additional build support
 config X86_NEED_RELOCS
 	def_bool y
 	depends on X86_32 && RELOCATABLE
 config PHYSICAL_ALIGN
 	hex "Alignment value to which kernel should be aligned" if X86_32
 	default "0x1000000"
 	range 0x2000 0x1000000
 	---help---
 	  This value puts the alignment restrictions on physical address
 	  where kernel is loaded and run from. Kernel is compiled for an
 	  address which meets above alignment restriction.
 	  If bootloader loads the kernel at a non-aligned address and
 	  CONFIG_RELOCATABLE is set, kernel will move itself to nearest
 	  address aligned to above value and run from there.
 	  If bootloader loads the kernel at a non-aligned address and
 	  CONFIG_RELOCATABLE is not set, kernel will ignore the run time
 	  load address and decompress itself to the address it has been
 	  compiled for and run from there. The address for which kernel is
 	  compiled already meets above alignment restrictions. Hence the
 	  end result is that kernel runs from a physical address meeting
 	  above alignment restrictions.
 	  Don't change this unless you know what you are doing.
 config HOTPLUG_CPU
 	bool "Support for hot-pluggable CPUs"
 	depends on SMP && HOTPLUG
 	---help---
 	  Say Y here to allow turning CPUs off and on. CPUs can be
 	  controlled through /sys/devices/system/cpu.
 	  ( Note: power management support will enable this option
 	    automatically on SMP systems. )
 	  Say N if you want to disable CPU hotplug.
 config COMPAT_VDSO
 	def_bool y
 	prompt "Compat VDSO support"
 	depends on X86_32 || IA32_EMULATION
 	---help---
 	  Map the 32-bit VDSO to the predictable old-style address too.
 	  Say N here if you are running a sufficiently recent glibc
 	  version (2.3.3 or later), to remove the high-mapped
 	  VDSO mapping and to exclusively use the randomized VDSO.
 	  If unsure, say Y.
 config CMDLINE_BOOL
 	bool "Built-in kernel command line"
 	---help---
 	  Allow for specifying boot arguments to the kernel at
 	  build time.  On some systems (e.g. embedded ones), it is
 	  necessary or convenient to provide some or all of the
 	  kernel boot arguments with the kernel itself (that is,
 	  to not rely on the boot loader to provide them.)
 	  To compile command line arguments into the kernel,
 	  set this option to 'Y', then fill in the
 	  the boot arguments in CONFIG_CMDLINE.
 	  Systems with fully functional boot loaders (i.e. non-embedded)
 	  should leave this option set to 'N'.
 config CMDLINE
 	string "Built-in kernel command string"
 	depends on CMDLINE_BOOL
 	default ""
 	---help---
 	  Enter arguments here that should be compiled into the kernel
 	  image and used at boot time.  If the boot loader provides a
 	  command line at boot time, it is appended to this string to
 	  form the full kernel command line, when the system boots.
 	  However, you can use the CONFIG_CMDLINE_OVERRIDE option to
 	  change this behavior.
 	  In most cases, the command line (whether built-in or provided
 	  by the boot loader) should specify the device for the root
 	  file system.
 config CMDLINE_OVERRIDE
 	bool "Built-in command line overrides boot loader arguments"
 	depends on CMDLINE_BOOL
 	---help---
 	  Set this option to 'Y' to have the kernel ignore the boot loader
 	  command line, and use ONLY the built-in command line.
 	  This is used to work around broken boot loaders.  This should
 	  be set to 'N' under normal conditions.
 endmenu
 config ARCH_ENABLE_MEMORY_HOTPLUG
 	def_bool y
 	depends on X86_64 || (X86_32 && HIGHMEM)
 config ARCH_ENABLE_MEMORY_HOTREMOVE
 	def_bool y
 	depends on MEMORY_HOTPLUG
 config USE_PERCPU_NUMA_NODE_ID
 	def_bool y
 	depends on NUMA
 menu "Power management and ACPI options"
 config ARCH_HIBERNATION_HEADER
 	def_bool y
 	depends on X86_64 && HIBERNATION
 source "kernel/power/Kconfig"
 source "drivers/acpi/Kconfig"
 source "drivers/sfi/Kconfig"
 config X86_APM_BOOT
 	def_bool y
 	depends on APM || APM_MODULE
 menuconfig APM
 	tristate "APM (Advanced Power Management) BIOS support"
 	depends on X86_32 && PM_SLEEP
 	---help---
 	  APM is a BIOS specification for saving power using several different
 	  techniques. This is mostly useful for battery powered laptops with
 	  APM compliant BIOSes. If you say Y here, the system time will be
 	  reset after a RESUME operation, the /proc/apm device will provide
 	  battery status information, and user-space programs will receive
 	  notification of APM "events" (e.g. battery status change).
 	  If you select "Y" here, you can disable actual use of the APM
 	  BIOS by passing the "apm=off" option to the kernel at boot time.
 	  Note that the APM support is almost completely disabled for
 	  machines with more than one CPU.
 	  In order to use APM, you will need supporting software. For location
 	  and more information, read <file:Documentation/power/apm-acpi.txt>
 	  and the Battery Powered Linux mini-HOWTO, available from
 	  <http://www.tldp.org/docs.html#howto>.
 	  This driver does not spin down disk drives (see the hdparm(8)
 	  manpage ("man 8 hdparm") for that), and it doesn't turn off
 	  VESA-compliant "green" monitors.
 	  This driver does not support the TI 4000M TravelMate and the ACER
 	  486/DX4/75 because they don't have compliant BIOSes. Many "green"
 	  desktop machines also don't have compliant BIOSes, and this driver
 	  may cause those machines to panic during the boot phase.
 	  Generally, if you don't have a battery in your machine, there isn't
 	  much point in using this driver and you should say N. If you get
 	  random kernel OOPSes or reboots that don't seem to be related to
 	  anything, try disabling/enabling this option (or disabling/enabling
 	  APM in your BIOS).
 	  Some other things you should try when experiencing seemingly random,
 	  "weird" problems:
 	  1) make sure that you have enough swap space and that it is
 	  enabled.
 	  2) pass the "no-hlt" option to the kernel
 	  3) switch on floating point emulation in the kernel and pass
 	  the "no387" option to the kernel
 	  4) pass the "floppy=nodma" option to the kernel
 	  5) pass the "mem=4M" option to the kernel (thereby disabling
 	  all but the first 4 MB of RAM)
 	  6) make sure that the CPU is not over clocked.
 	  7) read the sig11 FAQ at <http://www.bitwizard.nl/sig11/>
 	  8) disable the cache from your BIOS settings
 	  9) install a fan for the video card or exchange video RAM
 	  10) install a better fan for the CPU
 	  11) exchange RAM chips
 	  12) exchange the motherboard.
 	  To compile this driver as a module, choose M here: the
 	  module will be called apm.
 if APM
 config APM_IGNORE_USER_SUSPEND
 	bool "Ignore USER SUSPEND"
 	---help---
 	  This option will ignore USER SUSPEND requests. On machines with a
 	  compliant APM BIOS, you want to say N. However, on the NEC Versa M
 	  series notebooks, it is necessary to say Y because of a BIOS bug.
 config APM_DO_ENABLE
 	bool "Enable PM at boot time"
 	---help---
 	  Enable APM features at boot time. From page 36 of the APM BIOS
 	  specification: "When disabled, the APM BIOS does not automatically
 	  power manage devices, enter the Standby State, enter the Suspend
 	  State, or take power saving steps in response to CPU Idle calls."
 	  This driver will make CPU Idle calls when Linux is idle (unless this
 	  feature is turned off -- see "Do CPU IDLE calls", below). This
 	  should always save battery power, but more complicated APM features
 	  will be dependent on your BIOS implementation. You may need to turn
 	  this option off if your computer hangs at boot time when using APM
 	  support, or if it beeps continuously instead of suspending. Turn
 	  this off if you have a NEC UltraLite Versa 33/C or a Toshiba
 	  T400CDT. This is off by default since most machines do fine without
 	  this feature.
 config APM_CPU_IDLE
 	bool "Make CPU Idle calls when idle"
 	---help---
 	  Enable calls to APM CPU Idle/CPU Busy inside the kernel's idle loop.
 	  On some machines, this can activate improved power savings, such as
 	  a slowed CPU clock rate, when the machine is idle. These idle calls
 	  are made after the idle loop has run for some length of time (e.g.,
 	  333 mS). On some machines, this will cause a hang at boot time or
 	  whenever the CPU becomes idle. (On machines with more than one CPU,
 	  this option does nothing.)
 config APM_DISPLAY_BLANK
 	bool "Enable console blanking using APM"
 	---help---
 	  Enable console blanking using the APM. Some laptops can use this to
 	  turn off the LCD backlight when the screen blanker of the Linux
 	  virtual console blanks the screen. Note that this is only used by
 	  the virtual console screen blanker, and won't turn off the backlight
 	  when using the X Window system. This also doesn't have anything to
 	  do with your VESA-compliant power-saving monitor. Further, this
 	  option doesn't work for all laptops -- it might not turn off your
 	  backlight at all, or it might print a lot of errors to the console,
 	  especially if you are using gpm.
 config APM_ALLOW_INTS
 	bool "Allow interrupts during APM BIOS calls"
 	---help---
 	  Normally we disable external interrupts while we are making calls to
 	  the APM BIOS as a measure to lessen the effects of a badly behaving
 	  BIOS implementation.  The BIOS should reenable interrupts if it
 	  needs to.  Unfortunately, some BIOSes do not -- especially those in
 	  many of the newer IBM Thinkpads.  If you experience hangs when you
 	  suspend, try setting this to Y.  Otherwise, say N.
 endif # APM
 source "drivers/cpufreq/Kconfig"
 source "drivers/cpuidle/Kconfig"
 source "drivers/idle/Kconfig"
 endmenu
 menu "Bus options (PCI etc.)"
 config PCI
 	bool "PCI support"
 	default y
 	select ARCH_SUPPORTS_MSI if (X86_LOCAL_APIC && X86_IO_APIC)
 	---help---
 	  Find out whether you have a PCI motherboard. PCI is the name of a
 	  bus system, i.e. the way the CPU talks to the other stuff inside
 	  your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
 	  VESA. If you have PCI, say Y, otherwise N.
 choice
 	prompt "PCI access mode"
 	depends on X86_32 && PCI
 	default PCI_GOANY
 	---help---
 	  On PCI systems, the BIOS can be used to detect the PCI devices and
 	  determine their configuration. However, some old PCI motherboards
 	  have BIOS bugs and may crash if this is done. Also, some embedded
 	  PCI-based systems don't have any BIOS at all. Linux can also try to
 	  detect the PCI hardware directly without using the BIOS.
 	  With this option, you can specify how Linux should detect the
 	  PCI devices. If you choose "BIOS", the BIOS will be used,
 	  if you choose "Direct", the BIOS won't be used, and if you
 	  choose "MMConfig", then PCI Express MMCONFIG will be used.
 	  If you choose "Any", the kernel will try MMCONFIG, then the
 	  direct access method and falls back to the BIOS if that doesn't
 	  work. If unsure, go with the default, which is "Any".
 config PCI_GOBIOS
 	bool "BIOS"
 config PCI_GOMMCONFIG
 	bool "MMConfig"
 config PCI_GODIRECT
 	bool "Direct"
 config PCI_GOOLPC
 	bool "OLPC XO-1"
 	depends on OLPC
 config PCI_GOANY
 	bool "Any"
 endchoice
 config PCI_BIOS
 	def_bool y
 	depends on X86_32 && PCI && (PCI_GOBIOS || PCI_GOANY)
 # x86-64 doesn't support PCI BIOS access from long mode so always go direct.
 config PCI_DIRECT
 	def_bool y
 	depends on PCI && (X86_64 || (PCI_GODIRECT || PCI_GOANY || PCI_GOOLPC || PCI_GOMMCONFIG))
 config PCI_MMCONFIG
 	def_bool y
 	depends on X86_32 && PCI && (ACPI || SFI) && (PCI_GOMMCONFIG || PCI_GOANY)
 config PCI_OLPC
 	def_bool y
 	depends on PCI && OLPC && (PCI_GOOLPC || PCI_GOANY)
 config PCI_XEN
 	def_bool y
 	depends on PCI && XEN
 	select SWIOTLB_XEN
 config PCI_DOMAINS
 	def_bool y
 	depends on PCI
 config PCI_MMCONFIG
 	bool "Support mmconfig PCI config space access"
 	depends on X86_64 && PCI && ACPI
 config PCI_CNB20LE_QUIRK
 	bool "Read CNB20LE Host Bridge Windows" if EXPERT
 	default n
 	depends on PCI && EXPERIMENTAL
 	help
 	  Read the PCI windows out of the CNB20LE host bridge. This allows
 	  PCI hotplug to work on systems with the CNB20LE chipset which do
 	  not have ACPI.
 	  There's no public spec for this chipset, and this functionality
 	  is known to be incomplete.
 	  You should say N unless you know you need this.
 source "drivers/pci/pcie/Kconfig"
 source "drivers/pci/Kconfig"
 # x86_64 have no ISA slots, but can have ISA-style DMA.
 config ISA_DMA_API
 	bool "ISA-style DMA support" if (X86_64 && EXPERT)
 	default y
 	help
 	  Enables ISA-style DMA support for devices requiring such controllers.
 	  If unsure, say Y.
 if X86_32
 config ISA
 	bool "ISA support"
 	---help---
 	  Find out whether you have ISA slots on your motherboard.  ISA is the
 	  name of a bus system, i.e. the way the CPU talks to the other stuff
 	  inside your box.  Other bus systems are PCI, EISA, MicroChannel
 	  (MCA) or VESA.  ISA is an older system, now being displaced by PCI;
 	  newer boards don't support it.  If you have ISA, say Y, otherwise N.
 config EISA
 	bool "EISA support"
 	depends on ISA
 	---help---
 	  The Extended Industry Standard Architecture (EISA) bus was
 	  developed as an open alternative to the IBM MicroChannel bus.
 	  The EISA bus provided some of the features of the IBM MicroChannel
 	  bus while maintaining backward compatibility with cards made for
 	  the older ISA bus.  The EISA bus saw limited use between 1988 and
 	  1995 when it was made obsolete by the PCI bus.
 	  Say Y here if you are building a kernel for an EISA-based machine.
 	  Otherwise, say N.
 source "drivers/eisa/Kconfig"
 config MCA
 	bool "MCA support"
 	---help---
 	  MicroChannel Architecture is found in some IBM PS/2 machines and
 	  laptops.  It is a bus system similar to PCI or ISA. See
 	  <file:Documentation/mca.txt> (and especially the web page given
 	  there) before attempting to build an MCA bus kernel.
 source "drivers/mca/Kconfig"
 config SCx200
 	tristate "NatSemi SCx200 support"
 	---help---
 	  This provides basic support for National Semiconductor's
 	  (now AMD's) Geode processors.  The driver probes for the
 	  PCI-IDs of several on-chip devices, so its a good dependency
 	  for other scx200_* drivers.
 	  If compiled as a module, the driver is named scx200.
 config SCx200HR_TIMER
 	tristate "NatSemi SCx200 27MHz High-Resolution Timer Support"
 	depends on SCx200
 	default y
 	---help---
 	  This driver provides a clocksource built upon the on-chip
 	  27MHz high-resolution timer.  Its also a workaround for
 	  NSC Geode SC-1100's buggy TSC, which loses time when the
 	  processor goes idle (as is done by the scheduler).  The
 	  other workaround is idle=poll boot option.
 config OLPC
 	bool "One Laptop Per Child support"
 	depends on !X86_PAE
 	select GPIOLIB
 	select OF
 	select OF_PROMTREE
 	---help---
 	  Add support for detecting the unique features of the OLPC
 	  XO hardware.
 config OLPC_XO1_PM
 	bool "OLPC XO-1 Power Management"
 	depends on OLPC && MFD_CS5535 && PM_SLEEP
 	select MFD_CORE
 	---help---
 	  Add support for poweroff and suspend of the OLPC XO-1 laptop.
 config OLPC_XO1_RTC
 	bool "OLPC XO-1 Real Time Clock"
 	depends on OLPC_XO1_PM && RTC_DRV_CMOS
 	---help---
 	  Add support for the XO-1 real time clock, which can be used as a
 	  programmable wakeup source.
 config OLPC_XO1_SCI
 	bool "OLPC XO-1 SCI extras"
 	depends on OLPC && OLPC_XO1_PM
 	select POWER_SUPPLY
 	select GPIO_CS5535
 	select MFD_CORE
 	---help---
 	  Add support for SCI-based features of the OLPC XO-1 laptop:
 	   - EC-driven system wakeups
 	   - Power button
 	   - Ebook switch
 	   - Lid switch
 	   - AC adapter status updates
 	   - Battery status updates
 config OLPC_XO15_SCI
 	bool "OLPC XO-1.5 SCI extras"
 	depends on OLPC && ACPI
 	select POWER_SUPPLY
 	---help---
 	  Add support for SCI-based features of the OLPC XO-1.5 laptop:
 	   - EC-driven system wakeups
 	   - AC adapter status updates
 	   - Battery status updates
 config ALIX
 	bool "PCEngines ALIX System Support (LED setup)"
 	select GPIOLIB
 	---help---
 	  This option enables system support for the PCEngines ALIX.
 	  At present this just sets up LEDs for GPIO control on
 	  ALIX2/3/6 boards.  However, other system specific setup should
 	  get added here.
 	  Note: You must still enable the drivers for GPIO and LED support
 	  (GPIO_CS5535 & LEDS_GPIO) to actually use the LEDs
 	  Note: You have to set alix.force=1 for boards with Award BIOS.
 endif # X86_32
 config AMD_NB
 	def_bool y
 	depends on CPU_SUP_AMD && PCI
 source "drivers/pcmcia/Kconfig"
 source "drivers/pci/hotplug/Kconfig"
 config RAPIDIO
 	bool "RapidIO support"
 	depends on PCI
 	default n
 	help
 	  If you say Y here, the kernel will include drivers and
 	  infrastructure code to support RapidIO interconnect devices.
 source "drivers/rapidio/Kconfig"
 endmenu
 menu "Executable file formats / Emulations"
 source "fs/Kconfig.binfmt"
 config IA32_EMULATION
 	bool "IA32 Emulation"
 	depends on X86_64
 	select COMPAT_BINFMT_ELF
 	---help---
 	  Include code to run 32-bit programs under a 64-bit kernel. You should
 	  likely turn this on, unless you're 100% sure that you don't have any
 	  32-bit programs left.
 config IA32_AOUT
 	tristate "IA32 a.out support"
 	depends on IA32_EMULATION
 	---help---
 	  Support old a.out binaries in the 32bit emulation.
 config COMPAT
 	def_bool y
 	depends on IA32_EMULATION
 config COMPAT_FOR_U64_ALIGNMENT
 	def_bool COMPAT
 	depends on X86_64
 config SYSVIPC_COMPAT
 	def_bool y
 	depends on COMPAT && SYSVIPC
 config KEYS_COMPAT
 	bool
 	depends on COMPAT && KEYS
 	default y
 endmenu
 config HAVE_ATOMIC_IOMAP
 	def_bool y
 	depends on X86_32
 config HAVE_TEXT_POKE_SMP
 	bool
 	select STOP_MACHINE if SMP
 source "net/Kconfig"
 source "drivers/Kconfig"
 source "drivers/firmware/Kconfig"
 source "fs/Kconfig"
 source "arch/x86/Kconfig.debug"
 source "security/Kconfig"
 source "crypto/Kconfig"
 source "arch/x86/kvm/Kconfig"
 source "lib/Kconfig"

arch/x86/include/asm/e820.h

Diff comments View file @ a776878

 #ifndef _ASM_X86_E820_H
 #define _ASM_X86_E820_H
 #define E820MAP	0x2d0		/* our map */
 #define E820MAX	128		/* number of entries in E820MAP */
 /*
  * Legacy E820 BIOS limits us to 128 (E820MAX) nodes due to the
  * constrained space in the zeropage.  If we have more nodes than
  * that, and if we've booted off EFI firmware, then the EFI tables
  * passed us from the EFI firmware can list more nodes.  Size our
  * internal memory map tables to have room for these additional
  * nodes, based on up to three entries per node for which the
  * kernel was built: MAX_NUMNODES == (1 << CONFIG_NODES_SHIFT),
  * plus E820MAX, allowing space for the possible duplicate E820
  * entries that might need room in the same arrays, prior to the
  * call to sanitize_e820_map() to remove duplicates.  The allowance
  * of three memory map entries per node is "enough" entries for
  * the initial hardware platform motivating this mechanism to make
  * use of additional EFI map entries.  Future platforms may want
  * to allow more than three entries per node or otherwise refine
  * this size.
  */
 /*
  * Odd: 'make headers_check' complains about numa.h if I try
  * to collapse the next two #ifdef lines to a single line:
  *	#if defined(__KERNEL__) && defined(CONFIG_EFI)
  */
 #ifdef __KERNEL__
 #ifdef CONFIG_EFI
 #include <linux/numa.h>
 #define E820_X_MAX (E820MAX + 3 * MAX_NUMNODES)
 #else	/* ! CONFIG_EFI */
 #define E820_X_MAX E820MAX
 #endif
 #else	/* ! __KERNEL__ */
 #define E820_X_MAX E820MAX
 #endif
 #define E820NR	0x1e8		/* # entries in E820MAP */
 #define E820_RAM	1
 #define E820_RESERVED	2
 #define E820_ACPI	3
 #define E820_NVS	4
 #define E820_UNUSABLE	5
 /*
  * reserved RAM used by kernel itself
  * if CONFIG_INTEL_TXT is enabled, memory of this type will be
  * included in the S3 integrity calculation and so should not include
  * any memory that BIOS might alter over the S3 transition
  */
 #define E820_RESERVED_KERN        128
+/*
+ * Address ranges that need to be mapped by the kernel direct
+ * mapping. This is used to make sure regions such as
+ * EFI_RUNTIME_SERVICES_DATA are directly mapped. See setup_arch().
+ */
+#define E820_RESERVED_EFI         129
 #ifndef __ASSEMBLY__
 #include <linux/types.h>
 struct e820entry {
 	__u64 addr;	/* start of memory segment */
 	__u64 size;	/* size of memory segment */
 	__u32 type;	/* type of memory segment */
 } __attribute__((packed));
 struct e820map {
 	__u32 nr_map;
 	struct e820entry map[E820_X_MAX];
 };
 #define ISA_START_ADDRESS	0xa0000
 #define ISA_END_ADDRESS		0x100000
 #define BIOS_BEGIN		0x000a0000
 #define BIOS_END		0x00100000
 #define BIOS_ROM_BASE		0xffe00000
 #define BIOS_ROM_END		0xffffffff
 #ifdef __KERNEL__
 /* see comment in arch/x86/kernel/e820.c */
 extern struct e820map e820;
 extern struct e820map e820_saved;
 extern unsigned long pci_mem_start;
 extern int e820_any_mapped(u64 start, u64 end, unsigned type);
 extern int e820_all_mapped(u64 start, u64 end, unsigned type);
 extern void e820_add_region(u64 start, u64 size, int type);
 extern void e820_print_map(char *who);
 extern int
 sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, u32 *pnr_map);
 extern u64 e820_update_range(u64 start, u64 size, unsigned old_type,
 			       unsigned new_type);
 extern u64 e820_remove_range(u64 start, u64 size, unsigned old_type,
 			     int checktype);
 extern void update_e820(void);
 extern void e820_setup_gap(void);
 extern int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize,
 			unsigned long start_addr, unsigned long long end_addr);
 struct setup_data;
 extern void parse_e820_ext(struct setup_data *data);
 #if defined(CONFIG_X86_64) || \
 	(defined(CONFIG_X86_32) && defined(CONFIG_HIBERNATION))
 extern void e820_mark_nosave_regions(unsigned long limit_pfn);
 #else
 static inline void e820_mark_nosave_regions(unsigned long limit_pfn)
 {
 }
 #endif
 #ifdef CONFIG_MEMTEST
 extern void early_memtest(unsigned long start, unsigned long end);
 #else
 static inline void early_memtest(unsigned long start, unsigned long end)
 {
 }
 #endif
+extern unsigned long e820_end_pfn(unsigned long limit_pfn, unsigned type);
 extern unsigned long e820_end_of_ram_pfn(void);
 extern unsigned long e820_end_of_low_ram_pfn(void);
 extern u64 early_reserve_e820(u64 startt, u64 sizet, u64 align);
 void memblock_x86_fill(void);
 void memblock_find_dma_reserve(void);
 extern void finish_e820_parsing(void);
 extern void e820_reserve_resources(void);
 extern void e820_reserve_resources_late(void);
 extern void setup_memory_map(void);
 extern char *default_machine_specific_memory_setup(void);
 /*
  * Returns true iff the specified range [s,e) is completely contained inside
  * the ISA region.
  */
 static inline bool is_ISA_range(u64 s, u64 e)
 {
 	return s >= ISA_START_ADDRESS && e <= ISA_END_ADDRESS;
 }
 #endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
 #ifdef __KERNEL__
 #include <linux/ioport.h>
 #define HIGH_MEMORY	(1024*1024)
 #endif /* __KERNEL__ */
 #endif /* _ASM_X86_E820_H */

arch/x86/include/asm/efi.h

Diff comments View file @ a776878

 #ifndef _ASM_X86_EFI_H
 #define _ASM_X86_EFI_H
 #ifdef CONFIG_X86_32
 extern unsigned long asmlinkage efi_call_phys(void *, ...);
 #define efi_call_phys0(f)		efi_call_phys(f)
 #define efi_call_phys1(f, a1)		efi_call_phys(f, a1)
 #define efi_call_phys2(f, a1, a2)	efi_call_phys(f, a1, a2)
 #define efi_call_phys3(f, a1, a2, a3)	efi_call_phys(f, a1, a2, a3)
 #define efi_call_phys4(f, a1, a2, a3, a4)	\
 	efi_call_phys(f, a1, a2, a3, a4)
 #define efi_call_phys5(f, a1, a2, a3, a4, a5)	\
 	efi_call_phys(f, a1, a2, a3, a4, a5)
 #define efi_call_phys6(f, a1, a2, a3, a4, a5, a6)	\
 	efi_call_phys(f, a1, a2, a3, a4, a5, a6)
 /*
  * Wrap all the virtual calls in a way that forces the parameters on the stack.
  */
 #define efi_call_virt(f, args...) \
 	((efi_##f##_t __attribute__((regparm(0)))*)efi.systab->runtime->f)(args)
 #define efi_call_virt0(f)		efi_call_virt(f)
 #define efi_call_virt1(f, a1)		efi_call_virt(f, a1)
 #define efi_call_virt2(f, a1, a2)	efi_call_virt(f, a1, a2)
 #define efi_call_virt3(f, a1, a2, a3)	efi_call_virt(f, a1, a2, a3)
 #define efi_call_virt4(f, a1, a2, a3, a4)	\
 	efi_call_virt(f, a1, a2, a3, a4)
 #define efi_call_virt5(f, a1, a2, a3, a4, a5)	\
 	efi_call_virt(f, a1, a2, a3, a4, a5)
 #define efi_call_virt6(f, a1, a2, a3, a4, a5, a6)	\
 	efi_call_virt(f, a1, a2, a3, a4, a5, a6)
-#define efi_ioremap(addr, size, type)		ioremap_cache(addr, size)
 #else /* !CONFIG_X86_32 */
 extern u64 efi_call0(void *fp);
 extern u64 efi_call1(void *fp, u64 arg1);
 extern u64 efi_call2(void *fp, u64 arg1, u64 arg2);
 extern u64 efi_call3(void *fp, u64 arg1, u64 arg2, u64 arg3);
 extern u64 efi_call4(void *fp, u64 arg1, u64 arg2, u64 arg3, u64 arg4);
 extern u64 efi_call5(void *fp, u64 arg1, u64 arg2, u64 arg3,
 		     u64 arg4, u64 arg5);
 extern u64 efi_call6(void *fp, u64 arg1, u64 arg2, u64 arg3,
 		     u64 arg4, u64 arg5, u64 arg6);
 #define efi_call_phys0(f)			\
 	efi_call0((void *)(f))
 #define efi_call_phys1(f, a1)			\
 	efi_call1((void *)(f), (u64)(a1))
 #define efi_call_phys2(f, a1, a2)			\
 	efi_call2((void *)(f), (u64)(a1), (u64)(a2))
 #define efi_call_phys3(f, a1, a2, a3)				\
 	efi_call3((void *)(f), (u64)(a1), (u64)(a2), (u64)(a3))
 #define efi_call_phys4(f, a1, a2, a3, a4)				\
 	efi_call4((void *)(f), (u64)(a1), (u64)(a2), (u64)(a3),		\
 		  (u64)(a4))
 #define efi_call_phys5(f, a1, a2, a3, a4, a5)				\
 	efi_call5((void *)(f), (u64)(a1), (u64)(a2), (u64)(a3),		\
 		  (u64)(a4), (u64)(a5))
 #define efi_call_phys6(f, a1, a2, a3, a4, a5, a6)			\
 	efi_call6((void *)(f), (u64)(a1), (u64)(a2), (u64)(a3),		\
 		  (u64)(a4), (u64)(a5), (u64)(a6))
 #define efi_call_virt0(f)				\
 	efi_call0((void *)(efi.systab->runtime->f))
 #define efi_call_virt1(f, a1)					\
 	efi_call1((void *)(efi.systab->runtime->f), (u64)(a1))
 #define efi_call_virt2(f, a1, a2)					\
 	efi_call2((void *)(efi.systab->runtime->f), (u64)(a1), (u64)(a2))
 #define efi_call_virt3(f, a1, a2, a3)					\
 	efi_call3((void *)(efi.systab->runtime->f), (u64)(a1), (u64)(a2), \
 		  (u64)(a3))
 #define efi_call_virt4(f, a1, a2, a3, a4)				\
 	efi_call4((void *)(efi.systab->runtime->f), (u64)(a1), (u64)(a2), \
 		  (u64)(a3), (u64)(a4))
 #define efi_call_virt5(f, a1, a2, a3, a4, a5)				\
 	efi_call5((void *)(efi.systab->runtime->f), (u64)(a1), (u64)(a2), \
 		  (u64)(a3), (u64)(a4), (u64)(a5))
 #define efi_call_virt6(f, a1, a2, a3, a4, a5, a6)			\
 	efi_call6((void *)(efi.systab->runtime->f), (u64)(a1), (u64)(a2), \
 		  (u64)(a3), (u64)(a4), (u64)(a5), (u64)(a6))
-extern void __iomem *efi_ioremap(unsigned long addr, unsigned long size,
-				 u32 type);
 #endif /* CONFIG_X86_32 */
 extern int add_efi_memmap;
 extern void efi_set_executable(efi_memory_desc_t *md, bool executable);
 extern void efi_memblock_x86_reserve_range(void);
 extern void efi_call_phys_prelog(void);
 extern void efi_call_phys_epilog(void);
 #ifndef CONFIG_EFI
 /*
  * IF EFI is not configured, have the EFI calls return -ENOSYS.
  */
 #define efi_call0(_f)					(-ENOSYS)
 #define efi_call1(_f, _a1)				(-ENOSYS)
 #define efi_call2(_f, _a1, _a2)				(-ENOSYS)
 #define efi_call3(_f, _a1, _a2, _a3)			(-ENOSYS)
 #define efi_call4(_f, _a1, _a2, _a3, _a4)		(-ENOSYS)
 #define efi_call5(_f, _a1, _a2, _a3, _a4, _a5)		(-ENOSYS)
 #define efi_call6(_f, _a1, _a2, _a3, _a4, _a5, _a6)	(-ENOSYS)
 #endif /* CONFIG_EFI */
 #endif /* _ASM_X86_EFI_H */

arch/x86/kernel/e820.c

Diff comments View file @ a776878

 /*
  * Handle the memory map.
  * The functions here do the job until bootmem takes over.
  *
  *  Getting sanitize_e820_map() in sync with i386 version by applying change:
  *  -  Provisions for empty E820 memory regions (reported by certain BIOSes).
  *     Alex Achenbach <xela@slit.de>, December 2002.
  *  Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
  *
  */
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/crash_dump.h>
 #include <linux/export.h>
 #include <linux/bootmem.h>
 #include <linux/pfn.h>
 #include <linux/suspend.h>
 #include <linux/acpi.h>
 #include <linux/firmware-map.h>
 #include <linux/memblock.h>
 #include <asm/e820.h>
 #include <asm/proto.h>
 #include <asm/setup.h>
 /*
  * The e820 map is the map that gets modified e.g. with command line parameters
  * and that is also registered with modifications in the kernel resource tree
  * with the iomem_resource as parent.
  *
  * The e820_saved is directly saved after the BIOS-provided memory map is
  * copied. It doesn't get modified afterwards. It's registered for the
  * /sys/firmware/memmap interface.
  *
  * That memory map is not modified and is used as base for kexec. The kexec'd
  * kernel should get the same memory map as the firmware provides. Then the
  * user can e.g. boot the original kernel with mem=1G while still booting the
  * next kernel with full memory.
  */
 struct e820map e820;
 struct e820map e820_saved;
 /* For PCI or other memory-mapped resources */
 unsigned long pci_mem_start = 0xaeedbabe;
 #ifdef CONFIG_PCI
 EXPORT_SYMBOL(pci_mem_start);
 #endif
 /*
  * This function checks if any part of the range <start,end> is mapped
  * with type.
  */
 int
 e820_any_mapped(u64 start, u64 end, unsigned type)
 {
 	int i;
 	for (i = 0; i < e820.nr_map; i++) {
 		struct e820entry *ei = &e820.map[i];
 		if (type && ei->type != type)
 			continue;
 		if (ei->addr >= end || ei->addr + ei->size <= start)
 			continue;
 		return 1;
 	}
 	return 0;
 }
 EXPORT_SYMBOL_GPL(e820_any_mapped);
 /*
  * This function checks if the entire range <start,end> is mapped with type.
  *
  * Note: this function only works correct if the e820 table is sorted and
  * not-overlapping, which is the case
  */
 int __init e820_all_mapped(u64 start, u64 end, unsigned type)
 {
 	int i;
 	for (i = 0; i < e820.nr_map; i++) {
 		struct e820entry *ei = &e820.map[i];
 		if (type && ei->type != type)
 			continue;
 		/* is the region (part) in overlap with the current region ?*/
 		if (ei->addr >= end || ei->addr + ei->size <= start)
 			continue;
 		/* if the region is at the beginning of <start,end> we move
 		 * start to the end of the region since it's ok until there
 		 */
 		if (ei->addr <= start)
 			start = ei->addr + ei->size;
 		/*
 		 * if start is now at or beyond end, we're done, full
 		 * coverage
 		 */
 		if (start >= end)
 			return 1;
 	}
 	return 0;
 }
 /*
  * Add a memory region to the kernel e820 map.
  */
 static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size,
 					 int type)
 {
 	int x = e820x->nr_map;
 	if (x >= ARRAY_SIZE(e820x->map)) {
 		printk(KERN_ERR "Ooops! Too many entries in the memory map!\n");
 		return;
 	}
 	e820x->map[x].addr = start;
 	e820x->map[x].size = size;
 	e820x->map[x].type = type;
 	e820x->nr_map++;
 }
 void __init e820_add_region(u64 start, u64 size, int type)
 {
 	__e820_add_region(&e820, start, size, type);
 }
 static void __init e820_print_type(u32 type)
 {
 	switch (type) {
 	case E820_RAM:
 	case E820_RESERVED_KERN:
 		printk(KERN_CONT "(usable)");
 		break;
 	case E820_RESERVED:
+	case E820_RESERVED_EFI:
 		printk(KERN_CONT "(reserved)");
 		break;
 	case E820_ACPI:
 		printk(KERN_CONT "(ACPI data)");
 		break;
 	case E820_NVS:
 		printk(KERN_CONT "(ACPI NVS)");
 		break;
 	case E820_UNUSABLE:
 		printk(KERN_CONT "(unusable)");
 		break;
 	default:
 		printk(KERN_CONT "type %u", type);
 		break;
 	}
 }
 void __init e820_print_map(char *who)
 {
 	int i;
 	for (i = 0; i < e820.nr_map; i++) {
 		printk(KERN_INFO " %s: %016Lx - %016Lx ", who,
 		       (unsigned long long) e820.map[i].addr,
 		       (unsigned long long)
 		       (e820.map[i].addr + e820.map[i].size));
 		e820_print_type(e820.map[i].type);
 		printk(KERN_CONT "\n");
 	}
 }
 /*
  * Sanitize the BIOS e820 map.
  *
  * Some e820 responses include overlapping entries. The following
  * replaces the original e820 map with a new one, removing overlaps,
  * and resolving conflicting memory types in favor of highest
  * numbered type.
  *
  * The input parameter biosmap points to an array of 'struct
  * e820entry' which on entry has elements in the range [0, *pnr_map)
  * valid, and which has space for up to max_nr_map entries.
  * On return, the resulting sanitized e820 map entries will be in
  * overwritten in the same location, starting at biosmap.
  *
  * The integer pointed to by pnr_map must be valid on entry (the
  * current number of valid entries located at biosmap) and will
  * be updated on return, with the new number of valid entries
  * (something no more than max_nr_map.)
  *
  * The return value from sanitize_e820_map() is zero if it
  * successfully 'sanitized' the map entries passed in, and is -1
  * if it did nothing, which can happen if either of (1) it was
  * only passed one map entry, or (2) any of the input map entries
  * were invalid (start + size < start, meaning that the size was
  * so big the described memory range wrapped around through zero.)
  *
  *	Visually we're performing the following
  *	(1,2,3,4 = memory types)...
  *
  *	Sample memory map (w/overlaps):
  *	   ____22__________________
  *	   ______________________4_
  *	   ____1111________________
  *	   _44_____________________
  *	   11111111________________
  *	   ____________________33__
  *	   ___________44___________
  *	   __________33333_________
  *	   ______________22________
  *	   ___________________2222_
  *	   _________111111111______
  *	   _____________________11_
  *	   _________________4______
  *
  *	Sanitized equivalent (no overlap):
  *	   1_______________________
  *	   _44_____________________
  *	   ___1____________________
  *	   ____22__________________
  *	   ______11________________
  *	   _________1______________
  *	   __________3_____________
  *	   ___________44___________
  *	   _____________33_________
  *	   _______________2________
  *	   ________________1_______
  *	   _________________4______
  *	   ___________________2____
  *	   ____________________33__
  *	   ______________________4_
  */
 int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map,
 			     u32 *pnr_map)
 {
 	struct change_member {
 		struct e820entry *pbios; /* pointer to original bios entry */
 		unsigned long long addr; /* address for this change point */
 	};
 	static struct change_member change_point_list[2*E820_X_MAX] __initdata;
 	static struct change_member *change_point[2*E820_X_MAX] __initdata;
 	static struct e820entry *overlap_list[E820_X_MAX] __initdata;
 	static struct e820entry new_bios[E820_X_MAX] __initdata;
 	struct change_member *change_tmp;
 	unsigned long current_type, last_type;
 	unsigned long long last_addr;
 	int chgidx, still_changing;
 	int overlap_entries;
 	int new_bios_entry;
 	int old_nr, new_nr, chg_nr;
 	int i;
 	/* if there's only one memory region, don't bother */
 	if (*pnr_map < 2)
 		return -1;
 	old_nr = *pnr_map;
 	BUG_ON(old_nr > max_nr_map);
 	/* bail out if we find any unreasonable addresses in bios map */
 	for (i = 0; i < old_nr; i++)
 		if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
 			return -1;
 	/* create pointers for initial change-point information (for sorting) */
 	for (i = 0; i < 2 * old_nr; i++)
 		change_point[i] = &change_point_list[i];
 	/* record all known change-points (starting and ending addresses),
 	   omitting those that are for empty memory regions */
 	chgidx = 0;
 	for (i = 0; i < old_nr; i++)	{
 		if (biosmap[i].size != 0) {
 			change_point[chgidx]->addr = biosmap[i].addr;
 			change_point[chgidx++]->pbios = &biosmap[i];
 			change_point[chgidx]->addr = biosmap[i].addr +
 				biosmap[i].size;
 			change_point[chgidx++]->pbios = &biosmap[i];
 		}
 	}
 	chg_nr = chgidx;
 	/* sort change-point list by memory addresses (low -> high) */
 	still_changing = 1;
 	while (still_changing)	{
 		still_changing = 0;
 		for (i = 1; i < chg_nr; i++)  {
 			unsigned long long curaddr, lastaddr;
 			unsigned long long curpbaddr, lastpbaddr;
 			curaddr = change_point[i]->addr;
 			lastaddr = change_point[i - 1]->addr;
 			curpbaddr = change_point[i]->pbios->addr;
 			lastpbaddr = change_point[i - 1]->pbios->addr;
 			/*
 			 * swap entries, when:
 			 *
 			 * curaddr > lastaddr or
 			 * curaddr == lastaddr and curaddr == curpbaddr and
 			 * lastaddr != lastpbaddr
 			 */
 			if (curaddr < lastaddr ||
 			    (curaddr == lastaddr && curaddr == curpbaddr &&
 			     lastaddr != lastpbaddr)) {
 				change_tmp = change_point[i];
 				change_point[i] = change_point[i-1];
 				change_point[i-1] = change_tmp;
 				still_changing = 1;
 			}
 		}
 	}
 	/* create a new bios memory map, removing overlaps */
 	overlap_entries = 0;	 /* number of entries in the overlap table */
 	new_bios_entry = 0;	 /* index for creating new bios map entries */
 	last_type = 0;		 /* start with undefined memory type */
 	last_addr = 0;		 /* start with 0 as last starting address */
 	/* loop through change-points, determining affect on the new bios map */
 	for (chgidx = 0; chgidx < chg_nr; chgidx++) {
 		/* keep track of all overlapping bios entries */
 		if (change_point[chgidx]->addr ==
 		    change_point[chgidx]->pbios->addr) {
 			/*
 			 * add map entry to overlap list (> 1 entry
 			 * implies an overlap)
 			 */
 			overlap_list[overlap_entries++] =
 				change_point[chgidx]->pbios;
 		} else {
 			/*
 			 * remove entry from list (order independent,
 			 * so swap with last)
 			 */
 			for (i = 0; i < overlap_entries; i++) {
 				if (overlap_list[i] ==
 				    change_point[chgidx]->pbios)
 					overlap_list[i] =
 						overlap_list[overlap_entries-1];
 			}
 			overlap_entries--;
 		}
 		/*
 		 * if there are overlapping entries, decide which
 		 * "type" to use (larger value takes precedence --
 		 * 1=usable, 2,3,4,4+=unusable)
 		 */
 		current_type = 0;
 		for (i = 0; i < overlap_entries; i++)
 			if (overlap_list[i]->type > current_type)
 				current_type = overlap_list[i]->type;
 		/*
 		 * continue building up new bios map based on this
 		 * information
 		 */
 		if (current_type != last_type)	{
 			if (last_type != 0)	 {
 				new_bios[new_bios_entry].size =
 					change_point[chgidx]->addr - last_addr;
 				/*
 				 * move forward only if the new size
 				 * was non-zero
 				 */
 				if (new_bios[new_bios_entry].size != 0)
 					/*
 					 * no more space left for new
 					 * bios entries ?
 					 */
 					if (++new_bios_entry >= max_nr_map)
 						break;
 			}
 			if (current_type != 0)	{
 				new_bios[new_bios_entry].addr =
 					change_point[chgidx]->addr;
 				new_bios[new_bios_entry].type = current_type;
 				last_addr = change_point[chgidx]->addr;
 			}
 			last_type = current_type;
 		}
 	}
 	/* retain count for new bios entries */
 	new_nr = new_bios_entry;
 	/* copy new bios mapping into original location */
 	memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry));
 	*pnr_map = new_nr;
 	return 0;
 }
 static int __init __append_e820_map(struct e820entry *biosmap, int nr_map)
 {
 	while (nr_map) {
 		u64 start = biosmap->addr;
 		u64 size = biosmap->size;
 		u64 end = start + size;
 		u32 type = biosmap->type;
 		/* Overflow in 64 bits? Ignore the memory map. */
 		if (start > end)
 			return -1;
 		e820_add_region(start, size, type);
 		biosmap++;
 		nr_map--;
 	}
 	return 0;
 }
 /*
  * Copy the BIOS e820 map into a safe place.
  *
  * Sanity-check it while we're at it..
  *
  * If we're lucky and live on a modern system, the setup code
  * will have given us a memory map that we can use to properly
  * set up memory.  If we aren't, we'll fake a memory map.
  */
 static int __init append_e820_map(struct e820entry *biosmap, int nr_map)
 {
 	/* Only one memory region (or negative)? Ignore it */
 	if (nr_map < 2)
 		return -1;
 	return __append_e820_map(biosmap, nr_map);
 }
 static u64 __init __e820_update_range(struct e820map *e820x, u64 start,
 					u64 size, unsigned old_type,
 					unsigned new_type)
 {
 	u64 end;
 	unsigned int i;
 	u64 real_updated_size = 0;
 	BUG_ON(old_type == new_type);
 	if (size > (ULLONG_MAX - start))
 		size = ULLONG_MAX - start;
 	end = start + size;
 	printk(KERN_DEBUG "e820 update range: %016Lx - %016Lx ",
 		       (unsigned long long) start,
 		       (unsigned long long) end);
 	e820_print_type(old_type);
 	printk(KERN_CONT " ==> ");
 	e820_print_type(new_type);
 	printk(KERN_CONT "\n");
 	for (i = 0; i < e820x->nr_map; i++) {
 		struct e820entry *ei = &e820x->map[i];
 		u64 final_start, final_end;
 		u64 ei_end;
 		if (ei->type != old_type)
 			continue;
 		ei_end = ei->addr + ei->size;
 		/* totally covered by new range? */
 		if (ei->addr >= start && ei_end <= end) {
 			ei->type = new_type;
 			real_updated_size += ei->size;
 			continue;
 		}
 		/* new range is totally covered? */
 		if (ei->addr < start && ei_end > end) {
 			__e820_add_region(e820x, start, size, new_type);
 			__e820_add_region(e820x, end, ei_end - end, ei->type);
 			ei->size = start - ei->addr;
 			real_updated_size += size;
 			continue;
 		}
 		/* partially covered */
 		final_start = max(start, ei->addr);
 		final_end = min(end, ei_end);
 		if (final_start >= final_end)
 			continue;
 		__e820_add_region(e820x, final_start, final_end - final_start,
 				  new_type);
 		real_updated_size += final_end - final_start;
 		/*
 		 * left range could be head or tail, so need to update
 		 * size at first.
 		 */
 		ei->size -= final_end - final_start;
 		if (ei->addr < final_start)
 			continue;
 		ei->addr = final_end;
 	}
 	return real_updated_size;
 }
 u64 __init e820_update_range(u64 start, u64 size, unsigned old_type,
 			     unsigned new_type)
 {
 	return __e820_update_range(&e820, start, size, old_type, new_type);
 }
 static u64 __init e820_update_range_saved(u64 start, u64 size,
 					  unsigned old_type, unsigned new_type)
 {
 	return __e820_update_range(&e820_saved, start, size, old_type,
 				     new_type);
 }
 /* make e820 not cover the range */
 u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,
 			     int checktype)
 {
 	int i;
 	u64 end;
 	u64 real_removed_size = 0;
 	if (size > (ULLONG_MAX - start))
 		size = ULLONG_MAX - start;
 	end = start + size;
 	printk(KERN_DEBUG "e820 remove range: %016Lx - %016Lx ",
 		       (unsigned long long) start,
 		       (unsigned long long) end);
 	if (checktype)
 		e820_print_type(old_type);
 	printk(KERN_CONT "\n");
 	for (i = 0; i < e820.nr_map; i++) {
 		struct e820entry *ei = &e820.map[i];
 		u64 final_start, final_end;
 		u64 ei_end;
 		if (checktype && ei->type != old_type)
 			continue;
 		ei_end = ei->addr + ei->size;
 		/* totally covered? */
 		if (ei->addr >= start && ei_end <= end) {
 			real_removed_size += ei->size;
 			memset(ei, 0, sizeof(struct e820entry));
 			continue;
 		}
 		/* new range is totally covered? */
 		if (ei->addr < start && ei_end > end) {
 			e820_add_region(end, ei_end - end, ei->type);
 			ei->size = start - ei->addr;
 			real_removed_size += size;
 			continue;
 		}
 		/* partially covered */
 		final_start = max(start, ei->addr);
 		final_end = min(end, ei_end);
 		if (final_start >= final_end)
 			continue;
 		real_removed_size += final_end - final_start;
 		/*
 		 * left range could be head or tail, so need to update
 		 * size at first.
 		 */
 		ei->size -= final_end - final_start;
 		if (ei->addr < final_start)
 			continue;
 		ei->addr = final_end;
 	}
 	return real_removed_size;
 }
 void __init update_e820(void)
 {
 	u32 nr_map;
 	nr_map = e820.nr_map;
 	if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr_map))
 		return;
 	e820.nr_map = nr_map;
 	printk(KERN_INFO "modified physical RAM map:\n");
 	e820_print_map("modified");
 }
 static void __init update_e820_saved(void)
 {
 	u32 nr_map;
 	nr_map = e820_saved.nr_map;
 	if (sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map), &nr_map))
 		return;
 	e820_saved.nr_map = nr_map;
 }
 #define MAX_GAP_END 0x100000000ull
 /*
  * Search for a gap in the e820 memory space from start_addr to end_addr.
  */
 __init int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize,
 		unsigned long start_addr, unsigned long long end_addr)
 {
 	unsigned long long last;
 	int i = e820.nr_map;
 	int found = 0;
 	last = (end_addr && end_addr < MAX_GAP_END) ? end_addr : MAX_GAP_END;
 	while (--i >= 0) {
 		unsigned long long start = e820.map[i].addr;
 		unsigned long long end = start + e820.map[i].size;
 		if (end < start_addr)
 			continue;
 		/*
 		 * Since "last" is at most 4GB, we know we'll
 		 * fit in 32 bits if this condition is true
 		 */
 		if (last > end) {
 			unsigned long gap = last - end;
 			if (gap >= *gapsize) {
 				*gapsize = gap;
 				*gapstart = end;
 				found = 1;
 			}
 		}
 		if (start < last)
 			last = start;
 	}
 	return found;
 }
 /*
  * Search for the biggest gap in the low 32 bits of the e820
  * memory space.  We pass this space to PCI to assign MMIO resources
  * for hotplug or unconfigured devices in.
  * Hopefully the BIOS let enough space left.
  */
 __init void e820_setup_gap(void)
 {
 	unsigned long gapstart, gapsize;
 	int found;
 	gapstart = 0x10000000;
 	gapsize = 0x400000;
 	found  = e820_search_gap(&gapstart, &gapsize, 0, MAX_GAP_END);
 #ifdef CONFIG_X86_64
 	if (!found) {
 		gapstart = (max_pfn << PAGE_SHIFT) + 1024*1024;
 		printk(KERN_ERR
 	"PCI: Warning: Cannot find a gap in the 32bit address range\n"
 	"PCI: Unassigned devices with 32bit resource registers may break!\n");
 	}
 #endif
 	/*
 	 * e820_reserve_resources_late protect stolen RAM already
 	 */
 	pci_mem_start = gapstart;
 	printk(KERN_INFO
 	       "Allocating PCI resources starting at %lx (gap: %lx:%lx)\n",
 	       pci_mem_start, gapstart, gapsize);
 }
 /**
  * Because of the size limitation of struct boot_params, only first
  * 128 E820 memory entries are passed to kernel via
  * boot_params.e820_map, others are passed via SETUP_E820_EXT node of
  * linked list of struct setup_data, which is parsed here.
  */
 void __init parse_e820_ext(struct setup_data *sdata)
 {
 	int entries;
 	struct e820entry *extmap;
 	entries = sdata->len / sizeof(struct e820entry);
 	extmap = (struct e820entry *)(sdata->data);
 	__append_e820_map(extmap, entries);
 	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
 	printk(KERN_INFO "extended physical RAM map:\n");
 	e820_print_map("extended");
 }
 #if defined(CONFIG_X86_64) || \
 	(defined(CONFIG_X86_32) && defined(CONFIG_HIBERNATION))
 /**
  * Find the ranges of physical addresses that do not correspond to
  * e820 RAM areas and mark the corresponding pages as nosave for
  * hibernation (32 bit) or software suspend and suspend to RAM (64 bit).
  *
  * This function requires the e820 map to be sorted and without any
  * overlapping entries and assumes the first e820 area to be RAM.
  */
 void __init e820_mark_nosave_regions(unsigned long limit_pfn)
 {
 	int i;
 	unsigned long pfn;
 	pfn = PFN_DOWN(e820.map[0].addr + e820.map[0].size);
 	for (i = 1; i < e820.nr_map; i++) {
 		struct e820entry *ei = &e820.map[i];
 		if (pfn < PFN_UP(ei->addr))
 			register_nosave_region(pfn, PFN_UP(ei->addr));
 		pfn = PFN_DOWN(ei->addr + ei->size);
 		if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
 			register_nosave_region(PFN_UP(ei->addr), pfn);
 		if (pfn >= limit_pfn)
 			break;
 	}
 }
 #endif
 #ifdef CONFIG_HIBERNATION
 /**
  * Mark ACPI NVS memory region, so that we can save/restore it during
  * hibernation and the subsequent resume.
  */
 static int __init e820_mark_nvs_memory(void)
 {
 	int i;
 	for (i = 0; i < e820.nr_map; i++) {
 		struct e820entry *ei = &e820.map[i];
 		if (ei->type == E820_NVS)
 			suspend_nvs_register(ei->addr, ei->size);
 	}
 	return 0;
 }
 core_initcall(e820_mark_nvs_memory);
 #endif
 /*
  * pre allocated 4k and reserved it in memblock and e820_saved
  */
 u64 __init early_reserve_e820(u64 startt, u64 sizet, u64 align)
 {
 	u64 size = 0;
 	u64 addr;
 	u64 start;
 	for (start = startt; ; start += size) {
 		start = memblock_x86_find_in_range_size(start, &size, align);
 		if (start == MEMBLOCK_ERROR)
 			return 0;
 		if (size >= sizet)
 			break;
 	}
 #ifdef CONFIG_X86_32
 	if (start >= MAXMEM)
 		return 0;
 	if (start + size > MAXMEM)
 		size = MAXMEM - start;
 #endif
 	addr = round_down(start + size - sizet, align);
 	if (addr < start)
 		return 0;
 	memblock_x86_reserve_range(addr, addr + sizet, "new next");
 	e820_update_range_saved(addr, sizet, E820_RAM, E820_RESERVED);
 	printk(KERN_INFO "update e820_saved for early_reserve_e820\n");
 	update_e820_saved();
 	return addr;
 }
 #ifdef CONFIG_X86_32
 # ifdef CONFIG_X86_PAE
 #  define MAX_ARCH_PFN		(1ULL<<(36-PAGE_SHIFT))
 # else
 #  define MAX_ARCH_PFN		(1ULL<<(32-PAGE_SHIFT))
 # endif
 #else /* CONFIG_X86_32 */
 # define MAX_ARCH_PFN MAXMEM>>PAGE_SHIFT
 #endif
 /*
  * Find the highest page frame number we have available
  */
-static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type)
+unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type)
 {
 	int i;
 	unsigned long last_pfn = 0;
 	unsigned long max_arch_pfn = MAX_ARCH_PFN;
 	for (i = 0; i < e820.nr_map; i++) {
 		struct e820entry *ei = &e820.map[i];
 		unsigned long start_pfn;
 		unsigned long end_pfn;
 		if (ei->type != type)
 			continue;
 		start_pfn = ei->addr >> PAGE_SHIFT;
 		end_pfn = (ei->addr + ei->size) >> PAGE_SHIFT;
 		if (start_pfn >= limit_pfn)
 			continue;
 		if (end_pfn > limit_pfn) {
 			last_pfn = limit_pfn;
 			break;
 		}
 		if (end_pfn > last_pfn)
 			last_pfn = end_pfn;
 	}
 	if (last_pfn > max_arch_pfn)
 		last_pfn = max_arch_pfn;
 	printk(KERN_INFO "last_pfn = %#lx max_arch_pfn = %#lx\n",
 			 last_pfn, max_arch_pfn);
 	return last_pfn;
 }
 unsigned long __init e820_end_of_ram_pfn(void)
 {
 	return e820_end_pfn(MAX_ARCH_PFN, E820_RAM);
 }
 unsigned long __init e820_end_of_low_ram_pfn(void)
 {
 	return e820_end_pfn(1UL<<(32 - PAGE_SHIFT), E820_RAM);
 }
 static void early_panic(char *msg)
 {
 	early_printk(msg);
 	panic(msg);
 }
 static int userdef __initdata;
 /* "mem=nopentium" disables the 4MB page tables. */
 static int __init parse_memopt(char *p)
 {
 	u64 mem_size;
 	if (!p)
 		return -EINVAL;
 	if (!strcmp(p, "nopentium")) {
 #ifdef CONFIG_X86_32
 		setup_clear_cpu_cap(X86_FEATURE_PSE);
 		return 0;
 #else
 		printk(KERN_WARNING "mem=nopentium ignored! (only supported on x86_32)\n");
 		return -EINVAL;
 #endif
 	}
 	userdef = 1;
 	mem_size = memparse(p, &p);
 	/* don't remove all of memory when handling "mem={invalid}" param */
 	if (mem_size == 0)
 		return -EINVAL;
 	e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
 	return 0;
 }
 early_param("mem", parse_memopt);
 static int __init parse_memmap_opt(char *p)
 {
 	char *oldp;
 	u64 start_at, mem_size;
 	if (!p)
 		return -EINVAL;
 	if (!strncmp(p, "exactmap", 8)) {
 #ifdef CONFIG_CRASH_DUMP
 		/*
 		 * If we are doing a crash dump, we still need to know
 		 * the real mem size before original memory map is
 		 * reset.
 		 */
 		saved_max_pfn = e820_end_of_ram_pfn();
 #endif
 		e820.nr_map = 0;
 		userdef = 1;
 		return 0;
 	}
 	oldp = p;
 	mem_size = memparse(p, &p);
 	if (p == oldp)
 		return -EINVAL;
 	userdef = 1;
 	if (*p == '@') {
 		start_at = memparse(p+1, &p);
 		e820_add_region(start_at, mem_size, E820_RAM);
 	} else if (*p == '#') {
 		start_at = memparse(p+1, &p);
 		e820_add_region(start_at, mem_size, E820_ACPI);
 	} else if (*p == '$') {
 		start_at = memparse(p+1, &p);
 		e820_add_region(start_at, mem_size, E820_RESERVED);
 	} else
 		e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
 	return *p == '\0' ? 0 : -EINVAL;
 }
 early_param("memmap", parse_memmap_opt);
 void __init finish_e820_parsing(void)
 {
 	if (userdef) {
 		u32 nr = e820.nr_map;
 		if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0)
 			early_panic("Invalid user supplied memory map");
 		e820.nr_map = nr;
 		printk(KERN_INFO "user-defined physical RAM map:\n");
 		e820_print_map("user");
 	}
 }
 static inline const char *e820_type_to_string(int e820_type)
 {
 	switch (e820_type) {
 	case E820_RESERVED_KERN:
 	case E820_RAM:	return "System RAM";
 	case E820_ACPI:	return "ACPI Tables";
 	case E820_NVS:	return "ACPI Non-volatile Storage";
 	case E820_UNUSABLE:	return "Unusable memory";
 	default:	return "reserved";
 	}
 }
 /*
  * Mark e820 reserved areas as busy for the resource manager.
  */
 static struct resource __initdata *e820_res;
 void __init e820_reserve_resources(void)
 {
 	int i;
 	struct resource *res;
 	u64 end;
 	res = alloc_bootmem(sizeof(struct resource) * e820.nr_map);
 	e820_res = res;
 	for (i = 0; i < e820.nr_map; i++) {
 		end = e820.map[i].addr + e820.map[i].size - 1;
 		if (end != (resource_size_t)end) {
 			res++;
 			continue;
 		}
 		res->name = e820_type_to_string(e820.map[i].type);
 		res->start = e820.map[i].addr;
 		res->end = end;
 		res->flags = IORESOURCE_MEM;
 		/*
 		 * don't register the region that could be conflicted with
 		 * pci device BAR resource and insert them later in
 		 * pcibios_resource_survey()
 		 */
 		if (e820.map[i].type != E820_RESERVED || res->start < (1ULL<<20)) {
 			res->flags |= IORESOURCE_BUSY;
 			insert_resource(&iomem_resource, res);
 		}
 		res++;
 	}
 	for (i = 0; i < e820_saved.nr_map; i++) {
 		struct e820entry *entry = &e820_saved.map[i];
 		firmware_map_add_early(entry->addr,
 			entry->addr + entry->size - 1,
 			e820_type_to_string(entry->type));
 	}
 }
 /* How much should we pad RAM ending depending on where it is? */
 static unsigned long ram_alignment(resource_size_t pos)
 {
 	unsigned long mb = pos >> 20;
 	/* To 64kB in the first megabyte */
 	if (!mb)
 		return 64*1024;
 	/* To 1MB in the first 16MB */
 	if (mb < 16)
 		return 1024*1024;
 	/* To 64MB for anything above that */
 	return 64*1024*1024;
 }
 #define MAX_RESOURCE_SIZE ((resource_size_t)-1)
 void __init e820_reserve_resources_late(void)
 {
 	int i;
 	struct resource *res;
 	res = e820_res;
 	for (i = 0; i < e820.nr_map; i++) {
 		if (!res->parent && res->end)
 			insert_resource_expand_to_fit(&iomem_resource, res);
 		res++;
 	}
 	/*
 	 * Try to bump up RAM regions to reasonable boundaries to
 	 * avoid stolen RAM:
 	 */
 	for (i = 0; i < e820.nr_map; i++) {
 		struct e820entry *entry = &e820.map[i];
 		u64 start, end;
 		if (entry->type != E820_RAM)
 			continue;
 		start = entry->addr + entry->size;
 		end = round_up(start, ram_alignment(start)) - 1;
 		if (end > MAX_RESOURCE_SIZE)
 			end = MAX_RESOURCE_SIZE;
 		if (start >= end)
 			continue;
 		printk(KERN_DEBUG "reserve RAM buffer: %016llx - %016llx ",
 			       start, end);
 		reserve_region_with_split(&iomem_resource, start, end,
 					  "RAM buffer");
 	}
 }
 char *__init default_machine_specific_memory_setup(void)
 {
 	char *who = "BIOS-e820";
 	u32 new_nr;
 	/*
 	 * Try to copy the BIOS-supplied E820-map.
 	 *
 	 * Otherwise fake a memory map; one section from 0k->640k,
 	 * the next section from 1mb->appropriate_mem_k
 	 */
 	new_nr = boot_params.e820_entries;
 	sanitize_e820_map(boot_params.e820_map,
 			ARRAY_SIZE(boot_params.e820_map),
 			&new_nr);
 	boot_params.e820_entries = new_nr;
 	if (append_e820_map(boot_params.e820_map, boot_params.e820_entries)
 	  < 0) {
 		u64 mem_size;
 		/* compare results from other methods and take the greater */
 		if (boot_params.alt_mem_k
 		    < boot_params.screen_info.ext_mem_k) {
 			mem_size = boot_params.screen_info.ext_mem_k;
 			who = "BIOS-88";
 		} else {
 			mem_size = boot_params.alt_mem_k;
 			who = "BIOS-e801";
 		}
 		e820.nr_map = 0;
 		e820_add_region(0, LOWMEMSIZE(), E820_RAM);
 		e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
 	}
 	/* In case someone cares... */
 	return who;
 }
 void __init setup_memory_map(void)
 {
 	char *who;
 	who = x86_init.resources.memory_setup();
 	memcpy(&e820_saved, &e820, sizeof(struct e820map));
 	printk(KERN_INFO "BIOS-provided physical RAM map:\n");
 	e820_print_map(who);
 }
 void __init memblock_x86_fill(void)
 {
 	int i;
 	u64 end;
 	/*
 	 * EFI may have more than 128 entries
 	 * We are safe to enable resizing, beause memblock_x86_fill()
 	 * is rather later for x86
 	 */
 	memblock_can_resize = 1;
 	for (i = 0; i < e820.nr_map; i++) {
 		struct e820entry *ei = &e820.map[i];
 		end = ei->addr + ei->size;
 		if (end != (resource_size_t)end)
 			continue;
 		if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
 			continue;
 		memblock_add(ei->addr, ei->size);
 	}
 	memblock_analyze();
 	memblock_dump_all();
 }
 void __init memblock_find_dma_reserve(void)
 {
 #ifdef CONFIG_X86_64
 	u64 free_size_pfn;
 	u64 mem_size_pfn;
 	/*
 	 * need to find out used area below MAX_DMA_PFN
 	 * need to use memblock to get free size in [0, MAX_DMA_PFN]
 	 * at first, and assume boot_mem will not take below MAX_DMA_PFN
 	 */
 	mem_size_pfn = memblock_x86_memory_in_range(0, MAX_DMA_PFN << PAGE_SHIFT) >> PAGE_SHIFT;
 	free_size_pfn = memblock_x86_free_memory_in_range(0, MAX_DMA_PFN << PAGE_SHIFT) >> PAGE_SHIFT;
 	set_dma_reserve(mem_size_pfn - free_size_pfn);
 #endif
 }

arch/x86/kernel/hpet.c

Diff comments View file @ a776878

 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
 #include <linux/interrupt.h>
 #include <linux/export.h>
 #include <linux/sysdev.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/i8253.h>
 #include <linux/slab.h>
 #include <linux/hpet.h>
 #include <linux/init.h>
 #include <linux/cpu.h>
 #include <linux/pm.h>
 #include <linux/io.h>
 #include <asm/fixmap.h>
 #include <asm/hpet.h>
 #include <asm/time.h>
 #define HPET_MASK			CLOCKSOURCE_MASK(32)
 /* FSEC = 10^-15
    NSEC = 10^-9 */
 #define FSEC_PER_NSEC			1000000L
 #define HPET_DEV_USED_BIT		2
 #define HPET_DEV_USED			(1 << HPET_DEV_USED_BIT)
 #define HPET_DEV_VALID			0x8
 #define HPET_DEV_FSB_CAP		0x1000
 #define HPET_DEV_PERI_CAP		0x2000
 #define HPET_MIN_CYCLES			128
 #define HPET_MIN_PROG_DELTA		(HPET_MIN_CYCLES + (HPET_MIN_CYCLES >> 1))
 #define EVT_TO_HPET_DEV(evt) container_of(evt, struct hpet_dev, evt)
 /*
  * HPET address is set in acpi/boot.c, when an ACPI entry exists
  */
 unsigned long				hpet_address;
 u8					hpet_blockid; /* OS timer block num */
 u8					hpet_msi_disable;
 #ifdef CONFIG_PCI_MSI
 static unsigned long			hpet_num_timers;
 #endif
 static void __iomem			*hpet_virt_address;
 struct hpet_dev {
 	struct clock_event_device	evt;
 	unsigned int			num;
 	int				cpu;
 	unsigned int			irq;
 	unsigned int			flags;
 	char				name[10];
 };
 inline unsigned int hpet_readl(unsigned int a)
 {
 	return readl(hpet_virt_address + a);
 }
 static inline void hpet_writel(unsigned int d, unsigned int a)
 {
 	writel(d, hpet_virt_address + a);
 }
 #ifdef CONFIG_X86_64
 #include <asm/pgtable.h>
 #endif
 static inline void hpet_set_mapping(void)
 {
 	hpet_virt_address = ioremap_nocache(hpet_address, HPET_MMAP_SIZE);
 #ifdef CONFIG_X86_64
 	__set_fixmap(VSYSCALL_HPET, hpet_address, PAGE_KERNEL_VVAR_NOCACHE);
 #endif
 }
 static inline void hpet_clear_mapping(void)
 {
 	iounmap(hpet_virt_address);
 	hpet_virt_address = NULL;
 }
 /*
  * HPET command line enable / disable
  */
 static int boot_hpet_disable;
 int hpet_force_user;
 static int hpet_verbose;
 static int __init hpet_setup(char *str)
 {
 	if (str) {
 		if (!strncmp("disable", str, 7))
 			boot_hpet_disable = 1;
 		if (!strncmp("force", str, 5))
 			hpet_force_user = 1;
 		if (!strncmp("verbose", str, 7))
 			hpet_verbose = 1;
 	}
 	return 1;
 }
 __setup("hpet=", hpet_setup);
 static int __init disable_hpet(char *str)
 {
 	boot_hpet_disable = 1;
 	return 1;
 }
 __setup("nohpet", disable_hpet);
 static inline int is_hpet_capable(void)
 {
 	return !boot_hpet_disable && hpet_address;
 }
 /*
  * HPET timer interrupt enable / disable
  */
 static int hpet_legacy_int_enabled;
 /**
  * is_hpet_enabled - check whether the hpet timer interrupt is enabled
  */
 int is_hpet_enabled(void)
 {
 	return is_hpet_capable() && hpet_legacy_int_enabled;
 }
 EXPORT_SYMBOL_GPL(is_hpet_enabled);
 static void _hpet_print_config(const char *function, int line)
 {
 	u32 i, timers, l, h;
 	printk(KERN_INFO "hpet: %s(%d):\n", function, line);
 	l = hpet_readl(HPET_ID);
 	h = hpet_readl(HPET_PERIOD);
 	timers = ((l & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
 	printk(KERN_INFO "hpet: ID: 0x%x, PERIOD: 0x%x\n", l, h);
 	l = hpet_readl(HPET_CFG);
 	h = hpet_readl(HPET_STATUS);
 	printk(KERN_INFO "hpet: CFG: 0x%x, STATUS: 0x%x\n", l, h);
 	l = hpet_readl(HPET_COUNTER);
 	h = hpet_readl(HPET_COUNTER+4);
 	printk(KERN_INFO "hpet: COUNTER_l: 0x%x, COUNTER_h: 0x%x\n", l, h);
 	for (i = 0; i < timers; i++) {
 		l = hpet_readl(HPET_Tn_CFG(i));
 		h = hpet_readl(HPET_Tn_CFG(i)+4);
 		printk(KERN_INFO "hpet: T%d: CFG_l: 0x%x, CFG_h: 0x%x\n",
 		       i, l, h);
 		l = hpet_readl(HPET_Tn_CMP(i));
 		h = hpet_readl(HPET_Tn_CMP(i)+4);
 		printk(KERN_INFO "hpet: T%d: CMP_l: 0x%x, CMP_h: 0x%x\n",
 		       i, l, h);
 		l = hpet_readl(HPET_Tn_ROUTE(i));
 		h = hpet_readl(HPET_Tn_ROUTE(i)+4);
 		printk(KERN_INFO "hpet: T%d ROUTE_l: 0x%x, ROUTE_h: 0x%x\n",
 		       i, l, h);
 	}
 }
 #define hpet_print_config()					\
 do {								\
 	if (hpet_verbose)					\
 		_hpet_print_config(__FUNCTION__, __LINE__);	\
 } while (0)
 /*
  * When the hpet driver (/dev/hpet) is enabled, we need to reserve
  * timer 0 and timer 1 in case of RTC emulation.
  */
 #ifdef CONFIG_HPET
 static void hpet_reserve_msi_timers(struct hpet_data *hd);
 static void hpet_reserve_platform_timers(unsigned int id)
 {
 	struct hpet __iomem *hpet = hpet_virt_address;
 	struct hpet_timer __iomem *timer = &hpet->hpet_timers[2];
 	unsigned int nrtimers, i;
 	struct hpet_data hd;
 	nrtimers = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT) + 1;
 	memset(&hd, 0, sizeof(hd));
 	hd.hd_phys_address	= hpet_address;
 	hd.hd_address		= hpet;
 	hd.hd_nirqs		= nrtimers;
 	hpet_reserve_timer(&hd, 0);
 #ifdef CONFIG_HPET_EMULATE_RTC
 	hpet_reserve_timer(&hd, 1);
 #endif
 	/*
 	 * NOTE that hd_irq[] reflects IOAPIC input pins (LEGACY_8254
 	 * is wrong for i8259!) not the output IRQ.  Many BIOS writers
 	 * don't bother configuring *any* comparator interrupts.
 	 */
 	hd.hd_irq[0] = HPET_LEGACY_8254;
 	hd.hd_irq[1] = HPET_LEGACY_RTC;
 	for (i = 2; i < nrtimers; timer++, i++) {
 		hd.hd_irq[i] = (readl(&timer->hpet_config) &
 			Tn_INT_ROUTE_CNF_MASK) >> Tn_INT_ROUTE_CNF_SHIFT;
 	}
 	hpet_reserve_msi_timers(&hd);
 	hpet_alloc(&hd);
 }
 #else
 static void hpet_reserve_platform_timers(unsigned int id) { }
 #endif
 /*
  * Common hpet info
  */
 static unsigned long hpet_freq;
 static void hpet_legacy_set_mode(enum clock_event_mode mode,
 			  struct clock_event_device *evt);
 static int hpet_legacy_next_event(unsigned long delta,
 			   struct clock_event_device *evt);
 /*
  * The hpet clock event device
  */
 static struct clock_event_device hpet_clockevent = {
 	.name		= "hpet",
 	.features	= CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
 	.set_mode	= hpet_legacy_set_mode,
 	.set_next_event = hpet_legacy_next_event,
 	.irq		= 0,
 	.rating		= 50,
 };
 static void hpet_stop_counter(void)
 {
 	unsigned long cfg = hpet_readl(HPET_CFG);
 	cfg &= ~HPET_CFG_ENABLE;
 	hpet_writel(cfg, HPET_CFG);
 }
 static void hpet_reset_counter(void)
 {
 	hpet_writel(0, HPET_COUNTER);
 	hpet_writel(0, HPET_COUNTER + 4);
 }
 static void hpet_start_counter(void)
 {
 	unsigned int cfg = hpet_readl(HPET_CFG);
 	cfg |= HPET_CFG_ENABLE;
 	hpet_writel(cfg, HPET_CFG);
 }
 static void hpet_restart_counter(void)
 {
 	hpet_stop_counter();
 	hpet_reset_counter();
 	hpet_start_counter();
 }
 static void hpet_resume_device(void)
 {
 	force_hpet_resume();
 }
 static void hpet_resume_counter(struct clocksource *cs)
 {
 	hpet_resume_device();
 	hpet_restart_counter();
 }
 static void hpet_enable_legacy_int(void)
 {
 	unsigned int cfg = hpet_readl(HPET_CFG);
 	cfg |= HPET_CFG_LEGACY;
 	hpet_writel(cfg, HPET_CFG);
 	hpet_legacy_int_enabled = 1;
 }
 static void hpet_legacy_clockevent_register(void)
 {
 	/* Start HPET legacy interrupts */
 	hpet_enable_legacy_int();
 	/*
 	 * Start hpet with the boot cpu mask and make it
 	 * global after the IO_APIC has been initialized.
 	 */
 	hpet_clockevent.cpumask = cpumask_of(smp_processor_id());
 	clockevents_config_and_register(&hpet_clockevent, hpet_freq,
 					HPET_MIN_PROG_DELTA, 0x7FFFFFFF);
 	global_clock_event = &hpet_clockevent;
 	printk(KERN_DEBUG "hpet clockevent registered\n");
 }
 static int hpet_setup_msi_irq(unsigned int irq);
 static void hpet_set_mode(enum clock_event_mode mode,
 			  struct clock_event_device *evt, int timer)
 {
 	unsigned int cfg, cmp, now;
 	uint64_t delta;
 	switch (mode) {
 	case CLOCK_EVT_MODE_PERIODIC:
 		hpet_stop_counter();
 		delta = ((uint64_t)(NSEC_PER_SEC/HZ)) * evt->mult;
 		delta >>= evt->shift;
 		now = hpet_readl(HPET_COUNTER);
 		cmp = now + (unsigned int) delta;
 		cfg = hpet_readl(HPET_Tn_CFG(timer));
 		/* Make sure we use edge triggered interrupts */
 		cfg &= ~HPET_TN_LEVEL;
 		cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC |
 		       HPET_TN_SETVAL | HPET_TN_32BIT;
 		hpet_writel(cfg, HPET_Tn_CFG(timer));
 		hpet_writel(cmp, HPET_Tn_CMP(timer));
 		udelay(1);
 		/*
 		 * HPET on AMD 81xx needs a second write (with HPET_TN_SETVAL
 		 * cleared) to T0_CMP to set the period. The HPET_TN_SETVAL
 		 * bit is automatically cleared after the first write.
 		 * (See AMD-8111 HyperTransport I/O Hub Data Sheet,
 		 * Publication # 24674)
 		 */
 		hpet_writel((unsigned int) delta, HPET_Tn_CMP(timer));
 		hpet_start_counter();
 		hpet_print_config();
 		break;
 	case CLOCK_EVT_MODE_ONESHOT:
 		cfg = hpet_readl(HPET_Tn_CFG(timer));
 		cfg &= ~HPET_TN_PERIODIC;
 		cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
 		hpet_writel(cfg, HPET_Tn_CFG(timer));
 		break;
 	case CLOCK_EVT_MODE_UNUSED:
 	case CLOCK_EVT_MODE_SHUTDOWN:
 		cfg = hpet_readl(HPET_Tn_CFG(timer));
 		cfg &= ~HPET_TN_ENABLE;
 		hpet_writel(cfg, HPET_Tn_CFG(timer));
 		break;
 	case CLOCK_EVT_MODE_RESUME:
 		if (timer == 0) {
 			hpet_enable_legacy_int();
 		} else {
 			struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 			hpet_setup_msi_irq(hdev->irq);
 			disable_irq(hdev->irq);
 			irq_set_affinity(hdev->irq, cpumask_of(hdev->cpu));
 			enable_irq(hdev->irq);
 		}
 		hpet_print_config();
 		break;
 	}
 }
 static int hpet_next_event(unsigned long delta,
 			   struct clock_event_device *evt, int timer)
 {
 	u32 cnt;
 	s32 res;
 	cnt = hpet_readl(HPET_COUNTER);
 	cnt += (u32) delta;
 	hpet_writel(cnt, HPET_Tn_CMP(timer));
 	/*
 	 * HPETs are a complete disaster. The compare register is
 	 * based on a equal comparison and neither provides a less
 	 * than or equal functionality (which would require to take
 	 * the wraparound into account) nor a simple count down event
 	 * mode. Further the write to the comparator register is
 	 * delayed internally up to two HPET clock cycles in certain
 	 * chipsets (ATI, ICH9,10). Some newer AMD chipsets have even
 	 * longer delays. We worked around that by reading back the
 	 * compare register, but that required another workaround for
 	 * ICH9,10 chips where the first readout after write can
 	 * return the old stale value. We already had a minimum
 	 * programming delta of 5us enforced, but a NMI or SMI hitting
 	 * between the counter readout and the comparator write can
 	 * move us behind that point easily. Now instead of reading
 	 * the compare register back several times, we make the ETIME
 	 * decision based on the following: Return ETIME if the
 	 * counter value after the write is less than HPET_MIN_CYCLES
 	 * away from the event or if the counter is already ahead of
 	 * the event. The minimum programming delta for the generic
 	 * clockevents code is set to 1.5 * HPET_MIN_CYCLES.
 	 */
 	res = (s32)(cnt - hpet_readl(HPET_COUNTER));
 	return res < HPET_MIN_CYCLES ? -ETIME : 0;
 }
 static void hpet_legacy_set_mode(enum clock_event_mode mode,
 			struct clock_event_device *evt)
 {
 	hpet_set_mode(mode, evt, 0);
 }
 static int hpet_legacy_next_event(unsigned long delta,
 			struct clock_event_device *evt)
 {
 	return hpet_next_event(delta, evt, 0);
 }
 /*
  * HPET MSI Support
  */
 #ifdef CONFIG_PCI_MSI
 static DEFINE_PER_CPU(struct hpet_dev *, cpu_hpet_dev);
 static struct hpet_dev	*hpet_devs;
 void hpet_msi_unmask(struct irq_data *data)
 {
 	struct hpet_dev *hdev = data->handler_data;
 	unsigned int cfg;
 	/* unmask it */
 	cfg = hpet_readl(HPET_Tn_CFG(hdev->num));
 	cfg |= HPET_TN_FSB;
 	hpet_writel(cfg, HPET_Tn_CFG(hdev->num));
 }
 void hpet_msi_mask(struct irq_data *data)
 {
 	struct hpet_dev *hdev = data->handler_data;
 	unsigned int cfg;
 	/* mask it */
 	cfg = hpet_readl(HPET_Tn_CFG(hdev->num));
 	cfg &= ~HPET_TN_FSB;
 	hpet_writel(cfg, HPET_Tn_CFG(hdev->num));
 }
 void hpet_msi_write(struct hpet_dev *hdev, struct msi_msg *msg)
 {
 	hpet_writel(msg->data, HPET_Tn_ROUTE(hdev->num));
 	hpet_writel(msg->address_lo, HPET_Tn_ROUTE(hdev->num) + 4);
 }
 void hpet_msi_read(struct hpet_dev *hdev, struct msi_msg *msg)
 {
 	msg->data = hpet_readl(HPET_Tn_ROUTE(hdev->num));
 	msg->address_lo = hpet_readl(HPET_Tn_ROUTE(hdev->num) + 4);
 	msg->address_hi = 0;
 }
 static void hpet_msi_set_mode(enum clock_event_mode mode,
 				struct clock_event_device *evt)
 {
 	struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 	hpet_set_mode(mode, evt, hdev->num);
 }
 static int hpet_msi_next_event(unsigned long delta,
 				struct clock_event_device *evt)
 {
 	struct hpet_dev *hdev = EVT_TO_HPET_DEV(evt);
 	return hpet_next_event(delta, evt, hdev->num);
 }
 static int hpet_setup_msi_irq(unsigned int irq)
 {
 	if (arch_setup_hpet_msi(irq, hpet_blockid)) {
 		destroy_irq(irq);
 		return -EINVAL;
 	}
 	return 0;
 }
 static int hpet_assign_irq(struct hpet_dev *dev)
 {
 	unsigned int irq;
 	irq = create_irq_nr(0, -1);
 	if (!irq)
 		return -EINVAL;
 	irq_set_handler_data(irq, dev);
 	if (hpet_setup_msi_irq(irq))
 		return -EINVAL;
 	dev->irq = irq;
 	return 0;
 }
 static irqreturn_t hpet_interrupt_handler(int irq, void *data)
 {
 	struct hpet_dev *dev = (struct hpet_dev *)data;
 	struct clock_event_device *hevt = &dev->evt;
 	if (!hevt->event_handler) {
 		printk(KERN_INFO "Spurious HPET timer interrupt on HPET timer %d\n",
 				dev->num);
 		return IRQ_HANDLED;
 	}
 	hevt->event_handler(hevt);
 	return IRQ_HANDLED;
 }
 static int hpet_setup_irq(struct hpet_dev *dev)
 {
 	if (request_irq(dev->irq, hpet_interrupt_handler,
 			IRQF_TIMER | IRQF_DISABLED | IRQF_NOBALANCING,
 			dev->name, dev))
 		return -1;
 	disable_irq(dev->irq);
 	irq_set_affinity(dev->irq, cpumask_of(dev->cpu));
 	enable_irq(dev->irq);
 	printk(KERN_DEBUG "hpet: %s irq %d for MSI\n",
 			 dev->name, dev->irq);
 	return 0;
 }
 /* This should be called in specific @cpu */
 static void init_one_hpet_msi_clockevent(struct hpet_dev *hdev, int cpu)
 {
 	struct clock_event_device *evt = &hdev->evt;
 	WARN_ON(cpu != smp_processor_id());
 	if (!(hdev->flags & HPET_DEV_VALID))
 		return;
 	if (hpet_setup_msi_irq(hdev->irq))
 		return;
 	hdev->cpu = cpu;
 	per_cpu(cpu_hpet_dev, cpu) = hdev;
 	evt->name = hdev->name;
 	hpet_setup_irq(hdev);
 	evt->irq = hdev->irq;
 	evt->rating = 110;
 	evt->features = CLOCK_EVT_FEAT_ONESHOT;
 	if (hdev->flags & HPET_DEV_PERI_CAP)
 		evt->features |= CLOCK_EVT_FEAT_PERIODIC;
 	evt->set_mode = hpet_msi_set_mode;
 	evt->set_next_event = hpet_msi_next_event;
 	evt->cpumask = cpumask_of(hdev->cpu);
 	clockevents_config_and_register(evt, hpet_freq, HPET_MIN_PROG_DELTA,
 					0x7FFFFFFF);
 }
 #ifdef CONFIG_HPET
 /* Reserve at least one timer for userspace (/dev/hpet) */
 #define RESERVE_TIMERS 1
 #else
 #define RESERVE_TIMERS 0
 #endif
 static void hpet_msi_capability_lookup(unsigned int start_timer)
 {
 	unsigned int id;
 	unsigned int num_timers;
 	unsigned int num_timers_used = 0;
 	int i;
 	if (hpet_msi_disable)
 		return;
 	if (boot_cpu_has(X86_FEATURE_ARAT))
 		return;
 	id = hpet_readl(HPET_ID);
 	num_timers = ((id & HPET_ID_NUMBER) >> HPET_ID_NUMBER_SHIFT);
 	num_timers++; /* Value read out starts from 0 */
 	hpet_print_config();
 	hpet_devs = kzalloc(sizeof(struct hpet_dev) * num_timers, GFP_KERNEL);
 	if (!hpet_devs)
 		return;
 	hpet_num_timers = num_timers;
 	for (i = start_timer; i < num_timers - RESERVE_TIMERS; i++) {
 		struct hpet_dev *hdev = &hpet_devs[num_timers_used];
 		unsigned int cfg = hpet_readl(HPET_Tn_CFG(i));
 		/* Only consider HPET timer with MSI support */
 		if (!(cfg & HPET_TN_FSB_CAP))
 			continue;
 		hdev->flags = 0;
 		if (cfg & HPET_TN_PERIODIC_CAP)
 			hdev->flags |= HPET_DEV_PERI_CAP;
 		hdev->num = i;
 		sprintf(hdev->name, "hpet%d", i);
 		if (hpet_assign_irq(hdev))
 			continue;
 		hdev->flags |= HPET_DEV_FSB_CAP;
 		hdev->flags |= HPET_DEV_VALID;
 		num_timers_used++;
 		if (num_timers_used == num_possible_cpus())
 			break;
 	}
 	printk(KERN_INFO "HPET: %d timers in total, %d timers will be used for per-cpu timer\n",
 		num_timers, num_timers_used);
 }
 #ifdef CONFIG_HPET
 static void hpet_reserve_msi_timers(struct hpet_data *hd)
 {
 	int i;
 	if (!hpet_devs)
 		return;
 	for (i = 0; i < hpet_num_timers; i++) {
 		struct hpet_dev *hdev = &hpet_devs[i];
 		if (!(hdev->flags & HPET_DEV_VALID))
 			continue;
 		hd->hd_irq[hdev->num] = hdev->irq;
 		hpet_reserve_timer(hd, hdev->num);
 	}
 }
 #endif
 static struct hpet_dev *hpet_get_unused_timer(void)
 {
 	int i;
 	if (!hpet_devs)
 		return NULL;
 	for (i = 0; i < hpet_num_timers; i++) {
 		struct hpet_dev *hdev = &hpet_devs[i];
 		if (!(hdev->flags & HPET_DEV_VALID))
 			continue;
 		if (test_and_set_bit(HPET_DEV_USED_BIT,
 			(unsigned long *)&hdev->flags))
 			continue;
 		return hdev;
 	}
 	return NULL;
 }
 struct hpet_work_struct {
 	struct delayed_work work;
 	struct completion complete;
 };
 static void hpet_work(struct work_struct *w)
 {
 	struct hpet_dev *hdev;
 	int cpu = smp_processor_id();
 	struct hpet_work_struct *hpet_work;
 	hpet_work = container_of(w, struct hpet_work_struct, work.work);
 	hdev = hpet_get_unused_timer();
 	if (hdev)
 		init_one_hpet_msi_clockevent(hdev, cpu);
 	complete(&hpet_work->complete);
 }
 static int hpet_cpuhp_notify(struct notifier_block *n,
 		unsigned long action, void *hcpu)
 {
 	unsigned long cpu = (unsigned long)hcpu;
 	struct hpet_work_struct work;
 	struct hpet_dev *hdev = per_cpu(cpu_hpet_dev, cpu);
 	switch (action & 0xf) {
 	case CPU_ONLINE:
 		INIT_DELAYED_WORK_ONSTACK(&work.work, hpet_work);
 		init_completion(&work.complete);
 		/* FIXME: add schedule_work_on() */
 		schedule_delayed_work_on(cpu, &work.work, 0);
 		wait_for_completion(&work.complete);
 		destroy_timer_on_stack(&work.work.timer);
 		break;
 	case CPU_DEAD:
 		if (hdev) {
 			free_irq(hdev->irq, hdev);
 			hdev->flags &= ~HPET_DEV_USED;
 			per_cpu(cpu_hpet_dev, cpu) = NULL;
 		}
 		break;
 	}
 	return NOTIFY_OK;
 }
 #else
 static int hpet_setup_msi_irq(unsigned int irq)
 {
 	return 0;
 }
 static void hpet_msi_capability_lookup(unsigned int start_timer)
 {
 	return;
 }
 #ifdef CONFIG_HPET
 static void hpet_reserve_msi_timers(struct hpet_data *hd)
 {
 	return;
 }
 #endif
 static int hpet_cpuhp_notify(struct notifier_block *n,
 		unsigned long action, void *hcpu)
 {
 	return NOTIFY_OK;
 }
 #endif
 /*
  * Clock source related code
  */
 static cycle_t read_hpet(struct clocksource *cs)
 {
 	return (cycle_t)hpet_readl(HPET_COUNTER);
 }
 static struct clocksource clocksource_hpet = {
 	.name		= "hpet",
 	.rating		= 250,
 	.read		= read_hpet,
 	.mask		= HPET_MASK,
 	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
 	.resume		= hpet_resume_counter,
 #ifdef CONFIG_X86_64
 	.archdata	= { .vclock_mode = VCLOCK_HPET },
 #endif
 };
 static int hpet_clocksource_register(void)
 {
 	u64 start, now;
 	cycle_t t1;
 	/* Start the counter */
 	hpet_restart_counter();
 	/* Verify whether hpet counter works */
 	t1 = hpet_readl(HPET_COUNTER);
 	rdtscll(start);
 	/*
 	 * We don't know the TSC frequency yet, but waiting for
 	 * 200000 TSC cycles is safe:
 	 * 4 GHz == 50us
 	 * 1 GHz == 200us
 	 */
 	do {
 		rep_nop();
 		rdtscll(now);
 	} while ((now - start) < 200000UL);
 	if (t1 == hpet_readl(HPET_COUNTER)) {
 		printk(KERN_WARNING
 		       "HPET counter not counting. HPET disabled\n");
 		return -ENODEV;
 	}
 	clocksource_register_hz(&clocksource_hpet, (u32)hpet_freq);
 	return 0;
 }
 /**
  * hpet_enable - Try to setup the HPET timer. Returns 1 on success.
  */
 int __init hpet_enable(void)
 {
 	unsigned long hpet_period;
 	unsigned int id;
 	u64 freq;
 	int i;
 	if (!is_hpet_capable())
 		return 0;
 	hpet_set_mapping();
 	/*
 	 * Read the period and check for a sane value:
 	 */
 	hpet_period = hpet_readl(HPET_PERIOD);
 	/*
 	 * AMD SB700 based systems with spread spectrum enabled use a
 	 * SMM based HPET emulation to provide proper frequency
 	 * setting. The SMM code is initialized with the first HPET
 	 * register access and takes some time to complete. During
 	 * this time the config register reads 0xffffffff. We check
 	 * for max. 1000 loops whether the config register reads a non
 	 * 0xffffffff value to make sure that HPET is up and running
 	 * before we go further. A counting loop is safe, as the HPET
 	 * access takes thousands of CPU cycles. On non SB700 based
 	 * machines this check is only done once and has no side
 	 * effects.
 	 */
 	for (i = 0; hpet_readl(HPET_CFG) == 0xFFFFFFFF; i++) {
 		if (i == 1000) {
 			printk(KERN_WARNING
 			       "HPET config register value = 0xFFFFFFFF. "
 			       "Disabling HPET\n");
 			goto out_nohpet;
 		}
 	}
 	if (hpet_period < HPET_MIN_PERIOD || hpet_period > HPET_MAX_PERIOD)
 		goto out_nohpet;
 	/*
 	 * The period is a femto seconds value. Convert it to a
 	 * frequency.
 	 */
 	freq = FSEC_PER_SEC;
 	do_div(freq, hpet_period);
 	hpet_freq = freq;
 	/*
 	 * Read the HPET ID register to retrieve the IRQ routing
 	 * information and the number of channels
 	 */
 	id = hpet_readl(HPET_ID);
 	hpet_print_config();
 #ifdef CONFIG_HPET_EMULATE_RTC
 	/*
 	 * The legacy routing mode needs at least two channels, tick timer
 	 * and the rtc emulation channel.
 	 */
 	if (!(id & HPET_ID_NUMBER))
 		goto out_nohpet;
 #endif
 	if (hpet_clocksource_register())
 		goto out_nohpet;
 	if (id & HPET_ID_LEGSUP) {
 		hpet_legacy_clockevent_register();
 		return 1;
 	}
 	return 0;
 out_nohpet:
 	hpet_clear_mapping();
 	hpet_address = 0;
 	return 0;
 }
 /*
  * Needs to be late, as the reserve_timer code calls kalloc !
  *
  * Not a problem on i386 as hpet_enable is called from late_time_init,
  * but on x86_64 it is necessary !
  */
 static __init int hpet_late_init(void)
 {
 	int cpu;
 	if (boot_hpet_disable)
 		return -ENODEV;
 	if (!hpet_address) {
 		if (!force_hpet_address)
 			return -ENODEV;
 		hpet_address = force_hpet_address;
 		hpet_enable();
 	}
 	if (!hpet_virt_address)
 		return -ENODEV;
 	if (hpet_readl(HPET_ID) & HPET_ID_LEGSUP)
 		hpet_msi_capability_lookup(2);
 	else
 		hpet_msi_capability_lookup(0);
 	hpet_reserve_platform_timers(hpet_readl(HPET_ID));
 	hpet_print_config();
 	if (hpet_msi_disable)
 		return 0;
 	if (boot_cpu_has(X86_FEATURE_ARAT))
 		return 0;
 	for_each_online_cpu(cpu) {
 		hpet_cpuhp_notify(NULL, CPU_ONLINE, (void *)(long)cpu);
 	}
 	/* This notifier should be called after workqueue is ready */
 	hotcpu_notifier(hpet_cpuhp_notify, -20);
 	return 0;
 }
 fs_initcall(hpet_late_init);
 void hpet_disable(void)
 {
 	if (is_hpet_capable() && hpet_virt_address) {
 		unsigned int cfg = hpet_readl(HPET_CFG);
 		if (hpet_legacy_int_enabled) {
 			cfg &= ~HPET_CFG_LEGACY;
 			hpet_legacy_int_enabled = 0;
 		}
 		cfg &= ~HPET_CFG_ENABLE;
 		hpet_writel(cfg, HPET_CFG);
 	}
 }
 #ifdef CONFIG_HPET_EMULATE_RTC
 /* HPET in LegacyReplacement Mode eats up RTC interrupt line. When, HPET
  * is enabled, we support RTC interrupt functionality in software.
  * RTC has 3 kinds of interrupts:
  * 1) Update Interrupt - generate an interrupt, every sec, when RTC clock
  *    is updated
  * 2) Alarm Interrupt - generate an interrupt at a specific time of day
  * 3) Periodic Interrupt - generate periodic interrupt, with frequencies
  *    2Hz-8192Hz (2Hz-64Hz for non-root user) (all freqs in powers of 2)
  * (1) and (2) above are implemented using polling at a frequency of
  * 64 Hz. The exact frequency is a tradeoff between accuracy and interrupt
  * overhead. (DEFAULT_RTC_INT_FREQ)
  * For (3), we use interrupts at 64Hz or user specified periodic
  * frequency, whichever is higher.
  */
 #include <linux/mc146818rtc.h>
 #include <linux/rtc.h>
 #include <asm/rtc.h>
 #define DEFAULT_RTC_INT_FREQ	64
 #define DEFAULT_RTC_SHIFT	6
 #define RTC_NUM_INTS		1
 static unsigned long hpet_rtc_flags;
 static int hpet_prev_update_sec;
 static struct rtc_time hpet_alarm_time;
 static unsigned long hpet_pie_count;
 static u32 hpet_t1_cmp;
 static u32 hpet_default_delta;
 static u32 hpet_pie_delta;
 static unsigned long hpet_pie_limit;
 static rtc_irq_handler irq_handler;
 /*
  * Check that the hpet counter c1 is ahead of the c2
  */
 static inline int hpet_cnt_ahead(u32 c1, u32 c2)
 {
 	return (s32)(c2 - c1) < 0;
 }
 /*
  * Registers a IRQ handler.
  */
 int hpet_register_irq_handler(rtc_irq_handler handler)
 {
 	if (!is_hpet_enabled())
 		return -ENODEV;
 	if (irq_handler)
 		return -EBUSY;
 	irq_handler = handler;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(hpet_register_irq_handler);
 /*
  * Deregisters the IRQ handler registered with hpet_register_irq_handler()
  * and does cleanup.
  */
 void hpet_unregister_irq_handler(rtc_irq_handler handler)
 {
 	if (!is_hpet_enabled())
 		return;
 	irq_handler = NULL;
 	hpet_rtc_flags = 0;
 }
 EXPORT_SYMBOL_GPL(hpet_unregister_irq_handler);
 /*
  * Timer 1 for RTC emulation. We use one shot mode, as periodic mode
  * is not supported by all HPET implementations for timer 1.
  *
  * hpet_rtc_timer_init() is called when the rtc is initialized.
  */
 int hpet_rtc_timer_init(void)
 {
 	unsigned int cfg, cnt, delta;
 	unsigned long flags;
 	if (!is_hpet_enabled())
 		return 0;
 	if (!hpet_default_delta) {
 		uint64_t clc;
 		clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
 		clc >>= hpet_clockevent.shift + DEFAULT_RTC_SHIFT;
 		hpet_default_delta = clc;
 	}
 	if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
 		delta = hpet_default_delta;
 	else
 		delta = hpet_pie_delta;
 	local_irq_save(flags);
 	cnt = delta + hpet_readl(HPET_COUNTER);
 	hpet_writel(cnt, HPET_T1_CMP);
 	hpet_t1_cmp = cnt;
 	cfg = hpet_readl(HPET_T1_CFG);
 	cfg &= ~HPET_TN_PERIODIC;
 	cfg |= HPET_TN_ENABLE | HPET_TN_32BIT;
 	hpet_writel(cfg, HPET_T1_CFG);
 	local_irq_restore(flags);
 	return 1;
 }
 EXPORT_SYMBOL_GPL(hpet_rtc_timer_init);
+static void hpet_disable_rtc_channel(void)
+{
+	unsigned long cfg;
+	cfg = hpet_readl(HPET_T1_CFG);
+	cfg &= ~HPET_TN_ENABLE;
+	hpet_writel(cfg, HPET_T1_CFG);
+}
 /*
  * The functions below are called from rtc driver.
  * Return 0 if HPET is not being used.
  * Otherwise do the necessary changes and return 1.
  */
 int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
 {
 	if (!is_hpet_enabled())
 		return 0;
 	hpet_rtc_flags &= ~bit_mask;
+	if (unlikely(!hpet_rtc_flags))
+		hpet_disable_rtc_channel();
 	return 1;
 }
 EXPORT_SYMBOL_GPL(hpet_mask_rtc_irq_bit);
 int hpet_set_rtc_irq_bit(unsigned long bit_mask)
 {
 	unsigned long oldbits = hpet_rtc_flags;
 	if (!is_hpet_enabled())
 		return 0;
 	hpet_rtc_flags |= bit_mask;
 	if ((bit_mask & RTC_UIE) && !(oldbits & RTC_UIE))
 		hpet_prev_update_sec = -1;
 	if (!oldbits)
 		hpet_rtc_timer_init();
 	return 1;
 }
 EXPORT_SYMBOL_GPL(hpet_set_rtc_irq_bit);
 int hpet_set_alarm_time(unsigned char hrs, unsigned char min,
 			unsigned char sec)
 {
 	if (!is_hpet_enabled())
 		return 0;
 	hpet_alarm_time.tm_hour = hrs;
 	hpet_alarm_time.tm_min = min;
 	hpet_alarm_time.tm_sec = sec;
 	return 1;
 }
 EXPORT_SYMBOL_GPL(hpet_set_alarm_time);
 int hpet_set_periodic_freq(unsigned long freq)
 {
 	uint64_t clc;
 	if (!is_hpet_enabled())
 		return 0;
 	if (freq <= DEFAULT_RTC_INT_FREQ)
 		hpet_pie_limit = DEFAULT_RTC_INT_FREQ / freq;
 	else {
 		clc = (uint64_t) hpet_clockevent.mult * NSEC_PER_SEC;
 		do_div(clc, freq);
 		clc >>= hpet_clockevent.shift;
 		hpet_pie_delta = clc;
 		hpet_pie_limit = 0;
 	}
 	return 1;
 }
 EXPORT_SYMBOL_GPL(hpet_set_periodic_freq);
 int hpet_rtc_dropped_irq(void)
 {
 	return is_hpet_enabled();
 }
 EXPORT_SYMBOL_GPL(hpet_rtc_dropped_irq);
 static void hpet_rtc_timer_reinit(void)
 {
-	unsigned int cfg, delta;
+	unsigned int delta;
 	int lost_ints = -1;
-	if (unlikely(!hpet_rtc_flags)) {
+	if (unlikely(!hpet_rtc_flags))
-		cfg = hpet_readl(HPET_T1_CFG);
+		hpet_disable_rtc_channel();
-		cfg &= ~HPET_TN_ENABLE;
-		hpet_writel(cfg, HPET_T1_CFG);
-		return;
-	}
 	if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
 		delta = hpet_default_delta;
 	else
 		delta = hpet_pie_delta;
 	/*
 	 * Increment the comparator value until we are ahead of the
 	 * current count.
 	 */
 	do {
 		hpet_t1_cmp += delta;
 		hpet_writel(hpet_t1_cmp, HPET_T1_CMP);
 		lost_ints++;
 	} while (!hpet_cnt_ahead(hpet_t1_cmp, hpet_readl(HPET_COUNTER)));
 	if (lost_ints) {
 		if (hpet_rtc_flags & RTC_PIE)
 			hpet_pie_count += lost_ints;
 		if (printk_ratelimit())
 			printk(KERN_WARNING "hpet1: lost %d rtc interrupts\n",
 				lost_ints);
 	}
 }
 irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
 {
 	struct rtc_time curr_time;
 	unsigned long rtc_int_flag = 0;
 	hpet_rtc_timer_reinit();
 	memset(&curr_time, 0, sizeof(struct rtc_time));
 	if (hpet_rtc_flags & (RTC_UIE | RTC_AIE))
 		get_rtc_time(&curr_time);
 	if (hpet_rtc_flags & RTC_UIE &&
 	    curr_time.tm_sec != hpet_prev_update_sec) {
 		if (hpet_prev_update_sec >= 0)
 			rtc_int_flag = RTC_UF;
 		hpet_prev_update_sec = curr_time.tm_sec;
 	}
 	if (hpet_rtc_flags & RTC_PIE &&
 	    ++hpet_pie_count >= hpet_pie_limit) {
 		rtc_int_flag |= RTC_PF;
 		hpet_pie_count = 0;
 	}
 	if (hpet_rtc_flags & RTC_AIE &&
 	    (curr_time.tm_sec == hpet_alarm_time.tm_sec) &&
 	    (curr_time.tm_min == hpet_alarm_time.tm_min) &&
 	    (curr_time.tm_hour == hpet_alarm_time.tm_hour))
 			rtc_int_flag |= RTC_AF;
 	if (rtc_int_flag) {
 		rtc_int_flag |= (RTC_IRQF | (RTC_NUM_INTS << 8));
 		if (irq_handler)
 			irq_handler(rtc_int_flag, dev_id);
 	}
 	return IRQ_HANDLED;

arch/x86/kernel/setup.c

Diff comments View file @ a776878

 /*
  *  Copyright (C) 1995  Linus Torvalds
  *
  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
  *
  *  Memory region support
  *	David Parsons <orc@pell.chi.il.us>, July-August 1999
  *
  *  Added E820 sanitization routine (removes overlapping memory regions);
  *  Brian Moyle <bmoyle@mvista.com>, February 2001
  *
  * Moved CPU detection code to cpu/${cpu}.c
  *    Patrick Mochel <mochel@osdl.org>, March 2002
  *
  *  Provisions for empty E820 memory regions (reported by certain BIOSes).
  *  Alex Achenbach <xela@slit.de>, December 2002.
  *
  */
 /*
  * This file handles the architecture-dependent parts of initialization
  */
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 #include <linux/screen_info.h>
 #include <linux/ioport.h>
 #include <linux/acpi.h>
 #include <linux/sfi.h>
 #include <linux/apm_bios.h>
 #include <linux/initrd.h>
 #include <linux/bootmem.h>
 #include <linux/memblock.h>
 #include <linux/seq_file.h>
 #include <linux/console.h>
 #include <linux/mca.h>
 #include <linux/root_dev.h>
 #include <linux/highmem.h>
 #include <linux/module.h>
 #include <linux/efi.h>
 #include <linux/init.h>
 #include <linux/edd.h>
 #include <linux/iscsi_ibft.h>
 #include <linux/nodemask.h>
 #include <linux/kexec.h>
 #include <linux/dmi.h>
 #include <linux/pfn.h>
 #include <linux/pci.h>
 #include <asm/pci-direct.h>
 #include <linux/init_ohci1394_dma.h>
 #include <linux/kvm_para.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/ptrace.h>
 #include <linux/user.h>
 #include <linux/delay.h>
 #include <linux/kallsyms.h>
 #include <linux/cpufreq.h>
 #include <linux/dma-mapping.h>
 #include <linux/ctype.h>
 #include <linux/uaccess.h>
 #include <linux/percpu.h>
 #include <linux/crash_dump.h>
 #include <linux/tboot.h>
 #include <video/edid.h>
 #include <asm/mtrr.h>
 #include <asm/apic.h>
 #include <asm/trampoline.h>
 #include <asm/e820.h>
 #include <asm/mpspec.h>
 #include <asm/setup.h>
 #include <asm/efi.h>
 #include <asm/timer.h>
 #include <asm/i8259.h>
 #include <asm/sections.h>
 #include <asm/dmi.h>
 #include <asm/io_apic.h>
 #include <asm/ist.h>
 #include <asm/setup_arch.h>
 #include <asm/bios_ebda.h>
 #include <asm/cacheflush.h>
 #include <asm/processor.h>
 #include <asm/bugs.h>
 #include <asm/system.h>
 #include <asm/vsyscall.h>
 #include <asm/cpu.h>
 #include <asm/desc.h>
 #include <asm/dma.h>
 #include <asm/iommu.h>
 #include <asm/gart.h>
 #include <asm/mmu_context.h>
 #include <asm/proto.h>
 #include <asm/paravirt.h>
 #include <asm/hypervisor.h>
 #include <asm/olpc_ofw.h>
 #include <asm/percpu.h>
 #include <asm/topology.h>
 #include <asm/apicdef.h>
 #include <asm/amd_nb.h>
 #ifdef CONFIG_X86_64
 #include <asm/numa_64.h>
 #endif
 #include <asm/mce.h>
 #include <asm/alternative.h>
 #include <asm/prom.h>
 /*
  * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries.
  * The direct mapping extends to max_pfn_mapped, so that we can directly access
  * apertures, ACPI and other tables without having to play with fixmaps.
  */
 unsigned long max_low_pfn_mapped;
 unsigned long max_pfn_mapped;
 #ifdef CONFIG_DMI
 RESERVE_BRK(dmi_alloc, 65536);
 #endif
 static __initdata unsigned long _brk_start = (unsigned long)__brk_base;
 unsigned long _brk_end = (unsigned long)__brk_base;
 #ifdef CONFIG_X86_64
 int default_cpu_present_to_apicid(int mps_cpu)
 {
 	return __default_cpu_present_to_apicid(mps_cpu);
 }
 int default_check_phys_apicid_present(int phys_apicid)
 {
 	return __default_check_phys_apicid_present(phys_apicid);
 }
 #endif
 #ifndef CONFIG_DEBUG_BOOT_PARAMS
 struct boot_params __initdata boot_params;
 #else
 struct boot_params boot_params;
 #endif
 /*
  * Machine setup..
  */
 static struct resource data_resource = {
 	.name	= "Kernel data",
 	.start	= 0,
 	.end	= 0,
 	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
 };
 static struct resource code_resource = {
 	.name	= "Kernel code",
 	.start	= 0,
 	.end	= 0,
 	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
 };
 static struct resource bss_resource = {
 	.name	= "Kernel bss",
 	.start	= 0,
 	.end	= 0,
 	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
 };
 #ifdef CONFIG_X86_32
 /* cpu data as detected by the assembly code in head.S */
 struct cpuinfo_x86 new_cpu_data __cpuinitdata = {0, 0, 0, 0, -1, 1, 0, 0, -1};
 /* common cpu data for all cpus */
 struct cpuinfo_x86 boot_cpu_data __read_mostly = {0, 0, 0, 0, -1, 1, 0, 0, -1};
 EXPORT_SYMBOL(boot_cpu_data);
 static void set_mca_bus(int x)
 {
 #ifdef CONFIG_MCA
 	MCA_bus = x;
 #endif
 }
 unsigned int def_to_bigsmp;
 /* for MCA, but anyone else can use it if they want */
 unsigned int machine_id;
 unsigned int machine_submodel_id;
 unsigned int BIOS_revision;
 struct apm_info apm_info;
 EXPORT_SYMBOL(apm_info);
 #if defined(CONFIG_X86_SPEEDSTEP_SMI) || \
 	defined(CONFIG_X86_SPEEDSTEP_SMI_MODULE)
 struct ist_info ist_info;
 EXPORT_SYMBOL(ist_info);
 #else
 struct ist_info ist_info;
 #endif
 #else
 struct cpuinfo_x86 boot_cpu_data __read_mostly = {
 	.x86_phys_bits = MAX_PHYSMEM_BITS,
 };
 EXPORT_SYMBOL(boot_cpu_data);
 #endif
 #if !defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
 unsigned long mmu_cr4_features;
 #else
 unsigned long mmu_cr4_features = X86_CR4_PAE;
 #endif
 /* Boot loader ID and version as integers, for the benefit of proc_dointvec */
 int bootloader_type, bootloader_version;
 /*
  * Setup options
  */
 struct screen_info screen_info;
 EXPORT_SYMBOL(screen_info);
 struct edid_info edid_info;
 EXPORT_SYMBOL_GPL(edid_info);
 extern int root_mountflags;
 unsigned long saved_video_mode;
 #define RAMDISK_IMAGE_START_MASK	0x07FF
 #define RAMDISK_PROMPT_FLAG		0x8000
 #define RAMDISK_LOAD_FLAG		0x4000
 static char __initdata command_line[COMMAND_LINE_SIZE];
 #ifdef CONFIG_CMDLINE_BOOL
 static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
 #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 __init 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 __init copy_edd(void)
 {
 }
 #endif
 void * __init extend_brk(size_t size, size_t align)
 {
 	size_t mask = align - 1;
 	void *ret;
 	BUG_ON(_brk_start == 0);
 	BUG_ON(align & mask);
 	_brk_end = (_brk_end + mask) & ~mask;
 	BUG_ON((char *)(_brk_end + size) > __brk_limit);
 	ret = (void *)_brk_end;
 	_brk_end += size;
 	memset(ret, 0, size);
 	return ret;
 }
 #ifdef CONFIG_X86_64
 static void __init init_gbpages(void)
 {
 	if (direct_gbpages && cpu_has_gbpages)
 		printk(KERN_INFO "Using GB pages for direct mapping\n");
 	else
 		direct_gbpages = 0;
 }
 #else
 static inline void init_gbpages(void)
 {
 }
 static void __init cleanup_highmap(void)
 {
 }
 #endif
 static void __init reserve_brk(void)
 {
 	if (_brk_end > _brk_start)
 		memblock_x86_reserve_range(__pa(_brk_start), __pa(_brk_end), "BRK");
 	/* Mark brk area as locked down and no longer taking any
 	   new allocations */
 	_brk_start = 0;
 }
 #ifdef CONFIG_BLK_DEV_INITRD
 #define MAX_MAP_CHUNK	(NR_FIX_BTMAPS << PAGE_SHIFT)
 static void __init relocate_initrd(void)
 {
 	/* Assume only end is not page aligned */
 	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
 	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
 	u64 area_size     = PAGE_ALIGN(ramdisk_size);
 	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
 	u64 ramdisk_here;
 	unsigned long slop, clen, mapaddr;
 	char *p, *q;
 	/* We need to move the initrd down into lowmem */
 	ramdisk_here = memblock_find_in_range(0, end_of_lowmem, area_size,
 					 PAGE_SIZE);
 	if (ramdisk_here == MEMBLOCK_ERROR)
 		panic("Cannot find place for new RAMDISK of size %lld\n",
 			 ramdisk_size);
 	/* Note: this includes all the lowmem currently occupied by
 	   the initrd, we rely on that fact to keep the data intact. */
 	memblock_x86_reserve_range(ramdisk_here, ramdisk_here + area_size, "NEW RAMDISK");
 	initrd_start = ramdisk_here + PAGE_OFFSET;
 	initrd_end   = initrd_start + ramdisk_size;
 	printk(KERN_INFO "Allocated new RAMDISK: %08llx - %08llx\n",
 			 ramdisk_here, ramdisk_here + ramdisk_size);
 	q = (char *)initrd_start;
 	/* Copy any lowmem portion of the initrd */
 	if (ramdisk_image < end_of_lowmem) {
 		clen = end_of_lowmem - ramdisk_image;
 		p = (char *)__va(ramdisk_image);
 		memcpy(q, p, clen);
 		q += clen;
 		ramdisk_image += clen;
 		ramdisk_size  -= clen;
 	}
 	/* Copy the highmem portion of the initrd */
 	while (ramdisk_size) {
 		slop = ramdisk_image & ~PAGE_MASK;
 		clen = ramdisk_size;
 		if (clen > MAX_MAP_CHUNK-slop)
 			clen = MAX_MAP_CHUNK-slop;
 		mapaddr = ramdisk_image & PAGE_MASK;
 		p = early_memremap(mapaddr, clen+slop);
 		memcpy(q, p+slop, clen);
 		early_iounmap(p, clen+slop);
 		q += clen;
 		ramdisk_image += clen;
 		ramdisk_size  -= clen;
 	}
 	/* high pages is not converted by early_res_to_bootmem */
 	ramdisk_image = boot_params.hdr.ramdisk_image;
 	ramdisk_size  = boot_params.hdr.ramdisk_size;
 	printk(KERN_INFO "Move RAMDISK from %016llx - %016llx to"
 		" %08llx - %08llx\n",
 		ramdisk_image, ramdisk_image + ramdisk_size - 1,
 		ramdisk_here, ramdisk_here + ramdisk_size - 1);
 }
 static void __init reserve_initrd(void)
 {
 	/* Assume only end is not page aligned */
 	u64 ramdisk_image = boot_params.hdr.ramdisk_image;
 	u64 ramdisk_size  = boot_params.hdr.ramdisk_size;
 	u64 ramdisk_end   = PAGE_ALIGN(ramdisk_image + ramdisk_size);
 	u64 end_of_lowmem = max_low_pfn_mapped << PAGE_SHIFT;
 	if (!boot_params.hdr.type_of_loader ||
 	    !ramdisk_image || !ramdisk_size)
 		return;		/* No initrd provided by bootloader */
 	initrd_start = 0;
 	if (ramdisk_size >= (end_of_lowmem>>1)) {
 		memblock_x86_free_range(ramdisk_image, ramdisk_end);
 		printk(KERN_ERR "initrd too large to handle, "
 		       "disabling initrd\n");
 		return;
 	}
 	printk(KERN_INFO "RAMDISK: %08llx - %08llx\n", ramdisk_image,
 			ramdisk_end);
 	if (ramdisk_end <= end_of_lowmem) {
 		/* All in lowmem, easy case */
 		/*
 		 * don't need to reserve again, already reserved early
 		 * in i386_start_kernel
 		 */
 		initrd_start = ramdisk_image + PAGE_OFFSET;
 		initrd_end = initrd_start + ramdisk_size;
 		return;
 	}
 	relocate_initrd();
 	memblock_x86_free_range(ramdisk_image, ramdisk_end);
 }
 #else
 static void __init reserve_initrd(void)
 {
 }
 #endif /* CONFIG_BLK_DEV_INITRD */
 static void __init parse_setup_data(void)
 {
 	struct setup_data *data;
 	u64 pa_data;
 	if (boot_params.hdr.version < 0x0209)
 		return;
 	pa_data = boot_params.hdr.setup_data;
 	while (pa_data) {
 		u32 data_len, map_len;
 		map_len = max(PAGE_SIZE - (pa_data & ~PAGE_MASK),
 			      (u64)sizeof(struct setup_data));
 		data = early_memremap(pa_data, map_len);
 		data_len = data->len + sizeof(struct setup_data);
 		if (data_len > map_len) {
 			early_iounmap(data, map_len);
 			data = early_memremap(pa_data, data_len);
 			map_len = data_len;
 		}
 		switch (data->type) {
 		case SETUP_E820_EXT:
 			parse_e820_ext(data);
 			break;
 		case SETUP_DTB:
 			add_dtb(pa_data);
 			break;
 		default:
 			break;
 		}
 		pa_data = data->next;
 		early_iounmap(data, map_len);
 	}
 }
 static void __init e820_reserve_setup_data(void)
 {
 	struct setup_data *data;
 	u64 pa_data;
 	int found = 0;
 	if (boot_params.hdr.version < 0x0209)
 		return;
 	pa_data = boot_params.hdr.setup_data;
 	while (pa_data) {
 		data = early_memremap(pa_data, sizeof(*data));
 		e820_update_range(pa_data, sizeof(*data)+data->len,
 			 E820_RAM, E820_RESERVED_KERN);
 		found = 1;
 		pa_data = data->next;
 		early_iounmap(data, sizeof(*data));
 	}
 	if (!found)
 		return;
 	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
 	memcpy(&e820_saved, &e820, sizeof(struct e820map));
 	printk(KERN_INFO "extended physical RAM map:\n");
 	e820_print_map("reserve setup_data");
 }
 static void __init memblock_x86_reserve_range_setup_data(void)
 {
 	struct setup_data *data;
 	u64 pa_data;
 	char buf[32];
 	if (boot_params.hdr.version < 0x0209)
 		return;
 	pa_data = boot_params.hdr.setup_data;
 	while (pa_data) {
 		data = early_memremap(pa_data, sizeof(*data));
 		sprintf(buf, "setup data %x", data->type);
 		memblock_x86_reserve_range(pa_data, pa_data+sizeof(*data)+data->len, buf);
 		pa_data = data->next;
 		early_iounmap(data, sizeof(*data));
 	}
 }
 /*
  * --------- Crashkernel reservation ------------------------------
  */
 #ifdef CONFIG_KEXEC
 static inline unsigned long long get_total_mem(void)
 {
 	unsigned long long total;
 	total = max_pfn - min_low_pfn;
 	return total << PAGE_SHIFT;
 }
 /*
  * Keep the crash kernel below this limit.  On 32 bits earlier kernels
  * would limit the kernel to the low 512 MiB due to mapping restrictions.
  * On 64 bits, kexec-tools currently limits us to 896 MiB; increase this
  * limit once kexec-tools are fixed.
  */
 #ifdef CONFIG_X86_32
 # define CRASH_KERNEL_ADDR_MAX	(512 << 20)
 #else
 # define CRASH_KERNEL_ADDR_MAX	(896 << 20)
 #endif
 static void __init reserve_crashkernel(void)
 {
 	unsigned long long total_mem;
 	unsigned long long crash_size, crash_base;
 	int ret;
 	total_mem = get_total_mem();
 	ret = parse_crashkernel(boot_command_line, total_mem,
 			&crash_size, &crash_base);
 	if (ret != 0 || crash_size <= 0)
 		return;
 	/* 0 means: find the address automatically */
 	if (crash_base <= 0) {
 		const unsigned long long alignment = 16<<20;	/* 16M */
 		/*
 		 *  kexec want bzImage is below CRASH_KERNEL_ADDR_MAX
 		 */
 		crash_base = memblock_find_in_range(alignment,
 			       CRASH_KERNEL_ADDR_MAX, crash_size, alignment);
 		if (crash_base == MEMBLOCK_ERROR) {
 			pr_info("crashkernel reservation failed - No suitable area found.\n");
 			return;
 		}
 	} else {
 		unsigned long long start;
 		start = memblock_find_in_range(crash_base,
 				 crash_base + crash_size, crash_size, 1<<20);
 		if (start != crash_base) {
 			pr_info("crashkernel reservation failed - memory is in use.\n");
 			return;
 		}
 	}
 	memblock_x86_reserve_range(crash_base, crash_base + crash_size, "CRASH KERNEL");
 	printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
 			"for crashkernel (System RAM: %ldMB)\n",
 			(unsigned long)(crash_size >> 20),
 			(unsigned long)(crash_base >> 20),
 			(unsigned long)(total_mem >> 20));
 	crashk_res.start = crash_base;
 	crashk_res.end   = crash_base + crash_size - 1;
 	insert_resource(&iomem_resource, &crashk_res);
 }
 #else
 static void __init reserve_crashkernel(void)
 {
 }
 #endif
 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 }
 };
 void __init reserve_standard_io_resources(void)
 {
 	int i;
 	/* 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]);
 }
 static __init void reserve_ibft_region(void)
 {
 	unsigned long addr, size = 0;
 	addr = find_ibft_region(&size);
 	if (size)
 		memblock_x86_reserve_range(addr, addr + size, "* ibft");
 }
 static unsigned reserve_low = CONFIG_X86_RESERVE_LOW << 10;
 static void __init trim_bios_range(void)
 {
 	/*
 	 * A special case is the first 4Kb of memory;
 	 * This is a BIOS owned area, not kernel ram, but generally
 	 * not listed as such in the E820 table.
 	 *
 	 * This typically reserves additional memory (64KiB by default)
 	 * since some BIOSes are known to corrupt low memory.  See the
 	 * Kconfig help text for X86_RESERVE_LOW.
 	 */
 	e820_update_range(0, ALIGN(reserve_low, PAGE_SIZE),
 			  E820_RAM, E820_RESERVED);
 	/*
 	 * special case: Some BIOSen report the PC BIOS
 	 * area (640->1Mb) as ram even though it is not.
 	 * take them out.
 	 */
 	e820_remove_range(BIOS_BEGIN, BIOS_END - BIOS_BEGIN, E820_RAM, 1);
 	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
 }
 static int __init parse_reservelow(char *p)
 {
 	unsigned long long size;
 	if (!p)
 		return -EINVAL;
 	size = memparse(p, &p);
 	if (size < 4096)
 		size = 4096;
 	if (size > 640*1024)
 		size = 640*1024;
 	reserve_low = size;
 	return 0;
 }
 early_param("reservelow", parse_reservelow);
 /*
  * Determine if we were loaded by an EFI loader.  If so, then we have also been
  * passed the efi memmap, systab, etc., so we should use these data structures
  * for initialization.  Note, the efi init code path is determined by the
  * global efi_enabled. This allows the same kernel image to be used on existing
  * systems (with a traditional BIOS) as well as on EFI systems.
  */
 /*
  * 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 long end_pfn;
 #ifdef CONFIG_X86_32
 	memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
 	visws_early_detect();
 	/*
 	 * copy kernel address range established so far and switch
 	 * to the proper swapper page table
 	 */
 	clone_pgd_range(swapper_pg_dir     + KERNEL_PGD_BOUNDARY,
 			initial_page_table + KERNEL_PGD_BOUNDARY,
 			KERNEL_PGD_PTRS);
 	load_cr3(swapper_pg_dir);
 	__flush_tlb_all();
 #else
 	printk(KERN_INFO "Command line: %s\n", boot_command_line);
 #endif
 	/*
 	 * If we have OLPC OFW, we might end up relocating the fixmap due to
 	 * reserve_top(), so do this before touching the ioremap area.
 	 */
 	olpc_ofw_detect();
 	early_trap_init();
 	early_cpu_init();
 	early_ioremap_init();
 	setup_olpc_ofw_pgd();
 	ROOT_DEV = old_decode_dev(boot_params.hdr.root_dev);
 	screen_info = boot_params.screen_info;
 	edid_info = boot_params.edid_info;
 #ifdef CONFIG_X86_32
 	apm_info.bios = boot_params.apm_bios_info;
 	ist_info = boot_params.ist_info;
 	if (boot_params.sys_desc_table.length != 0) {
 		set_mca_bus(boot_params.sys_desc_table.table[3] & 0x2);
 		machine_id = boot_params.sys_desc_table.table[0];
 		machine_submodel_id = boot_params.sys_desc_table.table[1];
 		BIOS_revision = boot_params.sys_desc_table.table[2];
 	}
 #endif
 	saved_video_mode = boot_params.hdr.vid_mode;
 	bootloader_type = boot_params.hdr.type_of_loader;
 	if ((bootloader_type >> 4) == 0xe) {
 		bootloader_type &= 0xf;
 		bootloader_type |= (boot_params.hdr.ext_loader_type+0x10) << 4;
 	}
 	bootloader_version  = bootloader_type & 0xf;
 	bootloader_version |= boot_params.hdr.ext_loader_ver << 4;
 #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,
 #ifdef CONFIG_X86_32
 		     "EL32",
 #else
 		     "EL64",
 #endif
 	 4)) {
 		efi_enabled = 1;
 		efi_memblock_x86_reserve_range();
 	}
 #endif
 	x86_init.oem.arch_setup();
 	iomem_resource.end = (1ULL << boot_cpu_data.x86_phys_bits) - 1;
 	setup_memory_map();
 	parse_setup_data();
 	/* update the e820_saved too */
 	e820_reserve_setup_data();
 	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 = _brk_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;
 #ifdef CONFIG_CMDLINE_BOOL
 #ifdef CONFIG_CMDLINE_OVERRIDE
 	strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
 #else
 	if (builtin_cmdline[0]) {
 		/* append boot loader cmdline to builtin */
 		strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE);
 		strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE);
 		strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
 	}
 #endif
 #endif
 	strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
 	*cmdline_p = command_line;
 	/*
 	 * x86_configure_nx() is called before parse_early_param() to detect
 	 * whether hardware doesn't support NX (so that the early EHCI debug
 	 * console setup can safely call set_fixmap()). It may then be called
 	 * again from within noexec_setup() during parsing early parameters
 	 * to honor the respective command line option.
 	 */
 	x86_configure_nx();
 	parse_early_param();
 	x86_report_nx();
 	/* after early param, so could get panic from serial */
 	memblock_x86_reserve_range_setup_data();
 	if (acpi_mps_check()) {
 #ifdef CONFIG_X86_LOCAL_APIC
 		disable_apic = 1;
 #endif
 		setup_clear_cpu_cap(X86_FEATURE_APIC);
 	}
 #ifdef CONFIG_PCI
 	if (pci_early_dump_regs)
 		early_dump_pci_devices();
 #endif
 	finish_e820_parsing();
 	if (efi_enabled)
 		efi_init();
 	dmi_scan_machine();
 	/*
 	 * VMware detection requires dmi to be available, so this
 	 * needs to be done after dmi_scan_machine, for the BP.
 	 */
 	init_hypervisor_platform();
 	x86_init.resources.probe_roms();
 	/* 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);
 	trim_bios_range();
 #ifdef CONFIG_X86_32
 	if (ppro_with_ram_bug()) {
 		e820_update_range(0x70000000ULL, 0x40000ULL, E820_RAM,
 				  E820_RESERVED);
 		sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
 		printk(KERN_INFO "fixed physical RAM map:\n");
 		e820_print_map("bad_ppro");
 	}
 #else
 	early_gart_iommu_check();
 #endif
 	/*
 	 * partially used pages are not usable - thus
 	 * we are rounding upwards:
 	 */
 	max_pfn = e820_end_of_ram_pfn();
 	/* update e820 for memory not covered by WB MTRRs */
 	mtrr_bp_init();
 	if (mtrr_trim_uncached_memory(max_pfn))
 		max_pfn = e820_end_of_ram_pfn();
 #ifdef CONFIG_X86_32
 	/* max_low_pfn get updated here */
 	find_low_pfn_range();
 #else
 	num_physpages = max_pfn;
 	check_x2apic();
 	/* How many end-of-memory variables you have, grandma! */
 	/* need this before calling reserve_initrd */
 	if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
 		max_low_pfn = e820_end_of_low_ram_pfn();
 	else
 		max_low_pfn = max_pfn;
 	high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
 #endif
 	/*
 	 * Find and reserve possible boot-time SMP configuration:
 	 */
 	find_smp_config();
 	reserve_ibft_region();
 	/*
 	 * Need to conclude brk, before memblock_x86_fill()
 	 *  it could use memblock_find_in_range, could overlap with
 	 *  brk area.
 	 */
 	reserve_brk();
 	cleanup_highmap();
 	memblock.current_limit = get_max_mapped();
 	memblock_x86_fill();
 	/*
 	 * The EFI specification says that boot service code won't be called
 	 * after ExitBootServices(). This is, in fact, a lie.
 	 */
 	if (efi_enabled)
 		efi_reserve_boot_services();
 	/* preallocate 4k for mptable mpc */
 	early_reserve_e820_mpc_new();
 #ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
 	setup_bios_corruption_check();
 #endif
 	printk(KERN_DEBUG "initial memory mapped : 0 - %08lx\n",
 			max_pfn_mapped<<PAGE_SHIFT);
 	setup_trampolines();
 	init_gbpages();
 	/* max_pfn_mapped is updated here */
-	max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
+	end_pfn = max_low_pfn;
+#ifdef CONFIG_X86_64
+	/*
+	 * There may be regions after the last E820_RAM region that we
+	 * want to include in the kernel direct mapping, such as
+	 * EFI_RUNTIME_SERVICES_DATA.
+	 */
+	if (efi_enabled) {
+		unsigned long efi_end;
+		efi_end = e820_end_pfn(MAXMEM>>PAGE_SHIFT, E820_RESERVED_EFI);
+		if (efi_end > max_low_pfn)
+			end_pfn = efi_end;
+	}
+#endif
+	max_low_pfn_mapped = init_memory_mapping(0, end_pfn << PAGE_SHIFT);
 	max_pfn_mapped = max_low_pfn_mapped;
 #ifdef CONFIG_X86_64
 	if (max_pfn > max_low_pfn) {
 		max_pfn_mapped = init_memory_mapping(1UL<<32,
 						     max_pfn<<PAGE_SHIFT);
 		/* can we preseve max_low_pfn ?*/
 		max_low_pfn = max_pfn;
 	}
 #endif
 	memblock.current_limit = get_max_mapped();
 	/*
 	 * NOTE: On x86-32, only from this point on, fixmaps are ready for use.
 	 */
 #ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
 	if (init_ohci1394_dma_early)
 		init_ohci1394_dma_on_all_controllers();
 #endif
 	/* Allocate bigger log buffer */
 	setup_log_buf(1);
 	reserve_initrd();
 	reserve_crashkernel();
 	vsmp_init();
 	io_delay_init();
 	/*
 	 * Parse the ACPI tables for possible boot-time SMP configuration.
 	 */
 	acpi_boot_table_init();
 	early_acpi_boot_init();
 	initmem_init();
 	memblock_find_dma_reserve();
 #ifdef CONFIG_KVM_CLOCK
 	kvmclock_init();
 #endif
 	x86_init.paging.pagetable_setup_start(swapper_pg_dir);
 	paging_init();
 	x86_init.paging.pagetable_setup_done(swapper_pg_dir);
 	if (boot_cpu_data.cpuid_level >= 0) {
 		/* A CPU has %cr4 if and only if it has CPUID */
 		mmu_cr4_features = read_cr4();
 	}
 #ifdef CONFIG_X86_32
 	/* sync back kernel address range */
 	clone_pgd_range(initial_page_table + KERNEL_PGD_BOUNDARY,
 			swapper_pg_dir     + KERNEL_PGD_BOUNDARY,
 			KERNEL_PGD_PTRS);
 #endif
 	tboot_probe();
 #ifdef CONFIG_X86_64
 	map_vsyscall();
 #endif
 	generic_apic_probe();
 	early_quirks();
 	/*
 	 * Read APIC and some other early information from ACPI tables.
 	 */
 	acpi_boot_init();
 	sfi_init();
 	x86_dtb_init();
 	/*
 	 * get boot-time SMP configuration:
 	 */
 	if (smp_found_config)
 		get_smp_config();
 	prefill_possible_map();
 	init_cpu_to_node();
 	init_apic_mappings();
 	ioapic_and_gsi_init();
 	kvm_guest_init();
 	e820_reserve_resources();
 	e820_mark_nosave_regions(max_low_pfn);
 	x86_init.resources.reserve_resources();
 	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
 	x86_init.oem.banner();
 	x86_init.timers.wallclock_init();
 	x86_platform.wallclock_init();
 	mcheck_init();
 	arch_init_ideal_nops();
 }
 #ifdef CONFIG_X86_32
 static struct resource video_ram_resource = {
 	.name	= "Video RAM area",
 	.start	= 0xa0000,
 	.end	= 0xbffff,
 	.flags	= IORESOURCE_BUSY | IORESOURCE_MEM
 };
 void __init i386_reserve_resources(void)
 {
 	request_resource(&iomem_resource, &video_ram_resource);
 	reserve_standard_io_resources();
 }
 #endif /* CONFIG_X86_32 */

arch/x86/platform/efi/efi.c

Diff comments View file @ a776878

 /*
  * Common EFI (Extensible Firmware Interface) support functions
  * Based on Extensible Firmware Interface Specification version 1.0
  *
  * Copyright (C) 1999 VA Linux Systems
  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
  * Copyright (C) 1999-2002 Hewlett-Packard Co.
  *	David Mosberger-Tang <davidm@hpl.hp.com>
  *	Stephane Eranian <eranian@hpl.hp.com>
  * Copyright (C) 2005-2008 Intel Co.
  *	Fenghua Yu <fenghua.yu@intel.com>
  *	Bibo Mao <bibo.mao@intel.com>
  *	Chandramouli Narayanan <mouli@linux.intel.com>
  *	Huang Ying <ying.huang@intel.com>
  *
  * Copied from efi_32.c to eliminate the duplicated code between EFI
  * 32/64 support code. --ying 2007-10-26
  *
  * All EFI Runtime Services are not implemented yet as EFI only
  * supports physical mode addressing on SoftSDV. This is to be fixed
  * in a future version.  --drummond 1999-07-20
  *
  * Implemented EFI runtime services and virtual mode calls.  --davidm
  *
  * Goutham Rao: <goutham.rao@intel.com>
  *	Skip non-WB memory and ignore empty memory ranges.
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/efi.h>
 #include <linux/export.h>
 #include <linux/bootmem.h>
 #include <linux/memblock.h>
 #include <linux/spinlock.h>
 #include <linux/uaccess.h>
 #include <linux/time.h>
 #include <linux/io.h>
 #include <linux/reboot.h>
 #include <linux/bcd.h>
 #include <asm/setup.h>
 #include <asm/efi.h>
 #include <asm/time.h>
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 #include <asm/x86_init.h>
 #define EFI_DEBUG	1
 #define PFX 		"EFI: "
 int efi_enabled;
 EXPORT_SYMBOL(efi_enabled);
 struct efi __read_mostly efi = {
 	.mps        = EFI_INVALID_TABLE_ADDR,
 	.acpi       = EFI_INVALID_TABLE_ADDR,
 	.acpi20     = EFI_INVALID_TABLE_ADDR,
 	.smbios     = EFI_INVALID_TABLE_ADDR,
 	.sal_systab = EFI_INVALID_TABLE_ADDR,
 	.boot_info  = EFI_INVALID_TABLE_ADDR,
 	.hcdp       = EFI_INVALID_TABLE_ADDR,
 	.uga        = EFI_INVALID_TABLE_ADDR,
 	.uv_systab  = EFI_INVALID_TABLE_ADDR,
 };
 EXPORT_SYMBOL(efi);
 struct efi_memory_map memmap;
 static struct efi efi_phys __initdata;
 static efi_system_table_t efi_systab __initdata;
 static int __init setup_noefi(char *arg)
 {
 	efi_enabled = 0;
 	return 0;
 }
 early_param("noefi", setup_noefi);
 int add_efi_memmap;
 EXPORT_SYMBOL(add_efi_memmap);
 static int __init setup_add_efi_memmap(char *arg)
 {
 	add_efi_memmap = 1;
 	return 0;
 }
 early_param("add_efi_memmap", setup_add_efi_memmap);
 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
 {
 	unsigned long flags;
 	efi_status_t status;
 	spin_lock_irqsave(&rtc_lock, flags);
 	status = efi_call_virt2(get_time, tm, tc);
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	return status;
 }
 static efi_status_t virt_efi_set_time(efi_time_t *tm)
 {
 	unsigned long flags;
 	efi_status_t status;
 	spin_lock_irqsave(&rtc_lock, flags);
 	status = efi_call_virt1(set_time, tm);
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	return status;
 }
 static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
 					     efi_bool_t *pending,
 					     efi_time_t *tm)
 {
 	unsigned long flags;
 	efi_status_t status;
 	spin_lock_irqsave(&rtc_lock, flags);
 	status = efi_call_virt3(get_wakeup_time,
 				enabled, pending, tm);
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	return status;
 }
 static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
 {
 	unsigned long flags;
 	efi_status_t status;
 	spin_lock_irqsave(&rtc_lock, flags);
 	status = efi_call_virt2(set_wakeup_time,
 				enabled, tm);
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	return status;
 }
 static efi_status_t virt_efi_get_variable(efi_char16_t *name,
 					  efi_guid_t *vendor,
 					  u32 *attr,
 					  unsigned long *data_size,
 					  void *data)
 {
 	return efi_call_virt5(get_variable,
 			      name, vendor, attr,
 			      data_size, data);
 }
 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
 					       efi_char16_t *name,
 					       efi_guid_t *vendor)
 {
 	return efi_call_virt3(get_next_variable,
 			      name_size, name, vendor);
 }
 static efi_status_t virt_efi_set_variable(efi_char16_t *name,
 					  efi_guid_t *vendor,
 					  u32 attr,
 					  unsigned long data_size,
 					  void *data)
 {
 	return efi_call_virt5(set_variable,
 			      name, vendor, attr,
 			      data_size, data);
 }
 static efi_status_t virt_efi_query_variable_info(u32 attr,
 						 u64 *storage_space,
 						 u64 *remaining_space,
 						 u64 *max_variable_size)
 {
 	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
 		return EFI_UNSUPPORTED;
 	return efi_call_virt4(query_variable_info, attr, storage_space,
 			      remaining_space, max_variable_size);
 }
 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
 {
 	return efi_call_virt1(get_next_high_mono_count, count);
 }
 static void virt_efi_reset_system(int reset_type,
 				  efi_status_t status,
 				  unsigned long data_size,
 				  efi_char16_t *data)
 {
 	efi_call_virt4(reset_system, reset_type, status,
 		       data_size, data);
 }
 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
 					    unsigned long count,
 					    unsigned long sg_list)
 {
 	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
 		return EFI_UNSUPPORTED;
 	return efi_call_virt3(update_capsule, capsules, count, sg_list);
 }
 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
 						unsigned long count,
 						u64 *max_size,
 						int *reset_type)
 {
 	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
 		return EFI_UNSUPPORTED;
 	return efi_call_virt4(query_capsule_caps, capsules, count, max_size,
 			      reset_type);
 }
 static efi_status_t __init phys_efi_set_virtual_address_map(
 	unsigned long memory_map_size,
 	unsigned long descriptor_size,
 	u32 descriptor_version,
 	efi_memory_desc_t *virtual_map)
 {
 	efi_status_t status;
 	efi_call_phys_prelog();
 	status = efi_call_phys4(efi_phys.set_virtual_address_map,
 				memory_map_size, descriptor_size,
 				descriptor_version, virtual_map);
 	efi_call_phys_epilog();
 	return status;
 }
 static efi_status_t __init phys_efi_get_time(efi_time_t *tm,
 					     efi_time_cap_t *tc)
 {
 	unsigned long flags;
 	efi_status_t status;
 	spin_lock_irqsave(&rtc_lock, flags);
 	efi_call_phys_prelog();
 	status = efi_call_phys2(efi_phys.get_time, tm, tc);
 	efi_call_phys_epilog();
 	spin_unlock_irqrestore(&rtc_lock, flags);
 	return status;
 }
 int efi_set_rtc_mmss(unsigned long nowtime)
 {
 	int real_seconds, real_minutes;
 	efi_status_t 	status;
 	efi_time_t 	eft;
 	efi_time_cap_t 	cap;
 	status = efi.get_time(&eft, &cap);
 	if (status != EFI_SUCCESS) {
 		printk(KERN_ERR "Oops: efitime: can't read time!\n");
 		return -1;
 	}
 	real_seconds = nowtime % 60;
 	real_minutes = nowtime / 60;
 	if (((abs(real_minutes - eft.minute) + 15)/30) & 1)
 		real_minutes += 30;
 	real_minutes %= 60;
 	eft.minute = real_minutes;
 	eft.second = real_seconds;
 	status = efi.set_time(&eft);
 	if (status != EFI_SUCCESS) {
 		printk(KERN_ERR "Oops: efitime: can't write time!\n");
 		return -1;
 	}
 	return 0;
 }
 unsigned long efi_get_time(void)
 {
 	efi_status_t status;
 	efi_time_t eft;
 	efi_time_cap_t cap;
 	status = efi.get_time(&eft, &cap);
 	if (status != EFI_SUCCESS)
 		printk(KERN_ERR "Oops: efitime: can't read time!\n");
 	return mktime(eft.year, eft.month, eft.day, eft.hour,
 		      eft.minute, eft.second);
 }
 /*
  * Tell the kernel about the EFI memory map.  This might include
  * more than the max 128 entries that can fit in the e820 legacy
  * (zeropage) memory map.
  */
 static void __init do_add_efi_memmap(void)
 {
 	void *p;
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		efi_memory_desc_t *md = p;
 		unsigned long long start = md->phys_addr;
 		unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
 		int e820_type;
 		switch (md->type) {
 		case EFI_LOADER_CODE:
 		case EFI_LOADER_DATA:
 		case EFI_BOOT_SERVICES_CODE:
 		case EFI_BOOT_SERVICES_DATA:
 		case EFI_CONVENTIONAL_MEMORY:
 			if (md->attribute & EFI_MEMORY_WB)
 				e820_type = E820_RAM;
 			else
 				e820_type = E820_RESERVED;
 			break;
 		case EFI_ACPI_RECLAIM_MEMORY:
 			e820_type = E820_ACPI;
 			break;
 		case EFI_ACPI_MEMORY_NVS:
 			e820_type = E820_NVS;
 			break;
 		case EFI_UNUSABLE_MEMORY:
 			e820_type = E820_UNUSABLE;
 			break;
+		case EFI_RUNTIME_SERVICES_DATA:
+			e820_type = E820_RESERVED_EFI;
+			break;
 		default:
 			/*
 			 * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE
-			 * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
+			 * EFI_MEMORY_MAPPED_IO
 			 * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
 			 */
 			e820_type = E820_RESERVED;
 			break;
 		}
 		e820_add_region(start, size, e820_type);
 	}
 	sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
 }
 void __init efi_memblock_x86_reserve_range(void)
 {
 	unsigned long pmap;
 #ifdef CONFIG_X86_32
 	pmap = boot_params.efi_info.efi_memmap;
 #else
 	pmap = (boot_params.efi_info.efi_memmap |
 		((__u64)boot_params.efi_info.efi_memmap_hi<<32));
 #endif
 	memmap.phys_map = (void *)pmap;
 	memmap.nr_map = boot_params.efi_info.efi_memmap_size /
 		boot_params.efi_info.efi_memdesc_size;
 	memmap.desc_version = boot_params.efi_info.efi_memdesc_version;
 	memmap.desc_size = boot_params.efi_info.efi_memdesc_size;
 	memblock_x86_reserve_range(pmap, pmap + memmap.nr_map * memmap.desc_size,
 		      "EFI memmap");
 }
 #if EFI_DEBUG
 static void __init print_efi_memmap(void)
 {
 	efi_memory_desc_t *md;
 	void *p;
 	int i;
 	for (p = memmap.map, i = 0;
 	     p < memmap.map_end;
 	     p += memmap.desc_size, i++) {
 		md = p;
 		printk(KERN_INFO PFX "mem%02u: type=%u, attr=0x%llx, "
 			"range=[0x%016llx-0x%016llx) (%lluMB)\n",
 			i, md->type, md->attribute, md->phys_addr,
 			md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
 			(md->num_pages >> (20 - EFI_PAGE_SHIFT)));
 	}
 }
 #endif  /*  EFI_DEBUG  */
 void __init efi_reserve_boot_services(void)
 {
 	void *p;
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		efi_memory_desc_t *md = p;
 		u64 start = md->phys_addr;
 		u64 size = md->num_pages << EFI_PAGE_SHIFT;
 		if (md->type != EFI_BOOT_SERVICES_CODE &&
 		    md->type != EFI_BOOT_SERVICES_DATA)
 			continue;
 		/* Only reserve where possible:
 		 * - Not within any already allocated areas
 		 * - Not over any memory area (really needed, if above?)
 		 * - Not within any part of the kernel
 		 * - Not the bios reserved area
 		*/
 		if ((start+size >= virt_to_phys(_text)
 				&& start <= virt_to_phys(_end)) ||
 			!e820_all_mapped(start, start+size, E820_RAM) ||
 			memblock_x86_check_reserved_size(&start, &size,
 							1<<EFI_PAGE_SHIFT)) {
 			/* Could not reserve, skip it */
 			md->num_pages = 0;
 			memblock_dbg(PFX "Could not reserve boot range "
 					"[0x%010llx-0x%010llx]\n",
 						start, start+size-1);
 		} else
 			memblock_x86_reserve_range(start, start+size,
 							"EFI Boot");
 	}
 }
 static void __init efi_free_boot_services(void)
 {
 	void *p;
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		efi_memory_desc_t *md = p;
 		unsigned long long start = md->phys_addr;
 		unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
 		if (md->type != EFI_BOOT_SERVICES_CODE &&
 		    md->type != EFI_BOOT_SERVICES_DATA)
 			continue;
 		/* Could not reserve boot area */
 		if (!size)
 			continue;
 		free_bootmem_late(start, size);
 	}
 }
 void __init efi_init(void)
 {
 	efi_config_table_t *config_tables;
 	efi_runtime_services_t *runtime;
 	efi_char16_t *c16;
 	char vendor[100] = "unknown";
 	int i = 0;
 	void *tmp;
 #ifdef CONFIG_X86_32
 	efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
 #else
 	efi_phys.systab = (efi_system_table_t *)
 		(boot_params.efi_info.efi_systab |
 		 ((__u64)boot_params.efi_info.efi_systab_hi<<32));
 #endif
 	efi.systab = early_ioremap((unsigned long)efi_phys.systab,
 				   sizeof(efi_system_table_t));
 	if (efi.systab == NULL)
 		printk(KERN_ERR "Couldn't map the EFI system table!\n");
 	memcpy(&efi_systab, efi.systab, sizeof(efi_system_table_t));
 	early_iounmap(efi.systab, sizeof(efi_system_table_t));
 	efi.systab = &efi_systab;
 	/*
 	 * Verify the EFI Table
 	 */
 	if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
 		printk(KERN_ERR "EFI system table signature incorrect!\n");
 	if ((efi.systab->hdr.revision >> 16) == 0)
 		printk(KERN_ERR "Warning: EFI system table version "
 		       "%d.%02d, expected 1.00 or greater!\n",
 		       efi.systab->hdr.revision >> 16,
 		       efi.systab->hdr.revision & 0xffff);
 	/*
 	 * Show what we know for posterity
 	 */
 	c16 = tmp = early_ioremap(efi.systab->fw_vendor, 2);
 	if (c16) {
 		for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
 			vendor[i] = *c16++;
 		vendor[i] = '\0';
 	} else
 		printk(KERN_ERR PFX "Could not map the firmware vendor!\n");
 	early_iounmap(tmp, 2);
 	printk(KERN_INFO "EFI v%u.%.02u by %s\n",
 	       efi.systab->hdr.revision >> 16,
 	       efi.systab->hdr.revision & 0xffff, vendor);
 	/*
 	 * Let's see what config tables the firmware passed to us.
 	 */
 	config_tables = early_ioremap(
 		efi.systab->tables,
 		efi.systab->nr_tables * sizeof(efi_config_table_t));
 	if (config_tables == NULL)
 		printk(KERN_ERR "Could not map EFI Configuration Table!\n");
 	printk(KERN_INFO);
 	for (i = 0; i < efi.systab->nr_tables; i++) {
 		if (!efi_guidcmp(config_tables[i].guid, MPS_TABLE_GUID)) {
 			efi.mps = config_tables[i].table;
 			printk(" MPS=0x%lx ", config_tables[i].table);
 		} else if (!efi_guidcmp(config_tables[i].guid,
 					ACPI_20_TABLE_GUID)) {
 			efi.acpi20 = config_tables[i].table;
 			printk(" ACPI 2.0=0x%lx ", config_tables[i].table);
 		} else if (!efi_guidcmp(config_tables[i].guid,
 					ACPI_TABLE_GUID)) {
 			efi.acpi = config_tables[i].table;
 			printk(" ACPI=0x%lx ", config_tables[i].table);
 		} else if (!efi_guidcmp(config_tables[i].guid,
 					SMBIOS_TABLE_GUID)) {
 			efi.smbios = config_tables[i].table;
 			printk(" SMBIOS=0x%lx ", config_tables[i].table);
 #ifdef CONFIG_X86_UV
 		} else if (!efi_guidcmp(config_tables[i].guid,
 					UV_SYSTEM_TABLE_GUID)) {
 			efi.uv_systab = config_tables[i].table;
 			printk(" UVsystab=0x%lx ", config_tables[i].table);
 #endif
 		} else if (!efi_guidcmp(config_tables[i].guid,
 					HCDP_TABLE_GUID)) {
 			efi.hcdp = config_tables[i].table;
 			printk(" HCDP=0x%lx ", config_tables[i].table);
 		} else if (!efi_guidcmp(config_tables[i].guid,
 					UGA_IO_PROTOCOL_GUID)) {
 			efi.uga = config_tables[i].table;
 			printk(" UGA=0x%lx ", config_tables[i].table);
 		}
 	}
 	printk("\n");
 	early_iounmap(config_tables,
 			  efi.systab->nr_tables * sizeof(efi_config_table_t));
 	/*
 	 * Check out the runtime services table. We need to map
 	 * the runtime services table so that we can grab the physical
 	 * address of several of the EFI runtime functions, needed to
 	 * set the firmware into virtual mode.
 	 */
 	runtime = early_ioremap((unsigned long)efi.systab->runtime,
 				sizeof(efi_runtime_services_t));
 	if (runtime != NULL) {
 		/*
 		 * We will only need *early* access to the following
 		 * two EFI runtime services before set_virtual_address_map
 		 * is invoked.
 		 */
 		efi_phys.get_time = (efi_get_time_t *)runtime->get_time;
 		efi_phys.set_virtual_address_map =
 			(efi_set_virtual_address_map_t *)
 			runtime->set_virtual_address_map;
 		/*
 		 * Make efi_get_time can be called before entering
 		 * virtual mode.
 		 */
 		efi.get_time = phys_efi_get_time;
 	} else
 		printk(KERN_ERR "Could not map the EFI runtime service "
 		       "table!\n");
 	early_iounmap(runtime, sizeof(efi_runtime_services_t));
 	/* Map the EFI memory map */
 	memmap.map = early_ioremap((unsigned long)memmap.phys_map,
 				   memmap.nr_map * memmap.desc_size);
 	if (memmap.map == NULL)
 		printk(KERN_ERR "Could not map the EFI memory map!\n");
 	memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
 	if (memmap.desc_size != sizeof(efi_memory_desc_t))
 		printk(KERN_WARNING
 		  "Kernel-defined memdesc doesn't match the one from EFI!\n");
 	if (add_efi_memmap)
 		do_add_efi_memmap();
 #ifdef CONFIG_X86_32
 	x86_platform.get_wallclock = efi_get_time;
 	x86_platform.set_wallclock = efi_set_rtc_mmss;
 #endif
 #if EFI_DEBUG
 	print_efi_memmap();
 #endif
 }
 void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
 {
 	u64 addr, npages;
 	addr = md->virt_addr;
 	npages = md->num_pages;
 	memrange_efi_to_native(&addr, &npages);
 	if (executable)
 		set_memory_x(addr, npages);
 	else
 		set_memory_nx(addr, npages);
 }
 static void __init runtime_code_page_mkexec(void)
 {
 	efi_memory_desc_t *md;
 	void *p;
 	/* Make EFI runtime service code area executable */
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		md = p;
 		if (md->type != EFI_RUNTIME_SERVICES_CODE)
 			continue;
 		efi_set_executable(md, true);
 	}
 }
 /*
  * This function will switch the EFI runtime services to virtual mode.
  * Essentially, look through the EFI memmap and map every region that
  * has the runtime attribute bit set in its memory descriptor and update
  * that memory descriptor with the virtual address obtained from ioremap().
  * This enables the runtime services to be called without having to
  * thunk back into physical mode for every invocation.
  */
 void __init efi_enter_virtual_mode(void)
 {
 	efi_memory_desc_t *md, *prev_md = NULL;
 	efi_status_t status;
 	unsigned long size;
 	u64 end, systab, addr, npages, end_pfn;
 	void *p, *va, *new_memmap = NULL;
 	int count = 0;
 	efi.systab = NULL;
 	/* Merge contiguous regions of the same type and attribute */
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		u64 prev_size;
 		md = p;
 		if (!prev_md) {
 			prev_md = md;
 			continue;
 		}
 		if (prev_md->type != md->type ||
 		    prev_md->attribute != md->attribute) {
 			prev_md = md;
 			continue;
 		}
 		prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;
 		if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
 			prev_md->num_pages += md->num_pages;
 			md->type = EFI_RESERVED_TYPE;
 			md->attribute = 0;
 			continue;
 		}
 		prev_md = md;
 	}
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		md = p;
 		if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
 		    md->type != EFI_BOOT_SERVICES_CODE &&
 		    md->type != EFI_BOOT_SERVICES_DATA)
 			continue;
 		size = md->num_pages << EFI_PAGE_SHIFT;
 		end = md->phys_addr + size;
 		end_pfn = PFN_UP(end);
 		if (end_pfn <= max_low_pfn_mapped
 		    || (end_pfn > (1UL << (32 - PAGE_SHIFT))
-			&& end_pfn <= max_pfn_mapped))
+			&& end_pfn <= max_pfn_mapped)) {
 			va = __va(md->phys_addr);
-		else
-			va = efi_ioremap(md->phys_addr, size, md->type);
+			if (!(md->attribute & EFI_MEMORY_WB)) {
+				addr = (u64) (unsigned long)va;
+				npages = md->num_pages;
+				memrange_efi_to_native(&addr, &npages);
+				set_memory_uc(addr, npages);
+			}
+		} else {
+			if (!(md->attribute & EFI_MEMORY_WB))
+				va = ioremap_nocache(md->phys_addr, size);
+			else
+				va = ioremap_cache(md->phys_addr, size);
+		}
 		md->virt_addr = (u64) (unsigned long) va;
 		if (!va) {
 			printk(KERN_ERR PFX "ioremap of 0x%llX failed!\n",
 			       (unsigned long long)md->phys_addr);
 			continue;
-		}
-		if (!(md->attribute & EFI_MEMORY_WB)) {
-			addr = md->virt_addr;
-			npages = md->num_pages;
-			memrange_efi_to_native(&addr, &npages);
-			set_memory_uc(addr, npages);
 		}
 		systab = (u64) (unsigned long) efi_phys.systab;
 		if (md->phys_addr <= systab && systab < end) {
 			systab += md->virt_addr - md->phys_addr;
 			efi.systab = (efi_system_table_t *) (unsigned long) systab;
 		}
 		new_memmap = krealloc(new_memmap,
 				      (count + 1) * memmap.desc_size,
 				      GFP_KERNEL);
 		memcpy(new_memmap + (count * memmap.desc_size), md,
 		       memmap.desc_size);
 		count++;
 	}
 	BUG_ON(!efi.systab);
 	status = phys_efi_set_virtual_address_map(
 		memmap.desc_size * count,
 		memmap.desc_size,
 		memmap.desc_version,
 		(efi_memory_desc_t *)__pa(new_memmap));
 	if (status != EFI_SUCCESS) {
 		printk(KERN_ALERT "Unable to switch EFI into virtual mode "
 		       "(status=%lx)!\n", status);
 		panic("EFI call to SetVirtualAddressMap() failed!");
 	}
 	/*
 	 * Thankfully, it does seem that no runtime services other than
 	 * SetVirtualAddressMap() will touch boot services code, so we can
 	 * get rid of it all at this point
 	 */
 	efi_free_boot_services();
 	/*
 	 * Now that EFI is in virtual mode, update the function
 	 * pointers in the runtime service table to the new virtual addresses.
 	 *
 	 * Call EFI services through wrapper functions.
 	 */
 	efi.get_time = virt_efi_get_time;
 	efi.set_time = virt_efi_set_time;
 	efi.get_wakeup_time = virt_efi_get_wakeup_time;
 	efi.set_wakeup_time = virt_efi_set_wakeup_time;
 	efi.get_variable = virt_efi_get_variable;
 	efi.get_next_variable = virt_efi_get_next_variable;
 	efi.set_variable = virt_efi_set_variable;
 	efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
 	efi.reset_system = virt_efi_reset_system;
 	efi.set_virtual_address_map = NULL;
 	efi.query_variable_info = virt_efi_query_variable_info;
 	efi.update_capsule = virt_efi_update_capsule;
 	efi.query_capsule_caps = virt_efi_query_capsule_caps;
 	if (__supported_pte_mask & _PAGE_NX)
 		runtime_code_page_mkexec();
 	early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
 	memmap.map = NULL;
 	kfree(new_memmap);
 }
 /*
  * Convenience functions to obtain memory types and attributes
  */
 u32 efi_mem_type(unsigned long phys_addr)
 {
 	efi_memory_desc_t *md;
 	void *p;
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		md = p;
 		if ((md->phys_addr <= phys_addr) &&
 		    (phys_addr < (md->phys_addr +
 				  (md->num_pages << EFI_PAGE_SHIFT))))
 			return md->type;
 	}
 	return 0;
 }
 u64 efi_mem_attributes(unsigned long phys_addr)
 {
 	efi_memory_desc_t *md;
 	void *p;
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {

arch/x86/platform/efi/efi_64.c

Diff comments View file @ a776878

 /*
  * x86_64 specific EFI support functions
  * Based on Extensible Firmware Interface Specification version 1.0
  *
  * Copyright (C) 2005-2008 Intel Co.
  *	Fenghua Yu <fenghua.yu@intel.com>
  *	Bibo Mao <bibo.mao@intel.com>
  *	Chandramouli Narayanan <mouli@linux.intel.com>
  *	Huang Ying <ying.huang@intel.com>
  *
  * Code to convert EFI to E820 map has been implemented in elilo bootloader
  * based on a EFI patch by Edgar Hucek. Based on the E820 map, the page table
  * is setup appropriately for EFI runtime code.
  * - mouli 06/14/2007.
  *
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/types.h>
 #include <linux/spinlock.h>
 #include <linux/bootmem.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/efi.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
 #include <linux/reboot.h>
 #include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/e820.h>
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
 #include <asm/proto.h>
 #include <asm/efi.h>
 #include <asm/cacheflush.h>
 #include <asm/fixmap.h>
 static pgd_t save_pgd __initdata;
 static unsigned long efi_flags __initdata;
 static void __init early_code_mapping_set_exec(int executable)
 {
 	efi_memory_desc_t *md;
 	void *p;
 	if (!(__supported_pte_mask & _PAGE_NX))
 		return;
 	/* Make EFI service code area executable */
 	for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
 		md = p;
 		if (md->type == EFI_RUNTIME_SERVICES_CODE ||
 		    md->type == EFI_BOOT_SERVICES_CODE)
 			efi_set_executable(md, executable);
 	}
 }
 void __init efi_call_phys_prelog(void)
 {
 	unsigned long vaddress;
 	early_code_mapping_set_exec(1);
 	local_irq_save(efi_flags);
 	vaddress = (unsigned long)__va(0x0UL);
 	save_pgd = *pgd_offset_k(0x0UL);
 	set_pgd(pgd_offset_k(0x0UL), *pgd_offset_k(vaddress));
 	__flush_tlb_all();
 }
 void __init efi_call_phys_epilog(void)
 {
 	/*
 	 * After the lock is released, the original page table is restored.
 	 */
 	set_pgd(pgd_offset_k(0x0UL), save_pgd);
 	__flush_tlb_all();
 	local_irq_restore(efi_flags);
 	early_code_mapping_set_exec(0);
 }
-void __iomem *__init efi_ioremap(unsigned long phys_addr, unsigned long size,
-				 u32 type)
-{
-	unsigned long last_map_pfn;
-	if (type == EFI_MEMORY_MAPPED_IO)
-		return ioremap(phys_addr, size);
-	last_map_pfn = init_memory_mapping(phys_addr, phys_addr + size);
-	if ((last_map_pfn << PAGE_SHIFT) < phys_addr + size) {
-		unsigned long top = last_map_pfn << PAGE_SHIFT;
-		efi_ioremap(top, size - (top - phys_addr), type);
-	}
-	return (void __iomem *)__va(phys_addr);
-}