167 files changed, 3355 insertions, 13266 deletions

diff --git a/arch/x86/Kbuild b/arch/x86/Kbuild
index 0e103236b754..0e9dec6cadd1 100644
--- a/arch/x86/Kbuild
+++ b/arch/x86/Kbuild
@@ -15,3 +15,4 @@ obj-y += vdso/
 obj-$(CONFIG_IA32_EMULATION) += ia32/
 
 obj-y += platform/
+obj-y += net/
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index cc6c53a95bfd..880fcb6c86f4 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -8,6 +8,7 @@ config 64BIT
 
 config X86_32
         def_bool !64BIT
+        select CLKSRC_I8253
 
 config X86_64
         def_bool 64BIT
@@ -71,7 +72,7 @@ config X86
         select GENERIC_IRQ_SHOW
         select IRQ_FORCED_THREADING
         select USE_GENERIC_SMP_HELPERS if SMP
-        select ARCH_NO_SYSDEV_OPS
+        select HAVE_BPF_JIT if (X86_64 && NET)
 
 config INSTRUCTION_DECODER
         def_bool (KPROBES || PERF_EVENTS)
@@ -112,7 +113,14 @@ config MMU
         def_bool y
 
 config ZONE_DMA
-        def_bool y
+        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
@@ -365,17 +373,6 @@ config X86_UV
 # Following is an alphabetically sorted list of 32 bit extended platforms
 # Please maintain the alphabetic order if and when there are additions
 
-config X86_ELAN
-        bool "AMD Elan"
-        depends on X86_32
-        depends on X86_EXTENDED_PLATFORM
-        ---help---
-          Select this for an AMD Elan processor.
-
-          Do not use this option for K6/Athlon/Opteron processors!
-
-          If unsure, choose "PC-compatible" instead.
-
 config X86_INTEL_CE
         bool "CE4100 TV platform"
         depends on PCI
@@ -690,6 +687,7 @@ config AMD_IOMMU
         bool "AMD IOMMU support"
         select SWIOTLB
         select PCI_MSI
+        select PCI_IOV
         depends on X86_64 && PCI && ACPI
         ---help---
           With this option you can enable support for AMD IOMMU hardware in
@@ -1174,7 +1172,7 @@ comment "NUMA (Summit) requires SMP, 64GB highmem support, ACPI"
 config AMD_NUMA
         def_bool y
         prompt "Old style AMD Opteron NUMA detection"
-        depends on X86_64 && NUMA && PCI
+        depends on 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
@@ -1201,7 +1199,7 @@ config NODES_SPAN_OTHER_NODES
 
 config NUMA_EMU
         bool "NUMA emulation"
-        depends on X86_64 && NUMA
+        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
@@ -1223,6 +1221,10 @@ 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
@@ -1231,13 +1233,9 @@ config NEED_NODE_MEMMAP_SIZE
         def_bool y
         depends on X86_32 && (DISCONTIGMEM || SPARSEMEM)
 
-config HAVE_ARCH_ALLOC_REMAP
-        def_bool y
-        depends on X86_32 && NUMA
-
 config ARCH_FLATMEM_ENABLE
         def_bool y
-        depends on X86_32 && ARCH_SELECT_MEMORY_MODEL && !NUMA
+        depends on X86_32 && !NUMA
 
 config ARCH_DISCONTIGMEM_ENABLE
         def_bool y
@@ -1247,20 +1245,16 @@ config ARCH_DISCONTIGMEM_DEFAULT
         def_bool y
         depends on NUMA && X86_32
 
-config ARCH_PROC_KCORE_TEXT
-        def_bool y
-        depends on X86_64 && PROC_KCORE
-
-config ARCH_SPARSEMEM_DEFAULT
-        def_bool y
-        depends on X86_64
-
 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
@@ -1269,6 +1263,10 @@ 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
@@ -1703,10 +1701,6 @@ config ARCH_ENABLE_MEMORY_HOTREMOVE
         def_bool y
         depends on MEMORY_HOTPLUG
 
-config HAVE_ARCH_EARLY_PFN_TO_NID
-        def_bool X86_64
-        depends on NUMA
-
 config USE_PERCPU_NUMA_NODE_ID
         def_bool y
         depends on NUMA
@@ -1848,7 +1842,7 @@ config APM_ALLOW_INTS
 
 endif # APM
 
-source "arch/x86/kernel/cpu/cpufreq/Kconfig"
+source "drivers/cpufreq/Kconfig"
 
 source "drivers/cpuidle/Kconfig"
 
@@ -2076,7 +2070,7 @@ config OLPC
         depends on !X86_PAE
         select GPIOLIB
         select OF
-        select OF_PROMTREE if PROC_DEVICETREE
+        select OF_PROMTREE
         ---help---
           Add support for detecting the unique features of the OLPC
           XO hardware.
diff --git a/arch/x86/Kconfig.cpu b/arch/x86/Kconfig.cpu
index d161e939df62..6a7cfdf8ff69 100644
--- a/arch/x86/Kconfig.cpu
+++ b/arch/x86/Kconfig.cpu
@@ -1,6 +1,4 @@
 # Put here option for CPU selection and depending optimization
-if !X86_ELAN
-
 choice
         prompt "Processor family"
         default M686 if X86_32
@@ -203,6 +201,14 @@ config MWINCHIP3D
           stores for this CPU, which can increase performance of some
           operations.
 
+config MELAN
+        bool "AMD Elan"
+        depends on X86_32
+        ---help---
+          Select this for an AMD Elan processor.
+
+          Do not use this option for K6/Athlon/Opteron processors!
+
 config MGEODEGX1
         bool "GeodeGX1"
         depends on X86_32
@@ -292,8 +298,6 @@ config X86_GENERIC
           This is really intended for distributors who need more
           generic optimizations.
 
-endif
-
 #
 # Define implied options from the CPU selection here
 config X86_INTERNODE_CACHE_SHIFT
@@ -312,7 +316,7 @@ config X86_L1_CACHE_SHIFT
         int
         default "7" if MPENTIUM4 || MPSC
         default "6" if MK7 || MK8 || MPENTIUMM || MCORE2 || MATOM || MVIAC7 || X86_GENERIC || GENERIC_CPU
-        default "4" if X86_ELAN || M486 || M386 || MGEODEGX1
+        default "4" if MELAN || M486 || M386 || MGEODEGX1
         default "5" if MWINCHIP3D || MWINCHIPC6 || MCRUSOE || MEFFICEON || MCYRIXIII || MK6 || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || M586 || MVIAC3_2 || MGEODE_LX
 
 config X86_XADD
@@ -358,7 +362,7 @@ config X86_POPAD_OK
 
 config X86_ALIGNMENT_16
         def_bool y
-        depends on MWINCHIP3D || MWINCHIPC6 || MCYRIXIII || X86_ELAN || MK6 || M586MMX || M586TSC || M586 || M486 || MVIAC3_2 || MGEODEGX1
+        depends on MWINCHIP3D || MWINCHIPC6 || MCYRIXIII || MELAN || MK6 || M586MMX || M586TSC || M586 || M486 || MVIAC3_2 || MGEODEGX1
 
 config X86_INTEL_USERCOPY
         def_bool y
diff --git a/arch/x86/Makefile_32.cpu b/arch/x86/Makefile_32.cpu
index f2ee1abb1df9..86cee7b749e1 100644
--- a/arch/x86/Makefile_32.cpu
+++ b/arch/x86/Makefile_32.cpu
@@ -37,7 +37,7 @@ cflags-$(CONFIG_MATOM)		+= $(call cc-option,-march=atom,$(call cc-option,-march=
         $(call cc-option,-mtune=atom,$(call cc-option,-mtune=generic))
 
 # AMD Elan support
-cflags-$(CONFIG_X86_ELAN)       += -march=i486
+cflags-$(CONFIG_MELAN)          += -march=i486
 
 # Geode GX1 support
 cflags-$(CONFIG_MGEODEGX1)      += -march=pentium-mmx
diff --git a/arch/x86/crypto/Makefile b/arch/x86/crypto/Makefile
index 1a58ad89fdf7..c04f1b7a9139 100644
--- a/arch/x86/crypto/Makefile
+++ b/arch/x86/crypto/Makefile
@@ -2,8 +2,6 @@
 # Arch-specific CryptoAPI modules.
 #
 
-obj-$(CONFIG_CRYPTO_FPU) += fpu.o
-
 obj-$(CONFIG_CRYPTO_AES_586) += aes-i586.o
 obj-$(CONFIG_CRYPTO_TWOFISH_586) += twofish-i586.o
 obj-$(CONFIG_CRYPTO_SALSA20_586) += salsa20-i586.o
@@ -24,6 +22,6 @@ aes-x86_64-y := aes-x86_64-asm_64.o aes_glue.o
 twofish-x86_64-y := twofish-x86_64-asm_64.o twofish_glue.o
 salsa20-x86_64-y := salsa20-x86_64-asm_64.o salsa20_glue.o
 
-aesni-intel-y := aesni-intel_asm.o aesni-intel_glue.o
+aesni-intel-y := aesni-intel_asm.o aesni-intel_glue.o fpu.o
 
 ghash-clmulni-intel-y := ghash-clmulni-intel_asm.o ghash-clmulni-intel_glue.o
diff --git a/arch/x86/crypto/aesni-intel_glue.c b/arch/x86/crypto/aesni-intel_glue.c
index 2577613fb32b..feee8ff1d05e 100644
--- a/arch/x86/crypto/aesni-intel_glue.c
+++ b/arch/x86/crypto/aesni-intel_glue.c
@@ -94,6 +94,10 @@ asmlinkage void aesni_cbc_enc(struct crypto_aes_ctx *ctx, u8 *out,
                               const u8 *in, unsigned int len, u8 *iv);
 asmlinkage void aesni_cbc_dec(struct crypto_aes_ctx *ctx, u8 *out,
                               const u8 *in, unsigned int len, u8 *iv);
+
+int crypto_fpu_init(void);
+void crypto_fpu_exit(void);
+
 #ifdef CONFIG_X86_64
 asmlinkage void aesni_ctr_enc(struct crypto_aes_ctx *ctx, u8 *out,
                               const u8 *in, unsigned int len, u8 *iv);
@@ -1257,6 +1261,8 @@ static int __init aesni_init(void)
                 return -ENODEV;
         }
 
+        if ((err = crypto_fpu_init()))
+                goto fpu_err;
         if ((err = crypto_register_alg(&aesni_alg)))
                 goto aes_err;
         if ((err = crypto_register_alg(&__aesni_alg)))
@@ -1334,6 +1340,7 @@ blk_ecb_err:
 __aes_err:
         crypto_unregister_alg(&aesni_alg);
 aes_err:
+fpu_err:
         return err;
 }
 
@@ -1363,6 +1370,8 @@ static void __exit aesni_exit(void)
         crypto_unregister_alg(&blk_ecb_alg);
         crypto_unregister_alg(&__aesni_alg);
         crypto_unregister_alg(&aesni_alg);
+
+        crypto_fpu_exit();
 }
 
 module_init(aesni_init);
diff --git a/arch/x86/crypto/fpu.c b/arch/x86/crypto/fpu.c
index 1a8f8649c035..98d7a188f46b 100644
--- a/arch/x86/crypto/fpu.c
+++ b/arch/x86/crypto/fpu.c
@@ -150,18 +150,12 @@ static struct crypto_template crypto_fpu_tmpl = {
         .module = THIS_MODULE,
 };
 
-static int __init crypto_fpu_module_init(void)
+int __init crypto_fpu_init(void)
 {
         return crypto_register_template(&crypto_fpu_tmpl);
 }
 
-static void __exit crypto_fpu_module_exit(void)
+void __exit crypto_fpu_exit(void)
 {
         crypto_unregister_template(&crypto_fpu_tmpl);
 }
-
-module_init(crypto_fpu_module_init);
-module_exit(crypto_fpu_module_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("FPU block cipher wrapper");
diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
index 849a9d23c71d..95f5826be458 100644
--- a/arch/x86/ia32/ia32entry.S
+++ b/arch/x86/ia32/ia32entry.S
@@ -848,4 +848,5 @@ ia32_sys_call_table:
         .quad compat_sys_open_by_handle_at
         .quad compat_sys_clock_adjtime
         .quad sys_syncfs
+        .quad compat_sys_sendmmsg       /* 345 */
 ia32_syscall_end:
diff --git a/arch/x86/include/asm/acpi.h b/arch/x86/include/asm/acpi.h
index 12e0e7dd869c..416d865eae39 100644
--- a/arch/x86/include/asm/acpi.h
+++ b/arch/x86/include/asm/acpi.h
@@ -183,8 +183,6 @@ static inline void disable_acpi(void) { }
 
 #define ARCH_HAS_POWER_INIT     1
 
-struct bootnode;
-
 #ifdef CONFIG_ACPI_NUMA
 extern int acpi_numa;
 extern int x86_acpi_numa_init(void);
diff --git a/arch/x86/include/asm/alternative-asm.h b/arch/x86/include/asm/alternative-asm.h
index a63a68be1cce..94d420b360d1 100644
--- a/arch/x86/include/asm/alternative-asm.h
+++ b/arch/x86/include/asm/alternative-asm.h
@@ -15,4 +15,13 @@
         .endm
 #endif
 
+.macro altinstruction_entry orig alt feature orig_len alt_len
+        .align 8
+        .quad \orig
+        .quad \alt
+        .word \feature
+        .byte \orig_len
+        .byte \alt_len
+.endm
+
 #endif  /*  __ASSEMBLY__  */
diff --git a/arch/x86/include/asm/alternative.h b/arch/x86/include/asm/alternative.h
index 13009d1af99a..bf535f947e8c 100644
--- a/arch/x86/include/asm/alternative.h
+++ b/arch/x86/include/asm/alternative.h
@@ -4,7 +4,6 @@
 #include <linux/types.h>
 #include <linux/stddef.h>
 #include <linux/stringify.h>
-#include <linux/jump_label.h>
 #include <asm/asm.h>
 
 /*
@@ -191,12 +190,4 @@ extern void *text_poke(void *addr, const void *opcode, size_t len);
 extern void *text_poke_smp(void *addr, const void *opcode, size_t len);
 extern void text_poke_smp_batch(struct text_poke_param *params, int n);
 
-#if defined(CONFIG_DYNAMIC_FTRACE) || defined(HAVE_JUMP_LABEL)
-#define IDEAL_NOP_SIZE_5 5
-extern unsigned char ideal_nop5[IDEAL_NOP_SIZE_5];
-extern void arch_init_ideal_nop5(void);
-#else
-static inline void arch_init_ideal_nop5(void) {}
-#endif
-
 #endif /* _ASM_X86_ALTERNATIVE_H */
diff --git a/arch/x86/include/asm/amd_iommu_proto.h b/arch/x86/include/asm/amd_iommu_proto.h
index 916bc8111a01..55d95eb789b3 100644
--- a/arch/x86/include/asm/amd_iommu_proto.h
+++ b/arch/x86/include/asm/amd_iommu_proto.h
@@ -19,13 +19,12 @@
 #ifndef _ASM_X86_AMD_IOMMU_PROTO_H
 #define _ASM_X86_AMD_IOMMU_PROTO_H
 
-struct amd_iommu;
+#include <asm/amd_iommu_types.h>
 
 extern int amd_iommu_init_dma_ops(void);
 extern int amd_iommu_init_passthrough(void);
+extern irqreturn_t amd_iommu_int_thread(int irq, void *data);
 extern irqreturn_t amd_iommu_int_handler(int irq, void *data);
-extern void amd_iommu_flush_all_domains(void);
-extern void amd_iommu_flush_all_devices(void);
 extern void amd_iommu_apply_erratum_63(u16 devid);
 extern void amd_iommu_reset_cmd_buffer(struct amd_iommu *iommu);
 extern int amd_iommu_init_devices(void);
@@ -44,4 +43,12 @@ static inline bool is_rd890_iommu(struct pci_dev *pdev)
                (pdev->device == PCI_DEVICE_ID_RD890_IOMMU);
 }
 
+static inline bool iommu_feature(struct amd_iommu *iommu, u64 f)
+{
+        if (!(iommu->cap & (1 << IOMMU_CAP_EFR)))
+                return false;
+
+        return !!(iommu->features & f);
+}
+
 #endif /* _ASM_X86_AMD_IOMMU_PROTO_H  */
diff --git a/arch/x86/include/asm/amd_iommu_types.h b/arch/x86/include/asm/amd_iommu_types.h
index e3509fc303bf..4c9982995414 100644
--- a/arch/x86/include/asm/amd_iommu_types.h
+++ b/arch/x86/include/asm/amd_iommu_types.h
@@ -68,12 +68,25 @@
 #define MMIO_CONTROL_OFFSET     0x0018
 #define MMIO_EXCL_BASE_OFFSET   0x0020
 #define MMIO_EXCL_LIMIT_OFFSET  0x0028
+#define MMIO_EXT_FEATURES       0x0030
 #define MMIO_CMD_HEAD_OFFSET    0x2000
 #define MMIO_CMD_TAIL_OFFSET    0x2008
 #define MMIO_EVT_HEAD_OFFSET    0x2010
 #define MMIO_EVT_TAIL_OFFSET    0x2018
 #define MMIO_STATUS_OFFSET      0x2020
 
+
+/* Extended Feature Bits */
+#define FEATURE_PREFETCH        (1ULL<<0)
+#define FEATURE_PPR             (1ULL<<1)
+#define FEATURE_X2APIC          (1ULL<<2)
+#define FEATURE_NX              (1ULL<<3)
+#define FEATURE_GT              (1ULL<<4)
+#define FEATURE_IA              (1ULL<<6)
+#define FEATURE_GA              (1ULL<<7)
+#define FEATURE_HE              (1ULL<<8)
+#define FEATURE_PC              (1ULL<<9)
+
 /* MMIO status bits */
 #define MMIO_STATUS_COM_WAIT_INT_MASK   0x04
 
@@ -113,7 +126,9 @@
 /* command specific defines */
 #define CMD_COMPL_WAIT          0x01
 #define CMD_INV_DEV_ENTRY       0x02
-#define CMD_INV_IOMMU_PAGES     0x03
+#define CMD_INV_IOMMU_PAGES     0x03
+#define CMD_INV_IOTLB_PAGES     0x04
+#define CMD_INV_ALL             0x08
 
 #define CMD_COMPL_WAIT_STORE_MASK       0x01
 #define CMD_COMPL_WAIT_INT_MASK         0x02
@@ -215,6 +230,8 @@
 #define IOMMU_PTE_IR (1ULL << 61)
 #define IOMMU_PTE_IW (1ULL << 62)
 
+#define DTE_FLAG_IOTLB  0x01
+
 #define IOMMU_PAGE_MASK (((1ULL << 52) - 1) & ~0xfffULL)
 #define IOMMU_PTE_PRESENT(pte) ((pte) & IOMMU_PTE_P)
 #define IOMMU_PTE_PAGE(pte) (phys_to_virt((pte) & IOMMU_PAGE_MASK))
@@ -227,6 +244,7 @@
 /* IOMMU capabilities */
 #define IOMMU_CAP_IOTLB   24
 #define IOMMU_CAP_NPCACHE 26
+#define IOMMU_CAP_EFR     27
 
 #define MAX_DOMAIN_ID 65536
 
@@ -249,6 +267,8 @@ extern bool amd_iommu_dump;
 
 /* global flag if IOMMUs cache non-present entries */
 extern bool amd_iommu_np_cache;
+/* Only true if all IOMMUs support device IOTLBs */
+extern bool amd_iommu_iotlb_sup;
 
 /*
  * Make iterating over all IOMMUs easier
@@ -371,6 +391,9 @@ struct amd_iommu {
         /* flags read from acpi table */
         u8 acpi_flags;
 
+        /* Extended features */
+        u64 features;
+
         /*
          * Capability pointer. There could be more than one IOMMU per PCI
          * device function if there are more than one AMD IOMMU capability
@@ -409,9 +432,6 @@ struct amd_iommu {
         /* if one, we need to send a completion wait command */
         bool need_sync;
 
-        /* becomes true if a command buffer reset is running */
-        bool reset_in_progress;
-
         /* default dma_ops domain for that IOMMU */
         struct dma_ops_domain *default_dom;
 
diff --git a/arch/x86/include/asm/amd_nb.h b/arch/x86/include/asm/amd_nb.h
index 331682231bb4..67f87f257611 100644
--- a/arch/x86/include/asm/amd_nb.h
+++ b/arch/x86/include/asm/amd_nb.h
@@ -11,7 +11,6 @@ struct amd_nb_bus_dev_range {
 
 extern const struct pci_device_id amd_nb_misc_ids[];
 extern const struct amd_nb_bus_dev_range amd_nb_bus_dev_ranges[];
-struct bootnode;
 
 extern bool early_is_amd_nb(u32 value);
 extern int amd_cache_northbridges(void);
diff --git a/arch/x86/include/asm/apic.h b/arch/x86/include/asm/apic.h
index 2b7d573be549..a0c46f061210 100644
--- a/arch/x86/include/asm/apic.h
+++ b/arch/x86/include/asm/apic.h
@@ -363,7 +363,12 @@ struct apic {
          */
         int (*x86_32_early_logical_apicid)(int cpu);
 
-        /* determine CPU -> NUMA node mapping */
+        /*
+         * Optional method called from setup_local_APIC() after logical
+         * apicid is guaranteed to be known to initialize apicid -> node
+         * mapping if NUMA initialization hasn't done so already.  Don't
+         * add new users.
+         */
         int (*x86_32_numa_cpu_node)(int cpu);
 #endif
 };
@@ -537,8 +542,6 @@ static inline int default_phys_pkg_id(int cpuid_apic, int index_msb)
         return cpuid_apic >> index_msb;
 }
 
-extern int default_x86_32_numa_cpu_node(int cpu);
-
 #endif
 
 static inline unsigned int
diff --git a/arch/x86/include/asm/apicdef.h b/arch/x86/include/asm/apicdef.h
index d87988bacf3e..34595d5e1038 100644
--- a/arch/x86/include/asm/apicdef.h
+++ b/arch/x86/include/asm/apicdef.h
@@ -78,6 +78,7 @@
 #define         APIC_DEST_LOGICAL       0x00800
 #define         APIC_DEST_PHYSICAL      0x00000
 #define         APIC_DM_FIXED           0x00000
+#define         APIC_DM_FIXED_MASK      0x00700
 #define         APIC_DM_LOWEST          0x00100
 #define         APIC_DM_SMI             0x00200
 #define         APIC_DM_REMRD           0x00300
diff --git a/arch/x86/include/asm/bios_ebda.h b/arch/x86/include/asm/bios_ebda.h
index 3c7521063d3f..aa6a3170ab5a 100644
--- a/arch/x86/include/asm/bios_ebda.h
+++ b/arch/x86/include/asm/bios_ebda.h
@@ -4,16 +4,40 @@
 #include <asm/io.h>
 
 /*
- * there is a real-mode segmented pointer pointing to the
- * 4K EBDA area at 0x40E.
+ * Returns physical address of EBDA.  Returns 0 if there is no EBDA.
  */
 static inline unsigned int get_bios_ebda(void)
 {
+        /*
+         * There is a real-mode segmented pointer pointing to the
+         * 4K EBDA area at 0x40E.
+         */
         unsigned int address = *(unsigned short *)phys_to_virt(0x40E);
         address <<= 4;
         return address; /* 0 means none */
 }
 
+/*
+ * Return the sanitized length of the EBDA in bytes, if it exists.
+ */
+static inline unsigned int get_bios_ebda_length(void)
+{
+        unsigned int address;
+        unsigned int length;
+
+        address = get_bios_ebda();
+        if (!address)
+                return 0;
+
+        /* EBDA length is byte 0 of the EBDA (stored in KiB) */
+        length = *(unsigned char *)phys_to_virt(address);
+        length <<= 10;
+
+        /* Trim the length if it extends beyond 640KiB */
+        length = min_t(unsigned int, (640 * 1024) - address, length);
+        return length;
+}
+
 void reserve_ebda_region(void);
 
 #ifdef CONFIG_X86_CHECK_BIOS_CORRUPTION
diff --git a/arch/x86/include/asm/cpufeature.h b/arch/x86/include/asm/cpufeature.h
index 91f3e087cf21..5dc6acc98dbd 100644
--- a/arch/x86/include/asm/cpufeature.h
+++ b/arch/x86/include/asm/cpufeature.h
@@ -195,6 +195,8 @@
 
 /* Intel-defined CPU features, CPUID level 0x00000007:0 (ebx), word 9 */
 #define X86_FEATURE_FSGSBASE    (9*32+ 0) /* {RD/WR}{FS/GS}BASE instructions*/
+#define X86_FEATURE_SMEP        (9*32+ 7) /* Supervisor Mode Execution Protection */
+#define X86_FEATURE_ERMS        (9*32+ 9) /* Enhanced REP MOVSB/STOSB */
 
 #if defined(__KERNEL__) && !defined(__ASSEMBLY__)
 
@@ -207,8 +209,7 @@ extern const char * const x86_power_flags[32];
 #define test_cpu_cap(c, bit)                                            \
          test_bit(bit, (unsigned long *)((c)->x86_capability))
 
-#define cpu_has(c, bit)                                                 \
-        (__builtin_constant_p(bit) &&                                   \
+#define REQUIRED_MASK_BIT_SET(bit)                                      \
          ( (((bit)>>5)==0 && (1UL<<((bit)&31) & REQUIRED_MASK0)) ||     \
            (((bit)>>5)==1 && (1UL<<((bit)&31) & REQUIRED_MASK1)) ||     \
            (((bit)>>5)==2 && (1UL<<((bit)&31) & REQUIRED_MASK2)) ||     \
@@ -218,10 +219,16 @@ extern const char * const x86_power_flags[32];
            (((bit)>>5)==6 && (1UL<<((bit)&31) & REQUIRED_MASK6)) ||     \
            (((bit)>>5)==7 && (1UL<<((bit)&31) & REQUIRED_MASK7)) ||     \
            (((bit)>>5)==8 && (1UL<<((bit)&31) & REQUIRED_MASK8)) ||     \
-           (((bit)>>5)==9 && (1UL<<((bit)&31) & REQUIRED_MASK9)) )      \
-          ? 1 :                                                         \
+           (((bit)>>5)==9 && (1UL<<((bit)&31) & REQUIRED_MASK9)) )
+
+#define cpu_has(c, bit)                                                 \
+        (__builtin_constant_p(bit) && REQUIRED_MASK_BIT_SET(bit) ? 1 :  \
          test_cpu_cap(c, bit))
 
+#define this_cpu_has(bit)                                               \
+        (__builtin_constant_p(bit) && REQUIRED_MASK_BIT_SET(bit) ? 1 :  \
+         x86_this_cpu_test_bit(bit, (unsigned long *)&cpu_info.x86_capability))
+
 #define boot_cpu_has(bit)       cpu_has(&boot_cpu_data, bit)
 
 #define set_cpu_cap(c, bit)     set_bit(bit, (unsigned long *)((c)->x86_capability))
diff --git a/arch/x86/include/asm/dma.h b/arch/x86/include/asm/dma.h
index 057099e5faba..0bdb0c54d9a1 100644
--- a/arch/x86/include/asm/dma.h
+++ b/arch/x86/include/asm/dma.h
@@ -69,22 +69,18 @@
 
 #define MAX_DMA_CHANNELS        8
 
-#ifdef CONFIG_X86_32
-
-/* The maximum address that we can perform a DMA transfer to on this platform */
-#define MAX_DMA_ADDRESS      (PAGE_OFFSET + 0x1000000)
-
-#else
-
 /* 16MB ISA DMA zone */
 #define MAX_DMA_PFN   ((16 * 1024 * 1024) >> PAGE_SHIFT)
 
 /* 4GB broken PCI/AGP hardware bus master zone */
 #define MAX_DMA32_PFN ((4UL * 1024 * 1024 * 1024) >> PAGE_SHIFT)
 
+#ifdef CONFIG_X86_32
+/* The maximum address that we can perform a DMA transfer to on this platform */
+#define MAX_DMA_ADDRESS      (PAGE_OFFSET + 0x1000000)
+#else
 /* Compat define for old dma zone */
 #define MAX_DMA_ADDRESS ((unsigned long)__va(MAX_DMA_PFN << PAGE_SHIFT))
-
 #endif
 
 /* 8237 DMA controllers */
diff --git a/arch/x86/include/asm/efi.h b/arch/x86/include/asm/efi.h
index 8e4a16508d4e..7093e4a6a0bc 100644
--- a/arch/x86/include/asm/efi.h
+++ b/arch/x86/include/asm/efi.h
@@ -90,6 +90,7 @@ extern void __iomem *efi_ioremap(unsigned long addr, unsigned long size,
 #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);
diff --git a/arch/x86/include/asm/ftrace.h b/arch/x86/include/asm/ftrace.h
index db24c2278be0..268c783ab1c0 100644
--- a/arch/x86/include/asm/ftrace.h
+++ b/arch/x86/include/asm/ftrace.h
@@ -38,11 +38,10 @@ extern void mcount(void);
 static inline unsigned long ftrace_call_adjust(unsigned long addr)
 {
         /*
-         * call mcount is "e8 <4 byte offset>"
-         * The addr points to the 4 byte offset and the caller of this
-         * function wants the pointer to e8. Simply subtract one.
+         * addr is the address of the mcount call instruction.
+         * recordmcount does the necessary offset calculation.
          */
-        return addr - 1;
+        return addr;
 }
 
 #ifdef CONFIG_DYNAMIC_FTRACE
diff --git a/arch/x86/include/asm/i8253.h b/arch/x86/include/asm/i8253.h
index fc1f579fb965..65aaa91d5850 100644
--- a/arch/x86/include/asm/i8253.h
+++ b/arch/x86/include/asm/i8253.h
@@ -6,6 +6,8 @@
 #define PIT_CH0                 0x40
 #define PIT_CH2                 0x42
 
+#define PIT_LATCH       LATCH
+
 extern raw_spinlock_t i8253_lock;
 
 extern struct clock_event_device *global_clock_event;
diff --git a/arch/x86/include/asm/jump_label.h b/arch/x86/include/asm/jump_label.h
index 574dbc22893a..a32b18ce6ead 100644
--- a/arch/x86/include/asm/jump_label.h
+++ b/arch/x86/include/asm/jump_label.h
@@ -5,20 +5,25 @@
 
 #include <linux/types.h>
 #include <asm/nops.h>
+#include <asm/asm.h>
 
 #define JUMP_LABEL_NOP_SIZE 5
 
-# define JUMP_LABEL_INITIAL_NOP ".byte 0xe9 \n\t .long 0\n\t"
-
-# define JUMP_LABEL(key, label)                                 \
-        do {                                                    \
-                asm goto("1:"                                   \
-                        JUMP_LABEL_INITIAL_NOP                  \
-                        ".pushsection __jump_table,  \"aw\" \n\t"\
-                        _ASM_PTR "1b, %l[" #label "], %c0 \n\t" \
-                        ".popsection \n\t"                      \
-                        : :  "i" (key) :  : label);             \
-        } while (0)
+#define JUMP_LABEL_INITIAL_NOP ".byte 0xe9 \n\t .long 0\n\t"
+
+static __always_inline bool arch_static_branch(struct jump_label_key *key)
+{
+        asm goto("1:"
+                JUMP_LABEL_INITIAL_NOP
+                ".pushsection __jump_table,  \"aw\" \n\t"
+                _ASM_ALIGN "\n\t"
+                _ASM_PTR "1b, %l[l_yes], %c0 \n\t"
+                ".popsection \n\t"
+                : :  "i" (key) : : l_yes);
+        return false;
+l_yes:
+        return true;
+}
 
 #endif /* __KERNEL__ */
 
diff --git a/arch/x86/include/asm/mce.h b/arch/x86/include/asm/mce.h
index eb16e94ae04f..021979a6e23f 100644
--- a/arch/x86/include/asm/mce.h
+++ b/arch/x86/include/asm/mce.h
@@ -142,8 +142,6 @@ static inline void winchip_mcheck_init(struct cpuinfo_x86 *c) {}
 static inline void enable_p5_mce(void) {}
 #endif
 
-extern void (*x86_mce_decode_callback)(struct mce *m);
-
 void mce_setup(struct mce *m);
 void mce_log(struct mce *m);
 DECLARE_PER_CPU(struct sys_device, mce_dev);
diff --git a/arch/x86/include/asm/mmzone_32.h b/arch/x86/include/asm/mmzone_32.h
index 91df7c51806c..5e83a416eca8 100644
--- a/arch/x86/include/asm/mmzone_32.h
+++ b/arch/x86/include/asm/mmzone_32.h
@@ -13,31 +13,11 @@ extern struct pglist_data *node_data[];
 #define NODE_DATA(nid)  (node_data[nid])
 
 #include <asm/numaq.h>
-/* summit or generic arch */
-#include <asm/srat.h>
-
-extern int get_memcfg_numa_flat(void);
-/*
- * This allows any one NUMA architecture to be compiled
- * for, and still fall back to the flat function if it
- * fails.
- */
-static inline void get_memcfg_numa(void)
-{
-
-        if (get_memcfg_numaq())
-                return;
-        if (get_memcfg_from_srat())
-                return;
-        get_memcfg_numa_flat();
-}
 
 extern void resume_map_numa_kva(pgd_t *pgd);
 
 #else /* !CONFIG_NUMA */
 
-#define get_memcfg_numa get_memcfg_numa_flat
-
 static inline void resume_map_numa_kva(pgd_t *pgd) {}
 
 #endif /* CONFIG_NUMA */
diff --git a/arch/x86/include/asm/mmzone_64.h b/arch/x86/include/asm/mmzone_64.h
index 288b96f815a6..b3f88d7867c7 100644
--- a/arch/x86/include/asm/mmzone_64.h
+++ b/arch/x86/include/asm/mmzone_64.h
@@ -4,36 +4,13 @@
 #ifndef _ASM_X86_MMZONE_64_H
 #define _ASM_X86_MMZONE_64_H
 
-
 #ifdef CONFIG_NUMA
 
 #include <linux/mmdebug.h>
-
 #include <asm/smp.h>
 
-/* Simple perfect hash to map physical addresses to node numbers */
-struct memnode {
-        int shift;
-        unsigned int mapsize;
-        s16 *map;
-        s16 embedded_map[64 - 8];
-} ____cacheline_aligned; /* total size = 128 bytes */
-extern struct memnode memnode;
-#define memnode_shift memnode.shift
-#define memnodemap memnode.map
-#define memnodemapsize memnode.mapsize
-
 extern struct pglist_data *node_data[];
 
-static inline __attribute__((pure)) int phys_to_nid(unsigned long addr)
-{
-        unsigned nid;
-        VIRTUAL_BUG_ON(!memnodemap);
-        nid = memnodemap[addr >> memnode_shift];
-        VIRTUAL_BUG_ON(nid >= MAX_NUMNODES || !node_data[nid]);
-        return nid;
-}
-
 #define NODE_DATA(nid)          (node_data[nid])
 
 #define node_start_pfn(nid)     (NODE_DATA(nid)->node_start_pfn)
diff --git a/arch/x86/include/asm/module.h b/arch/x86/include/asm/module.h
index 67763c5d8b4e..9eae7752ae9b 100644
--- a/arch/x86/include/asm/module.h
+++ b/arch/x86/include/asm/module.h
@@ -35,7 +35,7 @@
 #define MODULE_PROC_FAMILY "K7 "
 #elif defined CONFIG_MK8
 #define MODULE_PROC_FAMILY "K8 "
-#elif defined CONFIG_X86_ELAN
+#elif defined CONFIG_MELAN
 #define MODULE_PROC_FAMILY "ELAN "
 #elif defined CONFIG_MCRUSOE
 #define MODULE_PROC_FAMILY "CRUSOE "
diff --git a/arch/x86/include/asm/nops.h b/arch/x86/include/asm/nops.h
index af788496020b..405b4032a60b 100644
--- a/arch/x86/include/asm/nops.h
+++ b/arch/x86/include/asm/nops.h
@@ -1,7 +1,13 @@
 #ifndef _ASM_X86_NOPS_H
 #define _ASM_X86_NOPS_H
 
-/* Define nops for use with alternative() */
+/*
+ * Define nops for use with alternative() and for tracing.
+ *
+ * *_NOP5_ATOMIC must be a single instruction.
+ */
+
+#define NOP_DS_PREFIX 0x3e
 
 /* generic versions from gas
    1: nop
@@ -13,14 +19,15 @@
    6: leal 0x00000000(%esi),%esi
    7: leal 0x00000000(,%esi,1),%esi
 */
-#define GENERIC_NOP1 ".byte 0x90\n"
-#define GENERIC_NOP2 ".byte 0x89,0xf6\n"
-#define GENERIC_NOP3 ".byte 0x8d,0x76,0x00\n"
-#define GENERIC_NOP4 ".byte 0x8d,0x74,0x26,0x00\n"
-#define GENERIC_NOP5 GENERIC_NOP1 GENERIC_NOP4
-#define GENERIC_NOP6 ".byte 0x8d,0xb6,0x00,0x00,0x00,0x00\n"
-#define GENERIC_NOP7 ".byte 0x8d,0xb4,0x26,0x00,0x00,0x00,0x00\n"
-#define GENERIC_NOP8 GENERIC_NOP1 GENERIC_NOP7
+#define GENERIC_NOP1 0x90
+#define GENERIC_NOP2 0x89,0xf6
+#define GENERIC_NOP3 0x8d,0x76,0x00
+#define GENERIC_NOP4 0x8d,0x74,0x26,0x00
+#define GENERIC_NOP5 GENERIC_NOP1,GENERIC_NOP4
+#define GENERIC_NOP6 0x8d,0xb6,0x00,0x00,0x00,0x00
+#define GENERIC_NOP7 0x8d,0xb4,0x26,0x00,0x00,0x00,0x00
+#define GENERIC_NOP8 GENERIC_NOP1,GENERIC_NOP7
+#define GENERIC_NOP5_ATOMIC NOP_DS_PREFIX,GENERIC_NOP4
 
 /* Opteron 64bit nops
    1: nop
@@ -29,13 +36,14 @@
    4: osp osp osp nop
 */
 #define K8_NOP1 GENERIC_NOP1
-#define K8_NOP2 ".byte 0x66,0x90\n"
-#define K8_NOP3 ".byte 0x66,0x66,0x90\n"
-#define K8_NOP4 ".byte 0x66,0x66,0x66,0x90\n"
-#define K8_NOP5 K8_NOP3 K8_NOP2
-#define K8_NOP6 K8_NOP3 K8_NOP3
-#define K8_NOP7 K8_NOP4 K8_NOP3
-#define K8_NOP8 K8_NOP4 K8_NOP4
+#define K8_NOP2 0x66,K8_NOP1
+#define K8_NOP3 0x66,K8_NOP2
+#define K8_NOP4 0x66,K8_NOP3
+#define K8_NOP5 K8_NOP3,K8_NOP2
+#define K8_NOP6 K8_NOP3,K8_NOP3
+#define K8_NOP7 K8_NOP4,K8_NOP3
+#define K8_NOP8 K8_NOP4,K8_NOP4
+#define K8_NOP5_ATOMIC 0x66,K8_NOP4
 
 /* K7 nops
    uses eax dependencies (arbitrary choice)
@@ -47,13 +55,14 @@
    7: leal 0x00000000(,%eax,1),%eax
 */
 #define K7_NOP1 GENERIC_NOP1
-#define K7_NOP2 ".byte 0x8b,0xc0\n"
-#define K7_NOP3 ".byte 0x8d,0x04,0x20\n"
-#define K7_NOP4 ".byte 0x8d,0x44,0x20,0x00\n"
-#define K7_NOP5 K7_NOP4 ASM_NOP1
-#define K7_NOP6 ".byte 0x8d,0x80,0,0,0,0\n"
-#define K7_NOP7 ".byte 0x8D,0x04,0x05,0,0,0,0\n"
-#define K7_NOP8 K7_NOP7 ASM_NOP1
+#define K7_NOP2 0x8b,0xc0
+#define K7_NOP3 0x8d,0x04,0x20
+#define K7_NOP4 0x8d,0x44,0x20,0x00
+#define K7_NOP5 K7_NOP4,K7_NOP1
+#define K7_NOP6 0x8d,0x80,0,0,0,0
+#define K7_NOP7 0x8D,0x04,0x05,0,0,0,0
+#define K7_NOP8 K7_NOP7,K7_NOP1
+#define K7_NOP5_ATOMIC NOP_DS_PREFIX,K7_NOP4
 
 /* P6 nops
    uses eax dependencies (Intel-recommended choice)
@@ -69,52 +78,65 @@
         There is kernel code that depends on this.
 */
 #define P6_NOP1 GENERIC_NOP1
-#define P6_NOP2 ".byte 0x66,0x90\n"
-#define P6_NOP3 ".byte 0x0f,0x1f,0x00\n"
-#define P6_NOP4 ".byte 0x0f,0x1f,0x40,0\n"
-#define P6_NOP5 ".byte 0x0f,0x1f,0x44,0x00,0\n"
-#define P6_NOP6 ".byte 0x66,0x0f,0x1f,0x44,0x00,0\n"
-#define P6_NOP7 ".byte 0x0f,0x1f,0x80,0,0,0,0\n"
-#define P6_NOP8 ".byte 0x0f,0x1f,0x84,0x00,0,0,0,0\n"
+#define P6_NOP2 0x66,0x90
+#define P6_NOP3 0x0f,0x1f,0x00
+#define P6_NOP4 0x0f,0x1f,0x40,0
+#define P6_NOP5 0x0f,0x1f,0x44,0x00,0
+#define P6_NOP6 0x66,0x0f,0x1f,0x44,0x00,0
+#define P6_NOP7 0x0f,0x1f,0x80,0,0,0,0
+#define P6_NOP8 0x0f,0x1f,0x84,0x00,0,0,0,0
+#define P6_NOP5_ATOMIC P6_NOP5
+
+#define _ASM_MK_NOP(x) ".byte " __stringify(x) "\n"
 
 #if defined(CONFIG_MK7)
-#define ASM_NOP1 K7_NOP1
-#define ASM_NOP2 K7_NOP2
-#define ASM_NOP3 K7_NOP3
-#define ASM_NOP4 K7_NOP4
-#define ASM_NOP5 K7_NOP5
-#define ASM_NOP6 K7_NOP6
-#define ASM_NOP7 K7_NOP7
-#define ASM_NOP8 K7_NOP8
+#define ASM_NOP1 _ASM_MK_NOP(K7_NOP1)
+#define ASM_NOP2 _ASM_MK_NOP(K7_NOP2)
+#define ASM_NOP3 _ASM_MK_NOP(K7_NOP3)
+#define ASM_NOP4 _ASM_MK_NOP(K7_NOP4)
+#define ASM_NOP5 _ASM_MK_NOP(K7_NOP5)
+#define ASM_NOP6 _ASM_MK_NOP(K7_NOP6)
+#define ASM_NOP7 _ASM_MK_NOP(K7_NOP7)
+#define ASM_NOP8 _ASM_MK_NOP(K7_NOP8)
+#define ASM_NOP5_ATOMIC _ASM_MK_NOP(K7_NOP5_ATOMIC)
 #elif defined(CONFIG_X86_P6_NOP)
-#define ASM_NOP1 P6_NOP1
-#define ASM_NOP2 P6_NOP2
-#define ASM_NOP3 P6_NOP3
-#define ASM_NOP4 P6_NOP4
-#define ASM_NOP5 P6_NOP5
-#define ASM_NOP6 P6_NOP6
-#define ASM_NOP7 P6_NOP7
-#define ASM_NOP8 P6_NOP8
+#define ASM_NOP1 _ASM_MK_NOP(P6_NOP1)
+#define ASM_NOP2 _ASM_MK_NOP(P6_NOP2)
+#define ASM_NOP3 _ASM_MK_NOP(P6_NOP3)
+#define ASM_NOP4 _ASM_MK_NOP(P6_NOP4)
+#define ASM_NOP5 _ASM_MK_NOP(P6_NOP5)
+#define ASM_NOP6 _ASM_MK_NOP(P6_NOP6)
+#define ASM_NOP7 _ASM_MK_NOP(P6_NOP7)
+#define ASM_NOP8 _ASM_MK_NOP(P6_NOP8)
+#define ASM_NOP5_ATOMIC _ASM_MK_NOP(P6_NOP5_ATOMIC)
 #elif defined(CONFIG_X86_64)
-#define ASM_NOP1 K8_NOP1
-#define ASM_NOP2 K8_NOP2
-#define ASM_NOP3 K8_NOP3
-#define ASM_NOP4 K8_NOP4
-#define ASM_NOP5 K8_NOP5
-#define ASM_NOP6 K8_NOP6
-#define ASM_NOP7 K8_NOP7
-#define ASM_NOP8 K8_NOP8
+#define ASM_NOP1 _ASM_MK_NOP(K8_NOP1)
+#define ASM_NOP2 _ASM_MK_NOP(K8_NOP2)
+#define ASM_NOP3 _ASM_MK_NOP(K8_NOP3)
+#define ASM_NOP4 _ASM_MK_NOP(K8_NOP4)
+#define ASM_NOP5 _ASM_MK_NOP(K8_NOP5)
+#define ASM_NOP6 _ASM_MK_NOP(K8_NOP6)
+#define ASM_NOP7 _ASM_MK_NOP(K8_NOP7)
+#define ASM_NOP8 _ASM_MK_NOP(K8_NOP8)
+#define ASM_NOP5_ATOMIC _ASM_MK_NOP(K8_NOP5_ATOMIC)
 #else
-#define ASM_NOP1 GENERIC_NOP1
-#define ASM_NOP2 GENERIC_NOP2
-#define ASM_NOP3 GENERIC_NOP3
-#define ASM_NOP4 GENERIC_NOP4
-#define ASM_NOP5 GENERIC_NOP5
-#define ASM_NOP6 GENERIC_NOP6
-#define ASM_NOP7 GENERIC_NOP7
-#define ASM_NOP8 GENERIC_NOP8
+#define ASM_NOP1 _ASM_MK_NOP(GENERIC_NOP1)
+#define ASM_NOP2 _ASM_MK_NOP(GENERIC_NOP2)
+#define ASM_NOP3 _ASM_MK_NOP(GENERIC_NOP3)
+#define ASM_NOP4 _ASM_MK_NOP(GENERIC_NOP4)
+#define ASM_NOP5 _ASM_MK_NOP(GENERIC_NOP5)
+#define ASM_NOP6 _ASM_MK_NOP(GENERIC_NOP6)
+#define ASM_NOP7 _ASM_MK_NOP(GENERIC_NOP7)
+#define ASM_NOP8 _ASM_MK_NOP(GENERIC_NOP8)
+#define ASM_NOP5_ATOMIC _ASM_MK_NOP(GENERIC_NOP5_ATOMIC)
 #endif
 
 #define ASM_NOP_MAX 8
+#define NOP_ATOMIC5 (ASM_NOP_MAX+1)     /* Entry for the 5-byte atomic NOP */
+
+#ifndef __ASSEMBLY__
+extern const unsigned char * const *ideal_nops;
+extern void arch_init_ideal_nops(void);
+#endif
 
 #endif /* _ASM_X86_NOPS_H */
diff --git a/arch/x86/include/asm/numa.h b/arch/x86/include/asm/numa.h
index a50fc9f493b3..bfacd2ccf651 100644
--- a/arch/x86/include/asm/numa.h
+++ b/arch/x86/include/asm/numa.h
@@ -1,12 +1,24 @@
 #ifndef _ASM_X86_NUMA_H
 #define _ASM_X86_NUMA_H
 
+#include <linux/nodemask.h>
+
 #include <asm/topology.h>
 #include <asm/apicdef.h>
 
 #ifdef CONFIG_NUMA
 
 #define NR_NODE_MEMBLKS         (MAX_NUMNODES*2)
+#define ZONE_ALIGN (1UL << (MAX_ORDER+PAGE_SHIFT))
+
+/*
+ * Too small node sizes may confuse the VM badly. Usually they
+ * result from BIOS bugs. So dont recognize nodes as standalone
+ * NUMA entities that have less than this amount of RAM listed:
+ */
+#define NODE_MIN_SIZE (4*1024*1024)
+
+extern int numa_off;
 
 /*
  * __apicid_to_node[] stores the raw mapping between physical apicid and
@@ -17,15 +29,27 @@
  * numa_cpu_node().
  */
 extern s16 __apicid_to_node[MAX_LOCAL_APIC];
+extern nodemask_t numa_nodes_parsed __initdata;
+
+extern int __init numa_add_memblk(int nodeid, u64 start, u64 end);
+extern void __init numa_set_distance(int from, int to, int distance);
 
 static inline void set_apicid_to_node(int apicid, s16 node)
 {
         __apicid_to_node[apicid] = node;
 }
+
+extern int __cpuinit numa_cpu_node(int cpu);
+
 #else   /* CONFIG_NUMA */
 static inline void set_apicid_to_node(int apicid, s16 node)
 {
 }
+
+static inline int numa_cpu_node(int cpu)
+{
+        return NUMA_NO_NODE;
+}
 #endif  /* CONFIG_NUMA */
 
 #ifdef CONFIG_X86_32
@@ -37,14 +61,12 @@ static inline void set_apicid_to_node(int apicid, s16 node)
 #ifdef CONFIG_NUMA
 extern void __cpuinit numa_set_node(int cpu, int node);
 extern void __cpuinit numa_clear_node(int cpu);
-extern void __init numa_init_array(void);
 extern void __init init_cpu_to_node(void);
 extern void __cpuinit numa_add_cpu(int cpu);
 extern void __cpuinit numa_remove_cpu(int cpu);
 #else   /* CONFIG_NUMA */
 static inline void numa_set_node(int cpu, int node)     { }
 static inline void numa_clear_node(int cpu)             { }
-static inline void numa_init_array(void)                { }
 static inline void init_cpu_to_node(void)               { }
 static inline void numa_add_cpu(int cpu)                { }
 static inline void numa_remove_cpu(int cpu)             { }
@@ -54,4 +76,10 @@ static inline void numa_remove_cpu(int cpu)		{ }
 void debug_cpumask_set_cpu(int cpu, int node, bool enable);
 #endif
 
+#ifdef CONFIG_NUMA_EMU
+#define FAKE_NODE_MIN_SIZE      ((u64)32 << 20)
+#define FAKE_NODE_MIN_HASH_MASK (~(FAKE_NODE_MIN_SIZE - 1UL))
+void numa_emu_cmdline(char *);
+#endif /* CONFIG_NUMA_EMU */
+
 #endif  /* _ASM_X86_NUMA_H */
diff --git a/arch/x86/include/asm/numa_32.h b/arch/x86/include/asm/numa_32.h
index c6beed1ef103..e7d6b8254742 100644
--- a/arch/x86/include/asm/numa_32.h
+++ b/arch/x86/include/asm/numa_32.h
@@ -1,16 +1,6 @@
 #ifndef _ASM_X86_NUMA_32_H
 #define _ASM_X86_NUMA_32_H
 
-extern int numa_off;
-
-extern int pxm_to_nid(int pxm);
-
-#ifdef CONFIG_NUMA
-extern int __cpuinit numa_cpu_node(int cpu);
-#else   /* CONFIG_NUMA */
-static inline int numa_cpu_node(int cpu)                { return NUMA_NO_NODE; }
-#endif  /* CONFIG_NUMA */
-
 #ifdef CONFIG_HIGHMEM
 extern void set_highmem_pages_init(void);
 #else
diff --git a/arch/x86/include/asm/numa_64.h b/arch/x86/include/asm/numa_64.h
index 344eb1790b46..0c05f7ae46e8 100644
--- a/arch/x86/include/asm/numa_64.h
+++ b/arch/x86/include/asm/numa_64.h
@@ -1,42 +1,6 @@
 #ifndef _ASM_X86_NUMA_64_H
 #define _ASM_X86_NUMA_64_H
 
-#include <linux/nodemask.h>
-
-struct bootnode {
-        u64 start;
-        u64 end;
-};
-
-#define ZONE_ALIGN (1UL << (MAX_ORDER+PAGE_SHIFT))
-
-extern int numa_off;
-
 extern unsigned long numa_free_all_bootmem(void);
-extern void setup_node_bootmem(int nodeid, unsigned long start,
-                               unsigned long end);
-
-#ifdef CONFIG_NUMA
-/*
- * Too small node sizes may confuse the VM badly. Usually they
- * result from BIOS bugs. So dont recognize nodes as standalone
- * NUMA entities that have less than this amount of RAM listed:
- */
-#define NODE_MIN_SIZE (4*1024*1024)
-
-extern nodemask_t numa_nodes_parsed __initdata;
-
-extern int __cpuinit numa_cpu_node(int cpu);
-extern int __init numa_add_memblk(int nodeid, u64 start, u64 end);
-extern void __init numa_set_distance(int from, int to, int distance);
-
-#ifdef CONFIG_NUMA_EMU
-#define FAKE_NODE_MIN_SIZE      ((u64)32 << 20)
-#define FAKE_NODE_MIN_HASH_MASK (~(FAKE_NODE_MIN_SIZE - 1UL))
-void numa_emu_cmdline(char *);
-#endif /* CONFIG_NUMA_EMU */
-#else
-static inline int numa_cpu_node(int cpu)                { return NUMA_NO_NODE; }
-#endif
 
 #endif /* _ASM_X86_NUMA_64_H */
diff --git a/arch/x86/include/asm/numaq.h b/arch/x86/include/asm/numaq.h
index 37c516545ec8..c3b3c322fd87 100644
--- a/arch/x86/include/asm/numaq.h
+++ b/arch/x86/include/asm/numaq.h
@@ -29,7 +29,7 @@
 #ifdef CONFIG_X86_NUMAQ
 
 extern int found_numaq;
-extern int get_memcfg_numaq(void);
+extern int numaq_numa_init(void);
 extern int pci_numaq_init(void);
 
 extern void *xquad_portio;
@@ -166,11 +166,6 @@ struct sys_cfg_data {
 
 void numaq_tsc_disable(void);
 
-#else
-static inline int get_memcfg_numaq(void)
-{
-        return 0;
-}
 #endif /* CONFIG_X86_NUMAQ */
 #endif /* _ASM_X86_NUMAQ_H */
 
diff --git a/arch/x86/include/asm/olpc_ofw.h b/arch/x86/include/asm/olpc_ofw.h
index c5d3a5abbb9f..24487712e0b1 100644
--- a/arch/x86/include/asm/olpc_ofw.h
+++ b/arch/x86/include/asm/olpc_ofw.h
@@ -26,15 +26,12 @@ extern void setup_olpc_ofw_pgd(void);
 /* check if OFW was detected during boot */
 extern bool olpc_ofw_present(void);
 
+extern void olpc_dt_build_devicetree(void);
+
 #else /* !CONFIG_OLPC */
 static inline void olpc_ofw_detect(void) { }
 static inline void setup_olpc_ofw_pgd(void) { }
-#endif /* !CONFIG_OLPC */
-
-#ifdef CONFIG_OF_PROMTREE
-extern void olpc_dt_build_devicetree(void);
-#else
 static inline void olpc_dt_build_devicetree(void) { }
-#endif
+#endif /* !CONFIG_OLPC */
 
 #endif /* _ASM_X86_OLPC_OFW_H */
diff --git a/arch/x86/include/asm/percpu.h b/arch/x86/include/asm/percpu.h
index d475b4398d8b..53278b0dfdf6 100644
--- a/arch/x86/include/asm/percpu.h
+++ b/arch/x86/include/asm/percpu.h
@@ -517,7 +517,7 @@ do {									\
         typeof(o2) __o2 = o2;                                           \
         typeof(o2) __n2 = n2;                                           \
         typeof(o2) __dummy;                                             \
-        alternative_io("call this_cpu_cmpxchg16b_emu\n\t" P6_NOP4,      \
+        alternative_io("call this_cpu_cmpxchg16b_emu\n\t" ASM_NOP4,     \
                        "cmpxchg16b " __percpu_prefix "(%%rsi)\n\tsetz %0\n\t",  \
                        X86_FEATURE_CX16,                                \
                        ASM_OUTPUT2("=a"(__ret), "=d"(__dummy)),         \
@@ -542,6 +542,33 @@ do {									\
         old__;                                                          \
 })
 
+static __always_inline int x86_this_cpu_constant_test_bit(unsigned int nr,
+                        const unsigned long __percpu *addr)
+{
+        unsigned long __percpu *a = (unsigned long *)addr + nr / BITS_PER_LONG;
+
+        return ((1UL << (nr % BITS_PER_LONG)) & percpu_read(*a)) != 0;
+}
+
+static inline int x86_this_cpu_variable_test_bit(int nr,
+                        const unsigned long __percpu *addr)
+{
+        int oldbit;
+
+        asm volatile("bt "__percpu_arg(2)",%1\n\t"
+                        "sbb %0,%0"
+                        : "=r" (oldbit)
+                        : "m" (*(unsigned long *)addr), "Ir" (nr));
+
+        return oldbit;
+}
+
+#define x86_this_cpu_test_bit(nr, addr)                 \
+        (__builtin_constant_p((nr))                     \
+         ? x86_this_cpu_constant_test_bit((nr), (addr)) \
+         : x86_this_cpu_variable_test_bit((nr), (addr)))
+
+
 #include <asm-generic/percpu.h>
 
 /* We can use this directly for local CPU (faster). */
diff --git a/arch/x86/include/asm/probe_roms.h b/arch/x86/include/asm/probe_roms.h
new file mode 100644
index 000000000000..4950a0b1d09c
--- /dev/null
+++ b/arch/x86/include/asm/probe_roms.h
@@ -0,0 +1,8 @@
+#ifndef _PROBE_ROMS_H_
+#define _PROBE_ROMS_H_
+struct pci_dev;
+
+extern void __iomem *pci_map_biosrom(struct pci_dev *pdev);
+extern void pci_unmap_biosrom(void __iomem *rom);
+extern size_t pci_biosrom_size(struct pci_dev *pdev);
+#endif
diff --git a/arch/x86/include/asm/processor-flags.h b/arch/x86/include/asm/processor-flags.h
index a898a2b6e10c..59ab4dffa377 100644
--- a/arch/x86/include/asm/processor-flags.h
+++ b/arch/x86/include/asm/processor-flags.h
@@ -60,6 +60,7 @@
 #define X86_CR4_OSXMMEXCPT 0x00000400 /* enable unmasked SSE exceptions */
 #define X86_CR4_VMXE    0x00002000 /* enable VMX virtualization */
 #define X86_CR4_OSXSAVE 0x00040000 /* enable xsave and xrestore */
+#define X86_CR4_SMEP    0x00100000 /* enable SMEP support */
 
 /*
  * x86-64 Task Priority Register, CR8
diff --git a/arch/x86/include/asm/setup.h b/arch/x86/include/asm/setup.h
index db8aa19a08a2..9756551ec760 100644
--- a/arch/x86/include/asm/setup.h
+++ b/arch/x86/include/asm/setup.h
@@ -88,7 +88,7 @@ void *extend_brk(size_t size, size_t align);
  * executable.)
  */
 #define RESERVE_BRK(name,sz)                                            \
-        static void __section(.discard.text) __used                     \
+        static void __section(.discard.text) __used notrace             \
         __brk_reservation_fn_##name##__(void) {                         \
                 asm volatile (                                          \
                         ".pushsection .brk_reservation,\"aw\",@nobits;" \
@@ -104,10 +104,10 @@ void *extend_brk(size_t size, size_t align);
         type *name;                                     \
         RESERVE_BRK(name, sizeof(type) * entries)
 
+extern void probe_roms(void);
 #ifdef __i386__
 
 void __init i386_start_kernel(void);
-extern void probe_roms(void);
 
 #else
 void __init x86_64_start_kernel(char *real_mode);
diff --git a/arch/x86/include/asm/srat.h b/arch/x86/include/asm/srat.h
deleted file mode 100644
index b508d639d1a7..000000000000
--- a/arch/x86/include/asm/srat.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Some of the code in this file has been gleaned from the 64 bit
- * discontigmem support code base.
- *
- * Copyright (C) 2002, IBM Corp.
- *
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * Send feedback to Pat Gaughen <gone@us.ibm.com>
- */
-
-#ifndef _ASM_X86_SRAT_H
-#define _ASM_X86_SRAT_H
-
-#ifdef CONFIG_ACPI_NUMA
-extern int get_memcfg_from_srat(void);
-#else
-static inline int get_memcfg_from_srat(void)
-{
-        return 0;
-}
-#endif
-
-#endif /* _ASM_X86_SRAT_H */
diff --git a/arch/x86/include/asm/stacktrace.h b/arch/x86/include/asm/stacktrace.h
index d7e89c83645d..70bbe39043a9 100644
--- a/arch/x86/include/asm/stacktrace.h
+++ b/arch/x86/include/asm/stacktrace.h
@@ -37,9 +37,6 @@ print_context_stack_bp(struct thread_info *tinfo,
 /* Generic stack tracer with callbacks */
 
 struct stacktrace_ops {
-        void (*warning)(void *data, char *msg);
-        /* msg must contain %s for the symbol */
-        void (*warning_symbol)(void *data, char *msg, unsigned long symbol);
         void (*address)(void *data, unsigned long address, int reliable);
         /* On negative return stop dumping */
         int (*stack)(void *data, char *name);
diff --git a/arch/x86/include/asm/system.h b/arch/x86/include/asm/system.h
index 12569e691ce3..c2ff2a1d845e 100644
--- a/arch/x86/include/asm/system.h
+++ b/arch/x86/include/asm/system.h
@@ -303,24 +303,81 @@ static inline void native_wbinvd(void)
 #ifdef CONFIG_PARAVIRT
 #include <asm/paravirt.h>
 #else
-#define read_cr0()      (native_read_cr0())
-#define write_cr0(x)    (native_write_cr0(x))
-#define read_cr2()      (native_read_cr2())
-#define write_cr2(x)    (native_write_cr2(x))
-#define read_cr3()      (native_read_cr3())
-#define write_cr3(x)    (native_write_cr3(x))
-#define read_cr4()      (native_read_cr4())
-#define read_cr4_safe() (native_read_cr4_safe())
-#define write_cr4(x)    (native_write_cr4(x))
-#define wbinvd()        (native_wbinvd())
+
+static inline unsigned long read_cr0(void)
+{
+        return native_read_cr0();
+}
+
+static inline void write_cr0(unsigned long x)
+{
+        native_write_cr0(x);
+}
+
+static inline unsigned long read_cr2(void)
+{
+        return native_read_cr2();
+}
+
+static inline void write_cr2(unsigned long x)
+{
+        native_write_cr2(x);
+}
+
+static inline unsigned long read_cr3(void)
+{
+        return native_read_cr3();
+}
+
+static inline void write_cr3(unsigned long x)
+{
+        native_write_cr3(x);
+}
+
+static inline unsigned long read_cr4(void)
+{
+        return native_read_cr4();
+}
+
+static inline unsigned long read_cr4_safe(void)
+{
+        return native_read_cr4_safe();
+}
+
+static inline void write_cr4(unsigned long x)
+{
+        native_write_cr4(x);
+}
+
+static inline void wbinvd(void)
+{
+        native_wbinvd();
+}
+
 #ifdef CONFIG_X86_64
-#define read_cr8()      (native_read_cr8())
-#define write_cr8(x)    (native_write_cr8(x))
-#define load_gs_index   native_load_gs_index
+
+static inline unsigned long read_cr8(void)
+{
+        return native_read_cr8();
+}
+
+static inline void write_cr8(unsigned long x)
+{
+        native_write_cr8(x);
+}
+
+static inline void load_gs_index(unsigned selector)
+{
+        native_load_gs_index(selector);
+}
+
 #endif
 
 /* Clear the 'TS' bit */
-#define clts()          (native_clts())
+static inline void clts(void)
+{
+        native_clts();
+}
 
 #endif/* CONFIG_PARAVIRT */
 
diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
index 910a7084f7f2..c00692476e9f 100644
--- a/arch/x86/include/asm/topology.h
+++ b/arch/x86/include/asm/topology.h
@@ -93,19 +93,11 @@ extern void setup_node_to_cpumask_map(void);
 #define pcibus_to_node(bus) __pcibus_to_node(bus)
 
 #ifdef CONFIG_X86_32
-extern unsigned long node_start_pfn[];
-extern unsigned long node_end_pfn[];
-extern unsigned long node_remap_size[];
-#define node_has_online_mem(nid) (node_start_pfn[nid] != node_end_pfn[nid])
-
 # define SD_CACHE_NICE_TRIES    1
 # define SD_IDLE_IDX            1
-
 #else
-
 # define SD_CACHE_NICE_TRIES    2
 # define SD_IDLE_IDX            2
-
 #endif
 
 /* sched_domains SD_NODE_INIT for NUMA machines */
diff --git a/arch/x86/include/asm/uaccess.h b/arch/x86/include/asm/uaccess.h
index abd3e0ea762a..99ddd148a760 100644
--- a/arch/x86/include/asm/uaccess.h
+++ b/arch/x86/include/asm/uaccess.h
@@ -6,7 +6,6 @@
 #include <linux/errno.h>
 #include <linux/compiler.h>
 #include <linux/thread_info.h>
-#include <linux/prefetch.h>
 #include <linux/string.h>
 #include <asm/asm.h>
 #include <asm/page.h>
@@ -42,7 +41,7 @@
  * Returns 0 if the range is valid, nonzero otherwise.
  *
  * This is equivalent to the following test:
- * (u33)addr + (u33)size >= (u33)current->addr_limit.seg (u65 for x86_64)
+ * (u33)addr + (u33)size > (u33)current->addr_limit.seg (u65 for x86_64)
  *
  * This needs 33-bit (65-bit for x86_64) arithmetic. We have a carry...
  */
diff --git a/arch/x86/include/asm/uaccess_32.h b/arch/x86/include/asm/uaccess_32.h
index 088d09fb1615..566e803cc602 100644
--- a/arch/x86/include/asm/uaccess_32.h
+++ b/arch/x86/include/asm/uaccess_32.h
@@ -6,7 +6,6 @@
  */
 #include <linux/errno.h>
 #include <linux/thread_info.h>
-#include <linux/prefetch.h>
 #include <linux/string.h>
 #include <asm/asm.h>
 #include <asm/page.h>
diff --git a/arch/x86/include/asm/uaccess_64.h b/arch/x86/include/asm/uaccess_64.h
index 316708d5af92..1c66d30971ad 100644
--- a/arch/x86/include/asm/uaccess_64.h
+++ b/arch/x86/include/asm/uaccess_64.h
@@ -6,7 +6,6 @@
  */
 #include <linux/compiler.h>
 #include <linux/errno.h>
-#include <linux/prefetch.h>
 #include <linux/lockdep.h>
 #include <asm/alternative.h>
 #include <asm/cpufeature.h>
diff --git a/arch/x86/include/asm/unistd_32.h b/arch/x86/include/asm/unistd_32.h
index a755ef5e5977..fb6a625c99bf 100644
--- a/arch/x86/include/asm/unistd_32.h
+++ b/arch/x86/include/asm/unistd_32.h
@@ -350,10 +350,11 @@
 #define __NR_open_by_handle_at  342
 #define __NR_clock_adjtime      343
 #define __NR_syncfs             344
+#define __NR_sendmmsg           345
 
 #ifdef __KERNEL__
 
-#define NR_syscalls 345
+#define NR_syscalls 346
 
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
diff --git a/arch/x86/include/asm/unistd_64.h b/arch/x86/include/asm/unistd_64.h
index 160fa76bd578..79f90eb15aad 100644
--- a/arch/x86/include/asm/unistd_64.h
+++ b/arch/x86/include/asm/unistd_64.h
@@ -677,6 +677,8 @@ __SYSCALL(__NR_open_by_handle_at, sys_open_by_handle_at)
 __SYSCALL(__NR_clock_adjtime, sys_clock_adjtime)
 #define __NR_syncfs                             306
 __SYSCALL(__NR_syncfs, sys_syncfs)
+#define __NR_sendmmsg                           307
+__SYSCALL(__NR_sendmmsg, sys_sendmmsg)
 
 #ifndef __NO_STUBS
 #define __ARCH_WANT_OLD_READDIR
diff --git a/arch/x86/include/asm/uv/uv_bau.h b/arch/x86/include/asm/uv/uv_bau.h
index 3e094af443c3..130f1eeee5fe 100644
--- a/arch/x86/include/asm/uv/uv_bau.h
+++ b/arch/x86/include/asm/uv/uv_bau.h
@@ -94,6 +94,8 @@
 /* after this # consecutive successes, bump up the throttle if it was lowered */
 #define COMPLETE_THRESHOLD 5
 
+#define UV_LB_SUBNODEID 0x10
+
 /*
  * number of entries in the destination side payload queue
  */
@@ -124,7 +126,7 @@
  * The distribution specification (32 bytes) is interpreted as a 256-bit
  * distribution vector. Adjacent bits correspond to consecutive even numbered
  * nodeIDs. The result of adding the index of a given bit to the 15-bit
- * 'base_dest_nodeid' field of the header corresponds to the
+ * 'base_dest_nasid' field of the header corresponds to the
  * destination nodeID associated with that specified bit.
  */
 struct bau_target_uvhubmask {
@@ -176,7 +178,7 @@ struct bau_msg_payload {
 struct bau_msg_header {
         unsigned int dest_subnodeid:6;  /* must be 0x10, for the LB */
         /* bits 5:0 */
-        unsigned int base_dest_nodeid:15; /* nasid of the */
+        unsigned int base_dest_nasid:15; /* nasid of the */
         /* bits 20:6 */                   /* first bit in uvhub map */
         unsigned int command:8; /* message type */
         /* bits 28:21 */
@@ -378,6 +380,10 @@ struct ptc_stats {
         unsigned long d_rcanceled; /* number of messages canceled by resets */
 };
 
+struct hub_and_pnode {
+        short uvhub;
+        short pnode;
+};
 /*
  * one per-cpu; to locate the software tables
  */
@@ -399,10 +405,12 @@ struct bau_control {
         int baudisabled;
         int set_bau_off;
         short cpu;
+        short osnode;
         short uvhub_cpu;
         short uvhub;
         short cpus_in_socket;
         short cpus_in_uvhub;
+        short partition_base_pnode;
         unsigned short message_number;
         unsigned short uvhub_quiesce;
         short socket_acknowledge_count[DEST_Q_SIZE];
@@ -422,15 +430,16 @@ struct bau_control {
         int congested_period;
         cycles_t period_time;
         long period_requests;
+        struct hub_and_pnode *target_hub_and_pnode;
 };
 
 static inline int bau_uvhub_isset(int uvhub, struct bau_target_uvhubmask *dstp)
 {
         return constant_test_bit(uvhub, &dstp->bits[0]);
 }
-static inline void bau_uvhub_set(int uvhub, struct bau_target_uvhubmask *dstp)
+static inline void bau_uvhub_set(int pnode, struct bau_target_uvhubmask *dstp)
 {
-        __set_bit(uvhub, &dstp->bits[0]);
+        __set_bit(pnode, &dstp->bits[0]);
 }
 static inline void bau_uvhubs_clear(struct bau_target_uvhubmask *dstp,
                                     int nbits)
diff --git a/arch/x86/include/asm/uv/uv_hub.h b/arch/x86/include/asm/uv/uv_hub.h
index a501741c2335..4298002d0c83 100644
--- a/arch/x86/include/asm/uv/uv_hub.h
+++ b/arch/x86/include/asm/uv/uv_hub.h
@@ -398,6 +398,8 @@ struct uv_blade_info {
         unsigned short  nr_online_cpus;
         unsigned short  pnode;
         short           memory_nid;
+        spinlock_t      nmi_lock;
+        unsigned long   nmi_count;
 };
 extern struct uv_blade_info *uv_blade_info;
 extern short *uv_node_to_blade;
diff --git a/arch/x86/include/asm/uv/uv_mmrs.h b/arch/x86/include/asm/uv/uv_mmrs.h
index 20cafeac7455..f5bb64a823d7 100644
--- a/arch/x86/include/asm/uv/uv_mmrs.h
+++ b/arch/x86/include/asm/uv/uv_mmrs.h
@@ -5,7 +5,7 @@
  *
  * SGI UV MMR definitions
  *
- * Copyright (C) 2007-2010 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2007-2011 Silicon Graphics, Inc. All rights reserved.
  */
 
 #ifndef _ASM_X86_UV_UV_MMRS_H
@@ -1099,5 +1099,19 @@ union uvh_rtc1_int_config_u {
     } s;
 };
 
+/* ========================================================================= */
+/*                               UVH_SCRATCH5                                */
+/* ========================================================================= */
+#define UVH_SCRATCH5 0x2d0200UL
+#define UVH_SCRATCH5_32 0x00778
+
+#define UVH_SCRATCH5_SCRATCH5_SHFT 0
+#define UVH_SCRATCH5_SCRATCH5_MASK 0xffffffffffffffffUL
+union uvh_scratch5_u {
+    unsigned long       v;
+    struct uvh_scratch5_s {
+        unsigned long   scratch5 : 64;  /* RW, W1CS */
+    } s;
+};
 
 #endif /* __ASM_UV_MMRS_X86_H__ */
diff --git a/arch/x86/include/asm/xen/page.h b/arch/x86/include/asm/xen/page.h
index c61934fbf22a..64a619d47d34 100644
--- a/arch/x86/include/asm/xen/page.h
+++ b/arch/x86/include/asm/xen/page.h
@@ -47,8 +47,9 @@ extern bool __set_phys_to_machine(unsigned long pfn, unsigned long mfn);
 extern unsigned long set_phys_range_identity(unsigned long pfn_s,
                                              unsigned long pfn_e);
 
-extern int m2p_add_override(unsigned long mfn, struct page *page);
-extern int m2p_remove_override(struct page *page);
+extern int m2p_add_override(unsigned long mfn, struct page *page,
+                            bool clear_pte);
+extern int m2p_remove_override(struct page *page, bool clear_pte);
 extern struct page *m2p_find_override(unsigned long mfn);
 extern unsigned long m2p_find_override_pfn(unsigned long mfn, unsigned long pfn);
 
diff --git a/arch/x86/include/asm/xen/pci.h b/arch/x86/include/asm/xen/pci.h
index aa8620989162..4fbda9a3f339 100644
--- a/arch/x86/include/asm/xen/pci.h
+++ b/arch/x86/include/asm/xen/pci.h
@@ -15,10 +15,26 @@ static inline int pci_xen_hvm_init(void)
 #endif
 #if defined(CONFIG_XEN_DOM0)
 void __init xen_setup_pirqs(void);
+int xen_find_device_domain_owner(struct pci_dev *dev);
+int xen_register_device_domain_owner(struct pci_dev *dev, uint16_t domain);
+int xen_unregister_device_domain_owner(struct pci_dev *dev);
 #else
 static inline void __init xen_setup_pirqs(void)
 {
 }
+static inline int xen_find_device_domain_owner(struct pci_dev *dev)
+{
+        return -1;
+}
+static inline int xen_register_device_domain_owner(struct pci_dev *dev,
+                                                   uint16_t domain)
+{
+        return -1;
+}
+static inline int xen_unregister_device_domain_owner(struct pci_dev *dev)
+{
+        return -1;
+}
 #endif
 
 #if defined(CONFIG_PCI_MSI)
diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index 7338ef2218bc..250806472a7e 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -36,7 +36,7 @@ obj-y			+= traps.o irq.o irq_$(BITS).o dumpstack_$(BITS).o
 obj-y                   += time.o ioport.o ldt.o dumpstack.o
 obj-y                   += setup.o x86_init.o i8259.o irqinit.o jump_label.o
 obj-$(CONFIG_IRQ_WORK)  += irq_work.o
-obj-$(CONFIG_X86_32)    += probe_roms_32.o
+obj-y                   += probe_roms.o
 obj-$(CONFIG_X86_32)    += sys_i386_32.o i386_ksyms_32.o
 obj-$(CONFIG_X86_64)    += sys_x86_64.o x8664_ksyms_64.o
 obj-$(CONFIG_X86_64)    += syscall_64.o vsyscall_64.o
@@ -117,7 +117,7 @@ obj-$(CONFIG_OF)			+= devicetree.o
 ifeq ($(CONFIG_X86_64),y)
         obj-$(CONFIG_AUDIT)             += audit_64.o
 
-        obj-$(CONFIG_GART_IOMMU)        += pci-gart_64.o aperture_64.o
+        obj-$(CONFIG_GART_IOMMU)        += amd_gart_64.o aperture_64.o
         obj-$(CONFIG_CALGARY_IOMMU)     += pci-calgary_64.o tce_64.o
         obj-$(CONFIG_AMD_IOMMU)         += amd_iommu_init.o amd_iommu.o
 
diff --git a/arch/x86/kernel/acpi/sleep.c b/arch/x86/kernel/acpi/sleep.c
index ff93bc1b09c3..18a857ba7a25 100644
--- a/arch/x86/kernel/acpi/sleep.c
+++ b/arch/x86/kernel/acpi/sleep.c
@@ -112,11 +112,6 @@ static int __init acpi_sleep_setup(char *str)
 #ifdef CONFIG_HIBERNATION
                 if (strncmp(str, "s4_nohwsig", 10) == 0)
                         acpi_no_s4_hw_signature();
-                if (strncmp(str, "s4_nonvs", 8) == 0) {
-                        pr_warning("ACPI: acpi_sleep=s4_nonvs is deprecated, "
-                                        "please use acpi_sleep=nonvs instead");
-                        acpi_nvs_nosave();
-                }
 #endif
                 if (strncmp(str, "nonvs", 5) == 0)
                         acpi_nvs_nosave();
diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c
index 4a234677e213..a81f2d52f869 100644
--- a/arch/x86/kernel/alternative.c
+++ b/arch/x86/kernel/alternative.c
@@ -67,17 +67,30 @@ __setup("noreplace-paravirt", setup_noreplace_paravirt);
 #define DPRINTK(fmt, args...) if (debug_alternative) \
         printk(KERN_DEBUG fmt, args)
 
+/*
+ * Each GENERIC_NOPX is of X bytes, and defined as an array of bytes
+ * that correspond to that nop. Getting from one nop to the next, we
+ * add to the array the offset that is equal to the sum of all sizes of
+ * nops preceding the one we are after.
+ *
+ * Note: The GENERIC_NOP5_ATOMIC is at the end, as it breaks the
+ * nice symmetry of sizes of the previous nops.
+ */
 #if defined(GENERIC_NOP1) && !defined(CONFIG_X86_64)
-/* Use inline assembly to define this because the nops are defined
-   as inline assembly strings in the include files and we cannot
-   get them easily into strings. */
-asm("\t" __stringify(__INITRODATA_OR_MODULE) "\nintelnops: "
-        GENERIC_NOP1 GENERIC_NOP2 GENERIC_NOP3 GENERIC_NOP4 GENERIC_NOP5 GENERIC_NOP6
-        GENERIC_NOP7 GENERIC_NOP8
-    "\t.previous");
-extern const unsigned char intelnops[];
-static const unsigned char *const __initconst_or_module
-intel_nops[ASM_NOP_MAX+1] = {
+static const unsigned char intelnops[] =
+{
+        GENERIC_NOP1,
+        GENERIC_NOP2,
+        GENERIC_NOP3,
+        GENERIC_NOP4,
+        GENERIC_NOP5,
+        GENERIC_NOP6,
+        GENERIC_NOP7,
+        GENERIC_NOP8,
+        GENERIC_NOP5_ATOMIC
+};
+static const unsigned char * const intel_nops[ASM_NOP_MAX+2] =
+{
         NULL,
         intelnops,
         intelnops + 1,
@@ -87,17 +100,25 @@ intel_nops[ASM_NOP_MAX+1] = {
         intelnops + 1 + 2 + 3 + 4 + 5,
         intelnops + 1 + 2 + 3 + 4 + 5 + 6,
         intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
+        intelnops + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8,
 };
 #endif
 
 #ifdef K8_NOP1
-asm("\t" __stringify(__INITRODATA_OR_MODULE) "\nk8nops: "
-        K8_NOP1 K8_NOP2 K8_NOP3 K8_NOP4 K8_NOP5 K8_NOP6
-        K8_NOP7 K8_NOP8
-    "\t.previous");
-extern const unsigned char k8nops[];
-static const unsigned char *const __initconst_or_module
-k8_nops[ASM_NOP_MAX+1] = {
+static const unsigned char k8nops[] =
+{
+        K8_NOP1,
+        K8_NOP2,
+        K8_NOP3,
+        K8_NOP4,
+        K8_NOP5,
+        K8_NOP6,
+        K8_NOP7,
+        K8_NOP8,
+        K8_NOP5_ATOMIC
+};
+static const unsigned char * const k8_nops[ASM_NOP_MAX+2] =
+{
         NULL,
         k8nops,
         k8nops + 1,
@@ -107,17 +128,25 @@ k8_nops[ASM_NOP_MAX+1] = {
         k8nops + 1 + 2 + 3 + 4 + 5,
         k8nops + 1 + 2 + 3 + 4 + 5 + 6,
         k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
+        k8nops + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8,
 };
 #endif
 
 #if defined(K7_NOP1) && !defined(CONFIG_X86_64)
-asm("\t" __stringify(__INITRODATA_OR_MODULE) "\nk7nops: "
-        K7_NOP1 K7_NOP2 K7_NOP3 K7_NOP4 K7_NOP5 K7_NOP6
-        K7_NOP7 K7_NOP8
-    "\t.previous");
-extern const unsigned char k7nops[];
-static const unsigned char *const __initconst_or_module
-k7_nops[ASM_NOP_MAX+1] = {
+static const unsigned char k7nops[] =
+{
+        K7_NOP1,
+        K7_NOP2,
+        K7_NOP3,
+        K7_NOP4,
+        K7_NOP5,
+        K7_NOP6,
+        K7_NOP7,
+        K7_NOP8,
+        K7_NOP5_ATOMIC
+};
+static const unsigned char * const k7_nops[ASM_NOP_MAX+2] =
+{
         NULL,
         k7nops,
         k7nops + 1,
@@ -127,17 +156,25 @@ k7_nops[ASM_NOP_MAX+1] = {
         k7nops + 1 + 2 + 3 + 4 + 5,
         k7nops + 1 + 2 + 3 + 4 + 5 + 6,
         k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
+        k7nops + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8,
 };
 #endif
 
 #ifdef P6_NOP1
-asm("\t" __stringify(__INITRODATA_OR_MODULE) "\np6nops: "
-        P6_NOP1 P6_NOP2 P6_NOP3 P6_NOP4 P6_NOP5 P6_NOP6
-        P6_NOP7 P6_NOP8
-    "\t.previous");
-extern const unsigned char p6nops[];
-static const unsigned char *const __initconst_or_module
-p6_nops[ASM_NOP_MAX+1] = {
+static const unsigned char  __initconst_or_module p6nops[] =
+{
+        P6_NOP1,
+        P6_NOP2,
+        P6_NOP3,
+        P6_NOP4,
+        P6_NOP5,
+        P6_NOP6,
+        P6_NOP7,
+        P6_NOP8,
+        P6_NOP5_ATOMIC
+};
+static const unsigned char * const p6_nops[ASM_NOP_MAX+2] =
+{
         NULL,
         p6nops,
         p6nops + 1,
@@ -147,47 +184,65 @@ p6_nops[ASM_NOP_MAX+1] = {
         p6nops + 1 + 2 + 3 + 4 + 5,
         p6nops + 1 + 2 + 3 + 4 + 5 + 6,
         p6nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
+        p6nops + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8,
 };
 #endif
 
+/* Initialize these to a safe default */
 #ifdef CONFIG_X86_64
+const unsigned char * const *ideal_nops = p6_nops;
+#else
+const unsigned char * const *ideal_nops = intel_nops;
+#endif
 
-extern char __vsyscall_0;
-static const unsigned char *const *__init_or_module find_nop_table(void)
+void __init arch_init_ideal_nops(void)
 {
-        if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL &&
-            boot_cpu_has(X86_FEATURE_NOPL))
-                return p6_nops;
-        else
-                return k8_nops;
-}
-
-#else /* CONFIG_X86_64 */
+        switch (boot_cpu_data.x86_vendor) {
+        case X86_VENDOR_INTEL:
+                /*
+                 * Due to a decoder implementation quirk, some
+                 * specific Intel CPUs actually perform better with
+                 * the "k8_nops" than with the SDM-recommended NOPs.
+                 */
+                if (boot_cpu_data.x86 == 6 &&
+                    boot_cpu_data.x86_model >= 0x0f &&
+                    boot_cpu_data.x86_model != 0x1c &&
+                    boot_cpu_data.x86_model != 0x26 &&
+                    boot_cpu_data.x86_model != 0x27 &&
+                    boot_cpu_data.x86_model < 0x30) {
+                        ideal_nops = k8_nops;
+                } else if (boot_cpu_has(X86_FEATURE_NOPL)) {
+                           ideal_nops = p6_nops;
+                } else {
+#ifdef CONFIG_X86_64
+                        ideal_nops = k8_nops;
+#else
+                        ideal_nops = intel_nops;
+#endif
+                }
 
-static const unsigned char *const *__init_or_module find_nop_table(void)
-{
-        if (boot_cpu_has(X86_FEATURE_K8))
-                return k8_nops;
-        else if (boot_cpu_has(X86_FEATURE_K7))
-                return k7_nops;
-        else if (boot_cpu_has(X86_FEATURE_NOPL))
-                return p6_nops;
-        else
-                return intel_nops;
+        default:
+#ifdef CONFIG_X86_64
+                ideal_nops = k8_nops;
+#else
+                if (boot_cpu_has(X86_FEATURE_K8))
+                        ideal_nops = k8_nops;
+                else if (boot_cpu_has(X86_FEATURE_K7))
+                        ideal_nops = k7_nops;
+                else
+                        ideal_nops = intel_nops;
+#endif
+        }
 }
 
-#endif /* CONFIG_X86_64 */
-
 /* Use this to add nops to a buffer, then text_poke the whole buffer. */
 static void __init_or_module add_nops(void *insns, unsigned int len)
 {
-        const unsigned char *const *noptable = find_nop_table();
-
         while (len > 0) {
                 unsigned int noplen = len;
                 if (noplen > ASM_NOP_MAX)
                         noplen = ASM_NOP_MAX;
-                memcpy(insns, noptable[noplen], noplen);
+                memcpy(insns, ideal_nops[noplen], noplen);
                 insns += noplen;
                 len -= noplen;
         }
@@ -195,6 +250,7 @@ static void __init_or_module add_nops(void *insns, unsigned int len)
 
 extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
 extern s32 __smp_locks[], __smp_locks_end[];
+extern char __vsyscall_0;
 void *text_poke_early(void *addr, const void *opcode, size_t len);
 
 /* Replace instructions with better alternatives for this CPU type.
@@ -210,6 +266,15 @@ void __init_or_module apply_alternatives(struct alt_instr *start,
         u8 insnbuf[MAX_PATCH_LEN];
 
         DPRINTK("%s: alt table %p -> %p\n", __func__, start, end);
+        /*
+         * The scan order should be from start to end. A later scanned
+         * alternative code can overwrite a previous scanned alternative code.
+         * Some kernel functions (e.g. memcpy, memset, etc) use this order to
+         * patch code.
+         *
+         * So be careful if you want to change the scan order to any other
+         * order.
+         */
         for (a = start; a < end; a++) {
                 u8 *instr = a->instr;
                 BUG_ON(a->replacementlen > a->instrlen);
@@ -678,29 +743,3 @@ void __kprobes text_poke_smp_batch(struct text_poke_param *params, int n)
         wrote_text = 0;
         __stop_machine(stop_machine_text_poke, (void *)&tpp, NULL);
 }
-
-#if defined(CONFIG_DYNAMIC_FTRACE) || defined(HAVE_JUMP_LABEL)
-
-#ifdef CONFIG_X86_64
-unsigned char ideal_nop5[5] = { 0x66, 0x66, 0x66, 0x66, 0x90 };
-#else
-unsigned char ideal_nop5[5] = { 0x3e, 0x8d, 0x74, 0x26, 0x00 };
-#endif
-
-void __init arch_init_ideal_nop5(void)
-{
-        /*
-         * There is no good nop for all x86 archs.  This selection
-         * algorithm should be unified with the one in find_nop_table(),
-         * but this should be good enough for now.
-         *
-         * For cases other than the ones below, use the safe (as in
-         * always functional) defaults above.
-         */
-#ifdef CONFIG_X86_64
-        /* Don't use these on 32 bits due to broken virtualizers */
-        if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL)
-                memcpy(ideal_nop5, p6_nops[5], 5);
-#endif
-}
-#endif
diff --git a/arch/x86/kernel/pci-gart_64.c b/arch/x86/kernel/amd_gart_64.c
index b117efd24f71..b117efd24f71 100644
--- a/arch/x86/kernel/pci-gart_64.c
+++ b/arch/x86/kernel/amd_gart_64.c
diff --git a/arch/x86/kernel/amd_iommu.c b/arch/x86/kernel/amd_iommu.c
index 57ca77787220..873e7e1ead7b 100644
--- a/arch/x86/kernel/amd_iommu.c
+++ b/arch/x86/kernel/amd_iommu.c
@@ -18,6 +18,7 @@
  */
 
 #include <linux/pci.h>
+#include <linux/pci-ats.h>
 #include <linux/bitmap.h>
 #include <linux/slab.h>
 #include <linux/debugfs.h>
@@ -25,6 +26,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/iommu-helper.h>
 #include <linux/iommu.h>
+#include <linux/delay.h>
 #include <asm/proto.h>
 #include <asm/iommu.h>
 #include <asm/gart.h>
@@ -34,7 +36,7 @@
 
 #define CMD_SET_TYPE(cmd, t) ((cmd)->data[1] |= ((t) << 28))
 
-#define EXIT_LOOP_COUNT 10000000
+#define LOOP_TIMEOUT    100000
 
 static DEFINE_RWLOCK(amd_iommu_devtable_lock);
 
@@ -57,7 +59,6 @@ struct iommu_cmd {
         u32 data[4];
 };
 
-static void reset_iommu_command_buffer(struct amd_iommu *iommu);
 static void update_domain(struct protection_domain *domain);
 
 /****************************************************************************
@@ -322,8 +323,6 @@ static void iommu_print_event(struct amd_iommu *iommu, void *__evt)
                 break;
         case EVENT_TYPE_ILL_CMD:
                 printk("ILLEGAL_COMMAND_ERROR address=0x%016llx]\n", address);
-                iommu->reset_in_progress = true;
-                reset_iommu_command_buffer(iommu);
                 dump_command(address);
                 break;
         case EVENT_TYPE_CMD_HARD_ERR:
@@ -367,7 +366,7 @@ static void iommu_poll_events(struct amd_iommu *iommu)
         spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
-irqreturn_t amd_iommu_int_handler(int irq, void *data)
+irqreturn_t amd_iommu_int_thread(int irq, void *data)
 {
         struct amd_iommu *iommu;
 
@@ -377,192 +376,300 @@ irqreturn_t amd_iommu_int_handler(int irq, void *data)
         return IRQ_HANDLED;
 }
 
+irqreturn_t amd_iommu_int_handler(int irq, void *data)
+{
+        return IRQ_WAKE_THREAD;
+}
+
 /****************************************************************************
  *
  * IOMMU command queuing functions
  *
  ****************************************************************************/
 
-/*
- * Writes the command to the IOMMUs command buffer and informs the
- * hardware about the new command. Must be called with iommu->lock held.
- */
-static int __iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
+static int wait_on_sem(volatile u64 *sem)
+{
+        int i = 0;
+
+        while (*sem == 0 && i < LOOP_TIMEOUT) {
+                udelay(1);
+                i += 1;
+        }
+
+        if (i == LOOP_TIMEOUT) {
+                pr_alert("AMD-Vi: Completion-Wait loop timed out\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static void copy_cmd_to_buffer(struct amd_iommu *iommu,
+                               struct iommu_cmd *cmd,
+                               u32 tail)
 {
-        u32 tail, head;
         u8 *target;
 
-        WARN_ON(iommu->cmd_buf_size & CMD_BUFFER_UNINITIALIZED);
-        tail = readl(iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
         target = iommu->cmd_buf + tail;
-        memcpy_toio(target, cmd, sizeof(*cmd));
-        tail = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
-        head = readl(iommu->mmio_base + MMIO_CMD_HEAD_OFFSET);
-        if (tail == head)
-                return -ENOMEM;
+        tail   = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
+
+        /* Copy command to buffer */
+        memcpy(target, cmd, sizeof(*cmd));
+
+        /* Tell the IOMMU about it */
         writel(tail, iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
+}
 
-        return 0;
+static void build_completion_wait(struct iommu_cmd *cmd, u64 address)
+{
+        WARN_ON(address & 0x7ULL);
+
+        memset(cmd, 0, sizeof(*cmd));
+        cmd->data[0] = lower_32_bits(__pa(address)) | CMD_COMPL_WAIT_STORE_MASK;
+        cmd->data[1] = upper_32_bits(__pa(address));
+        cmd->data[2] = 1;
+        CMD_SET_TYPE(cmd, CMD_COMPL_WAIT);
+}
+
+static void build_inv_dte(struct iommu_cmd *cmd, u16 devid)
+{
+        memset(cmd, 0, sizeof(*cmd));
+        cmd->data[0] = devid;
+        CMD_SET_TYPE(cmd, CMD_INV_DEV_ENTRY);
+}
+
+static void build_inv_iommu_pages(struct iommu_cmd *cmd, u64 address,
+                                  size_t size, u16 domid, int pde)
+{
+        u64 pages;
+        int s;
+
+        pages = iommu_num_pages(address, size, PAGE_SIZE);
+        s     = 0;
+
+        if (pages > 1) {
+                /*
+                 * If we have to flush more than one page, flush all
+                 * TLB entries for this domain
+                 */
+                address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
+                s = 1;
+        }
+
+        address &= PAGE_MASK;
+
+        memset(cmd, 0, sizeof(*cmd));
+        cmd->data[1] |= domid;
+        cmd->data[2]  = lower_32_bits(address);
+        cmd->data[3]  = upper_32_bits(address);
+        CMD_SET_TYPE(cmd, CMD_INV_IOMMU_PAGES);
+        if (s) /* size bit - we flush more than one 4kb page */
+                cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
+        if (pde) /* PDE bit - we wan't flush everything not only the PTEs */
+                cmd->data[2] |= CMD_INV_IOMMU_PAGES_PDE_MASK;
+}
+
+static void build_inv_iotlb_pages(struct iommu_cmd *cmd, u16 devid, int qdep,
+                                  u64 address, size_t size)
+{
+        u64 pages;
+        int s;
+
+        pages = iommu_num_pages(address, size, PAGE_SIZE);
+        s     = 0;
+
+        if (pages > 1) {
+                /*
+                 * If we have to flush more than one page, flush all
+                 * TLB entries for this domain
+                 */
+                address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
+                s = 1;
+        }
+
+        address &= PAGE_MASK;
+
+        memset(cmd, 0, sizeof(*cmd));
+        cmd->data[0]  = devid;
+        cmd->data[0] |= (qdep & 0xff) << 24;
+        cmd->data[1]  = devid;
+        cmd->data[2]  = lower_32_bits(address);
+        cmd->data[3]  = upper_32_bits(address);
+        CMD_SET_TYPE(cmd, CMD_INV_IOTLB_PAGES);
+        if (s)
+                cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
+}
+
+static void build_inv_all(struct iommu_cmd *cmd)
+{
+        memset(cmd, 0, sizeof(*cmd));
+        CMD_SET_TYPE(cmd, CMD_INV_ALL);
 }
 
 /*
- * General queuing function for commands. Takes iommu->lock and calls
- * __iommu_queue_command().
+ * Writes the command to the IOMMUs command buffer and informs the
+ * hardware about the new command.
  */
 static int iommu_queue_command(struct amd_iommu *iommu, struct iommu_cmd *cmd)
 {
+        u32 left, tail, head, next_tail;
         unsigned long flags;
-        int ret;
 
+        WARN_ON(iommu->cmd_buf_size & CMD_BUFFER_UNINITIALIZED);
+
+again:
         spin_lock_irqsave(&iommu->lock, flags);
-        ret = __iommu_queue_command(iommu, cmd);
-        if (!ret)
-                iommu->need_sync = true;
-        spin_unlock_irqrestore(&iommu->lock, flags);
 
-        return ret;
-}
+        head      = readl(iommu->mmio_base + MMIO_CMD_HEAD_OFFSET);
+        tail      = readl(iommu->mmio_base + MMIO_CMD_TAIL_OFFSET);
+        next_tail = (tail + sizeof(*cmd)) % iommu->cmd_buf_size;
+        left      = (head - next_tail) % iommu->cmd_buf_size;
 
-/*
- * This function waits until an IOMMU has completed a completion
- * wait command
- */
-static void __iommu_wait_for_completion(struct amd_iommu *iommu)
-{
-        int ready = 0;
-        unsigned status = 0;
-        unsigned long i = 0;
+        if (left <= 2) {
+                struct iommu_cmd sync_cmd;
+                volatile u64 sem = 0;
+                int ret;
 
-        INC_STATS_COUNTER(compl_wait);
+                build_completion_wait(&sync_cmd, (u64)&sem);
+                copy_cmd_to_buffer(iommu, &sync_cmd, tail);
 
-        while (!ready && (i < EXIT_LOOP_COUNT)) {
-                ++i;
-                /* wait for the bit to become one */
-                status = readl(iommu->mmio_base + MMIO_STATUS_OFFSET);
-                ready = status & MMIO_STATUS_COM_WAIT_INT_MASK;
+                spin_unlock_irqrestore(&iommu->lock, flags);
+
+                if ((ret = wait_on_sem(&sem)) != 0)
+                        return ret;
+
+                goto again;
         }
 
-        /* set bit back to zero */
-        status &= ~MMIO_STATUS_COM_WAIT_INT_MASK;
-        writel(status, iommu->mmio_base + MMIO_STATUS_OFFSET);
+        copy_cmd_to_buffer(iommu, cmd, tail);
+
+        /* We need to sync now to make sure all commands are processed */
+        iommu->need_sync = true;
+
+        spin_unlock_irqrestore(&iommu->lock, flags);
 
-        if (unlikely(i == EXIT_LOOP_COUNT))
-                iommu->reset_in_progress = true;
+        return 0;
 }
 
 /*
  * This function queues a completion wait command into the command
  * buffer of an IOMMU
  */
-static int __iommu_completion_wait(struct amd_iommu *iommu)
+static int iommu_completion_wait(struct amd_iommu *iommu)
 {
         struct iommu_cmd cmd;
+        volatile u64 sem = 0;
+        int ret;
 
-         memset(&cmd, 0, sizeof(cmd));
-         cmd.data[0] = CMD_COMPL_WAIT_INT_MASK;
-         CMD_SET_TYPE(&cmd, CMD_COMPL_WAIT);
+        if (!iommu->need_sync)
+                return 0;
 
-         return __iommu_queue_command(iommu, &cmd);
+        build_completion_wait(&cmd, (u64)&sem);
+
+        ret = iommu_queue_command(iommu, &cmd);
+        if (ret)
+                return ret;
+
+        return wait_on_sem(&sem);
 }
 
-/*
- * This function is called whenever we need to ensure that the IOMMU has
- * completed execution of all commands we sent. It sends a
- * COMPLETION_WAIT command and waits for it to finish. The IOMMU informs
- * us about that by writing a value to a physical address we pass with
- * the command.
- */
-static int iommu_completion_wait(struct amd_iommu *iommu)
+static int iommu_flush_dte(struct amd_iommu *iommu, u16 devid)
 {
-        int ret = 0;
-        unsigned long flags;
+        struct iommu_cmd cmd;
 
-        spin_lock_irqsave(&iommu->lock, flags);
+        build_inv_dte(&cmd, devid);
 
-        if (!iommu->need_sync)
-                goto out;
+        return iommu_queue_command(iommu, &cmd);
+}
 
-        ret = __iommu_completion_wait(iommu);
+static void iommu_flush_dte_all(struct amd_iommu *iommu)
+{
+        u32 devid;
 
-        iommu->need_sync = false;
+        for (devid = 0; devid <= 0xffff; ++devid)
+                iommu_flush_dte(iommu, devid);
 
-        if (ret)
-                goto out;
-
-        __iommu_wait_for_completion(iommu);
+        iommu_completion_wait(iommu);
+}
 
-out:
-        spin_unlock_irqrestore(&iommu->lock, flags);
+/*
+ * This function uses heavy locking and may disable irqs for some time. But
+ * this is no issue because it is only called during resume.
+ */
+static void iommu_flush_tlb_all(struct amd_iommu *iommu)
+{
+        u32 dom_id;
 
-        if (iommu->reset_in_progress)
-                reset_iommu_command_buffer(iommu);
+        for (dom_id = 0; dom_id <= 0xffff; ++dom_id) {
+                struct iommu_cmd cmd;
+                build_inv_iommu_pages(&cmd, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS,
+                                      dom_id, 1);
+                iommu_queue_command(iommu, &cmd);
+        }
 
-        return 0;
+        iommu_completion_wait(iommu);
 }
 
-static void iommu_flush_complete(struct protection_domain *domain)
+static void iommu_flush_all(struct amd_iommu *iommu)
 {
-        int i;
+        struct iommu_cmd cmd;
 
-        for (i = 0; i < amd_iommus_present; ++i) {
-                if (!domain->dev_iommu[i])
-                        continue;
+        build_inv_all(&cmd);
 
-                /*
-                 * Devices of this domain are behind this IOMMU
-                 * We need to wait for completion of all commands.
-                 */
-                iommu_completion_wait(amd_iommus[i]);
+        iommu_queue_command(iommu, &cmd);
+        iommu_completion_wait(iommu);
+}
+
+void iommu_flush_all_caches(struct amd_iommu *iommu)
+{
+        if (iommu_feature(iommu, FEATURE_IA)) {
+                iommu_flush_all(iommu);
+        } else {
+                iommu_flush_dte_all(iommu);
+                iommu_flush_tlb_all(iommu);
         }
 }
 
 /*
- * Command send function for invalidating a device table entry
+ * Command send function for flushing on-device TLB
  */
-static int iommu_flush_device(struct device *dev)
+static int device_flush_iotlb(struct device *dev, u64 address, size_t size)
 {
+        struct pci_dev *pdev = to_pci_dev(dev);
         struct amd_iommu *iommu;
         struct iommu_cmd cmd;
         u16 devid;
+        int qdep;
 
+        qdep  = pci_ats_queue_depth(pdev);
         devid = get_device_id(dev);
         iommu = amd_iommu_rlookup_table[devid];
 
-        /* Build command */
-        memset(&cmd, 0, sizeof(cmd));
-        CMD_SET_TYPE(&cmd, CMD_INV_DEV_ENTRY);
-        cmd.data[0] = devid;
+        build_inv_iotlb_pages(&cmd, devid, qdep, address, size);
 
         return iommu_queue_command(iommu, &cmd);
 }
 
-static void __iommu_build_inv_iommu_pages(struct iommu_cmd *cmd, u64 address,
-                                          u16 domid, int pde, int s)
-{
-        memset(cmd, 0, sizeof(*cmd));
-        address &= PAGE_MASK;
-        CMD_SET_TYPE(cmd, CMD_INV_IOMMU_PAGES);
-        cmd->data[1] |= domid;
-        cmd->data[2] = lower_32_bits(address);
-        cmd->data[3] = upper_32_bits(address);
-        if (s) /* size bit - we flush more than one 4kb page */
-                cmd->data[2] |= CMD_INV_IOMMU_PAGES_SIZE_MASK;
-        if (pde) /* PDE bit - we wan't flush everything not only the PTEs */
-                cmd->data[2] |= CMD_INV_IOMMU_PAGES_PDE_MASK;
-}
-
 /*
- * Generic command send function for invalidaing TLB entries
+ * Command send function for invalidating a device table entry
  */
-static int iommu_queue_inv_iommu_pages(struct amd_iommu *iommu,
-                u64 address, u16 domid, int pde, int s)
+static int device_flush_dte(struct device *dev)
 {
-        struct iommu_cmd cmd;
+        struct amd_iommu *iommu;
+        struct pci_dev *pdev;
+        u16 devid;
         int ret;
 
-        __iommu_build_inv_iommu_pages(&cmd, address, domid, pde, s);
+        pdev  = to_pci_dev(dev);
+        devid = get_device_id(dev);
+        iommu = amd_iommu_rlookup_table[devid];
 
-        ret = iommu_queue_command(iommu, &cmd);
+        ret = iommu_flush_dte(iommu, devid);
+        if (ret)
+                return ret;
+
+        if (pci_ats_enabled(pdev))
+                ret = device_flush_iotlb(dev, 0, ~0UL);
 
         return ret;
 }
@@ -572,23 +679,14 @@ static int iommu_queue_inv_iommu_pages(struct amd_iommu *iommu,
  * It invalidates a single PTE if the range to flush is within a single
  * page. Otherwise it flushes the whole TLB of the IOMMU.
  */
-static void __iommu_flush_pages(struct protection_domain *domain,
-                                u64 address, size_t size, int pde)
+static void __domain_flush_pages(struct protection_domain *domain,
+                                 u64 address, size_t size, int pde)
 {
-        int s = 0, i;
-        unsigned long pages = iommu_num_pages(address, size, PAGE_SIZE);
-
-        address &= PAGE_MASK;
-
-        if (pages > 1) {
-                /*
-                 * If we have to flush more than one page, flush all
-                 * TLB entries for this domain
-                 */
-                address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
-                s = 1;
-        }
+        struct iommu_dev_data *dev_data;
+        struct iommu_cmd cmd;
+        int ret = 0, i;
 
+        build_inv_iommu_pages(&cmd, address, size, domain->id, pde);
 
         for (i = 0; i < amd_iommus_present; ++i) {
                 if (!domain->dev_iommu[i])
@@ -598,101 +696,70 @@ static void __iommu_flush_pages(struct protection_domain *domain,
                  * Devices of this domain are behind this IOMMU
                  * We need a TLB flush
                  */
-                iommu_queue_inv_iommu_pages(amd_iommus[i], address,
-                                            domain->id, pde, s);
+                ret |= iommu_queue_command(amd_iommus[i], &cmd);
+        }
+
+        list_for_each_entry(dev_data, &domain->dev_list, list) {
+                struct pci_dev *pdev = to_pci_dev(dev_data->dev);
+
+                if (!pci_ats_enabled(pdev))
+                        continue;
+
+                ret |= device_flush_iotlb(dev_data->dev, address, size);
         }
 
-        return;
+        WARN_ON(ret);
 }
 
-static void iommu_flush_pages(struct protection_domain *domain,
-                             u64 address, size_t size)
+static void domain_flush_pages(struct protection_domain *domain,
+                               u64 address, size_t size)
 {
-        __iommu_flush_pages(domain, address, size, 0);
+        __domain_flush_pages(domain, address, size, 0);
 }
 
 /* Flush the whole IO/TLB for a given protection domain */
-static void iommu_flush_tlb(struct protection_domain *domain)
+static void domain_flush_tlb(struct protection_domain *domain)
 {
-        __iommu_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 0);
+        __domain_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 0);
 }
 
 /* Flush the whole IO/TLB for a given protection domain - including PDE */
-static void iommu_flush_tlb_pde(struct protection_domain *domain)
+static void domain_flush_tlb_pde(struct protection_domain *domain)
 {
-        __iommu_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 1);
-}
-
-
-/*
- * This function flushes the DTEs for all devices in domain
- */
-static void iommu_flush_domain_devices(struct protection_domain *domain)
-{
-        struct iommu_dev_data *dev_data;
-        unsigned long flags;
-
-        spin_lock_irqsave(&domain->lock, flags);
-
-        list_for_each_entry(dev_data, &domain->dev_list, list)
-                iommu_flush_device(dev_data->dev);
-
-        spin_unlock_irqrestore(&domain->lock, flags);
+        __domain_flush_pages(domain, 0, CMD_INV_IOMMU_ALL_PAGES_ADDRESS, 1);
 }
 
-static void iommu_flush_all_domain_devices(void)
+static void domain_flush_complete(struct protection_domain *domain)
 {
-        struct protection_domain *domain;
-        unsigned long flags;
+        int i;
 
-        spin_lock_irqsave(&amd_iommu_pd_lock, flags);
+        for (i = 0; i < amd_iommus_present; ++i) {
+                if (!domain->dev_iommu[i])
+                        continue;
 
-        list_for_each_entry(domain, &amd_iommu_pd_list, list) {
-                iommu_flush_domain_devices(domain);
-                iommu_flush_complete(domain);
+                /*
+                 * Devices of this domain are behind this IOMMU
+                 * We need to wait for completion of all commands.
+                 */
+                iommu_completion_wait(amd_iommus[i]);
         }
-
-        spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
 }
 
-void amd_iommu_flush_all_devices(void)
-{
-        iommu_flush_all_domain_devices();
-}
 
 /*
- * This function uses heavy locking and may disable irqs for some time. But
- * this is no issue because it is only called during resume.
+ * This function flushes the DTEs for all devices in domain
  */
-void amd_iommu_flush_all_domains(void)
+static void domain_flush_devices(struct protection_domain *domain)
 {
-        struct protection_domain *domain;
+        struct iommu_dev_data *dev_data;
         unsigned long flags;
 
-        spin_lock_irqsave(&amd_iommu_pd_lock, flags);
-
-        list_for_each_entry(domain, &amd_iommu_pd_list, list) {
-                spin_lock(&domain->lock);
-                iommu_flush_tlb_pde(domain);
-                iommu_flush_complete(domain);
-                spin_unlock(&domain->lock);
-        }
-
-        spin_unlock_irqrestore(&amd_iommu_pd_lock, flags);
-}
-
-static void reset_iommu_command_buffer(struct amd_iommu *iommu)
-{
-        pr_err("AMD-Vi: Resetting IOMMU command buffer\n");
-
-        if (iommu->reset_in_progress)
-                panic("AMD-Vi: ILLEGAL_COMMAND_ERROR while resetting command buffer\n");
+        spin_lock_irqsave(&domain->lock, flags);
 
-        amd_iommu_reset_cmd_buffer(iommu);
-        amd_iommu_flush_all_devices();
-        amd_iommu_flush_all_domains();
+        list_for_each_entry(dev_data, &domain->dev_list, list)
+                device_flush_dte(dev_data->dev);
 
-        iommu->reset_in_progress = false;
+        spin_unlock_irqrestore(&domain->lock, flags);
 }
 
 /****************************************************************************
@@ -1410,17 +1477,22 @@ static bool dma_ops_domain(struct protection_domain *domain)
         return domain->flags & PD_DMA_OPS_MASK;
 }
 
-static void set_dte_entry(u16 devid, struct protection_domain *domain)
+static void set_dte_entry(u16 devid, struct protection_domain *domain, bool ats)
 {
         u64 pte_root = virt_to_phys(domain->pt_root);
+        u32 flags = 0;
 
         pte_root |= (domain->mode & DEV_ENTRY_MODE_MASK)
                     << DEV_ENTRY_MODE_SHIFT;
         pte_root |= IOMMU_PTE_IR | IOMMU_PTE_IW | IOMMU_PTE_P | IOMMU_PTE_TV;
 
-        amd_iommu_dev_table[devid].data[2] = domain->id;
-        amd_iommu_dev_table[devid].data[1] = upper_32_bits(pte_root);
-        amd_iommu_dev_table[devid].data[0] = lower_32_bits(pte_root);
+        if (ats)
+                flags |= DTE_FLAG_IOTLB;
+
+        amd_iommu_dev_table[devid].data[3] |= flags;
+        amd_iommu_dev_table[devid].data[2]  = domain->id;
+        amd_iommu_dev_table[devid].data[1]  = upper_32_bits(pte_root);
+        amd_iommu_dev_table[devid].data[0]  = lower_32_bits(pte_root);
 }
 
 static void clear_dte_entry(u16 devid)
@@ -1437,34 +1509,42 @@ static void do_attach(struct device *dev, struct protection_domain *domain)
 {
         struct iommu_dev_data *dev_data;
         struct amd_iommu *iommu;
+        struct pci_dev *pdev;
+        bool ats = false;
         u16 devid;
 
         devid    = get_device_id(dev);
         iommu    = amd_iommu_rlookup_table[devid];
         dev_data = get_dev_data(dev);
+        pdev     = to_pci_dev(dev);
+
+        if (amd_iommu_iotlb_sup)
+                ats = pci_ats_enabled(pdev);
 
         /* Update data structures */
         dev_data->domain = domain;
         list_add(&dev_data->list, &domain->dev_list);
-        set_dte_entry(devid, domain);
+        set_dte_entry(devid, domain, ats);
 
         /* Do reference counting */
         domain->dev_iommu[iommu->index] += 1;
         domain->dev_cnt                 += 1;
 
         /* Flush the DTE entry */
-        iommu_flush_device(dev);
+        device_flush_dte(dev);
 }
 
 static void do_detach(struct device *dev)
 {
         struct iommu_dev_data *dev_data;
         struct amd_iommu *iommu;
+        struct pci_dev *pdev;
         u16 devid;
 
         devid    = get_device_id(dev);
         iommu    = amd_iommu_rlookup_table[devid];
         dev_data = get_dev_data(dev);
+        pdev     = to_pci_dev(dev);
 
         /* decrease reference counters */
         dev_data->domain->dev_iommu[iommu->index] -= 1;
@@ -1476,7 +1556,7 @@ static void do_detach(struct device *dev)
         clear_dte_entry(devid);
 
         /* Flush the DTE entry */
-        iommu_flush_device(dev);
+        device_flush_dte(dev);
 }
 
 /*
@@ -1539,9 +1619,13 @@ out_unlock:
 static int attach_device(struct device *dev,
                          struct protection_domain *domain)
 {
+        struct pci_dev *pdev = to_pci_dev(dev);
         unsigned long flags;
         int ret;
 
+        if (amd_iommu_iotlb_sup)
+                pci_enable_ats(pdev, PAGE_SHIFT);
+
         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
         ret = __attach_device(dev, domain);
         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
@@ -1551,7 +1635,7 @@ static int attach_device(struct device *dev,
          * left the caches in the IOMMU dirty. So we have to flush
          * here to evict all dirty stuff.
          */
-        iommu_flush_tlb_pde(domain);
+        domain_flush_tlb_pde(domain);
 
         return ret;
 }
@@ -1598,12 +1682,16 @@ static void __detach_device(struct device *dev)
  */
 static void detach_device(struct device *dev)
 {
+        struct pci_dev *pdev = to_pci_dev(dev);
         unsigned long flags;
 
         /* lock device table */
         write_lock_irqsave(&amd_iommu_devtable_lock, flags);
         __detach_device(dev);
         write_unlock_irqrestore(&amd_iommu_devtable_lock, flags);
+
+        if (amd_iommu_iotlb_sup && pci_ats_enabled(pdev))
+                pci_disable_ats(pdev);
 }
 
 /*
@@ -1692,7 +1780,7 @@ static int device_change_notifier(struct notifier_block *nb,
                 goto out;
         }
 
-        iommu_flush_device(dev);
+        device_flush_dte(dev);
         iommu_completion_wait(iommu);
 
 out:
@@ -1753,8 +1841,9 @@ static void update_device_table(struct protection_domain *domain)
         struct iommu_dev_data *dev_data;
 
         list_for_each_entry(dev_data, &domain->dev_list, list) {
+                struct pci_dev *pdev = to_pci_dev(dev_data->dev);
                 u16 devid = get_device_id(dev_data->dev);
-                set_dte_entry(devid, domain);
+                set_dte_entry(devid, domain, pci_ats_enabled(pdev));
         }
 }
 
@@ -1764,8 +1853,9 @@ static void update_domain(struct protection_domain *domain)
                 return;
 
         update_device_table(domain);
-        iommu_flush_domain_devices(domain);
-        iommu_flush_tlb_pde(domain);
+
+        domain_flush_devices(domain);
+        domain_flush_tlb_pde(domain);
 
         domain->updated = false;
 }
@@ -1924,10 +2014,10 @@ retry:
         ADD_STATS_COUNTER(alloced_io_mem, size);
 
         if (unlikely(dma_dom->need_flush && !amd_iommu_unmap_flush)) {
-                iommu_flush_tlb(&dma_dom->domain);
+                domain_flush_tlb(&dma_dom->domain);
                 dma_dom->need_flush = false;
         } else if (unlikely(amd_iommu_np_cache))
-                iommu_flush_pages(&dma_dom->domain, address, size);
+                domain_flush_pages(&dma_dom->domain, address, size);
 
 out:
         return address;
@@ -1976,7 +2066,7 @@ static void __unmap_single(struct dma_ops_domain *dma_dom,
         dma_ops_free_addresses(dma_dom, dma_addr, pages);
 
         if (amd_iommu_unmap_flush || dma_dom->need_flush) {
-                iommu_flush_pages(&dma_dom->domain, flush_addr, size);
+                domain_flush_pages(&dma_dom->domain, flush_addr, size);
                 dma_dom->need_flush = false;
         }
 }
@@ -2012,7 +2102,7 @@ static dma_addr_t map_page(struct device *dev, struct page *page,
         if (addr == DMA_ERROR_CODE)
                 goto out;
 
-        iommu_flush_complete(domain);
+        domain_flush_complete(domain);
 
 out:
         spin_unlock_irqrestore(&domain->lock, flags);
@@ -2039,7 +2129,7 @@ static void unmap_page(struct device *dev, dma_addr_t dma_addr, size_t size,
 
         __unmap_single(domain->priv, dma_addr, size, dir);
 
-        iommu_flush_complete(domain);
+        domain_flush_complete(domain);
 
         spin_unlock_irqrestore(&domain->lock, flags);
 }
@@ -2104,7 +2194,7 @@ static int map_sg(struct device *dev, struct scatterlist *sglist,
                         goto unmap;
         }
 
-        iommu_flush_complete(domain);
+        domain_flush_complete(domain);
 
 out:
         spin_unlock_irqrestore(&domain->lock, flags);
@@ -2150,7 +2240,7 @@ static void unmap_sg(struct device *dev, struct scatterlist *sglist,
                 s->dma_address = s->dma_length = 0;
         }
 
-        iommu_flush_complete(domain);
+        domain_flush_complete(domain);
 
         spin_unlock_irqrestore(&domain->lock, flags);
 }
@@ -2200,7 +2290,7 @@ static void *alloc_coherent(struct device *dev, size_t size,
                 goto out_free;
         }
 
-        iommu_flush_complete(domain);
+        domain_flush_complete(domain);
 
         spin_unlock_irqrestore(&domain->lock, flags);
 
@@ -2232,7 +2322,7 @@ static void free_coherent(struct device *dev, size_t size,
 
         __unmap_single(domain->priv, dma_addr, size, DMA_BIDIRECTIONAL);
 
-        iommu_flush_complete(domain);
+        domain_flush_complete(domain);
 
         spin_unlock_irqrestore(&domain->lock, flags);
 
@@ -2476,7 +2566,7 @@ static void amd_iommu_detach_device(struct iommu_domain *dom,
         if (!iommu)
                 return;
 
-        iommu_flush_device(dev);
+        device_flush_dte(dev);
         iommu_completion_wait(iommu);
 }
 
@@ -2542,7 +2632,7 @@ static int amd_iommu_unmap(struct iommu_domain *dom, unsigned long iova,
         unmap_size = iommu_unmap_page(domain, iova, page_size);
         mutex_unlock(&domain->api_lock);
 
-        iommu_flush_tlb_pde(domain);
+        domain_flush_tlb_pde(domain);
 
         return get_order(unmap_size);
 }
diff --git a/arch/x86/kernel/amd_iommu_init.c b/arch/x86/kernel/amd_iommu_init.c
index 246d727b65b7..9179c21120a8 100644
--- a/arch/x86/kernel/amd_iommu_init.c
+++ b/arch/x86/kernel/amd_iommu_init.c
@@ -137,6 +137,7 @@ int amd_iommus_present;
 
 /* IOMMUs have a non-present cache? */
 bool amd_iommu_np_cache __read_mostly;
+bool amd_iommu_iotlb_sup __read_mostly = true;
 
 /*
  * The ACPI table parsing functions set this variable on an error
@@ -180,6 +181,12 @@ static u32 dev_table_size;	/* size of the device table */
 static u32 alias_table_size;    /* size of the alias table */
 static u32 rlookup_table_size;  /* size if the rlookup table */
 
+/*
+ * This function flushes all internal caches of
+ * the IOMMU used by this driver.
+ */
+extern void iommu_flush_all_caches(struct amd_iommu *iommu);
+
 static inline void update_last_devid(u16 devid)
 {
         if (devid > amd_iommu_last_bdf)
@@ -293,9 +300,23 @@ static void iommu_feature_disable(struct amd_iommu *iommu, u8 bit)
 /* Function to enable the hardware */
 static void iommu_enable(struct amd_iommu *iommu)
 {
-        printk(KERN_INFO "AMD-Vi: Enabling IOMMU at %s cap 0x%hx\n",
+        static const char * const feat_str[] = {
+                "PreF", "PPR", "X2APIC", "NX", "GT", "[5]",
+                "IA", "GA", "HE", "PC", NULL
+        };
+        int i;
+
+        printk(KERN_INFO "AMD-Vi: Enabling IOMMU at %s cap 0x%hx",
                dev_name(&iommu->dev->dev), iommu->cap_ptr);
 
+        if (iommu->cap & (1 << IOMMU_CAP_EFR)) {
+                printk(KERN_CONT " extended features: ");
+                for (i = 0; feat_str[i]; ++i)
+                        if (iommu_feature(iommu, (1ULL << i)))
+                                printk(KERN_CONT " %s", feat_str[i]);
+        }
+        printk(KERN_CONT "\n");
+
         iommu_feature_enable(iommu, CONTROL_IOMMU_EN);
 }
 
@@ -651,7 +672,7 @@ static void __init set_device_exclusion_range(u16 devid, struct ivmd_header *m)
 static void __init init_iommu_from_pci(struct amd_iommu *iommu)
 {
         int cap_ptr = iommu->cap_ptr;
-        u32 range, misc;
+        u32 range, misc, low, high;
         int i, j;
 
         pci_read_config_dword(iommu->dev, cap_ptr + MMIO_CAP_HDR_OFFSET,
@@ -667,6 +688,15 @@ static void __init init_iommu_from_pci(struct amd_iommu *iommu)
                                         MMIO_GET_LD(range));
         iommu->evt_msi_num = MMIO_MSI_NUM(misc);
 
+        if (!(iommu->cap & (1 << IOMMU_CAP_IOTLB)))
+                amd_iommu_iotlb_sup = false;
+
+        /* read extended feature bits */
+        low  = readl(iommu->mmio_base + MMIO_EXT_FEATURES);
+        high = readl(iommu->mmio_base + MMIO_EXT_FEATURES + 4);
+
+        iommu->features = ((u64)high << 32) | low;
+
         if (!is_rd890_iommu(iommu->dev))
                 return;
 
@@ -1004,10 +1034,11 @@ static int iommu_setup_msi(struct amd_iommu *iommu)
         if (pci_enable_msi(iommu->dev))
                 return 1;
 
-        r = request_irq(iommu->dev->irq, amd_iommu_int_handler,
-                        IRQF_SAMPLE_RANDOM,
-                        "AMD-Vi",
-                        NULL);
+        r = request_threaded_irq(iommu->dev->irq,
+                                 amd_iommu_int_handler,
+                                 amd_iommu_int_thread,
+                                 0, "AMD-Vi",
+                                 iommu->dev);
 
         if (r) {
                 pci_disable_msi(iommu->dev);
@@ -1244,6 +1275,7 @@ static void enable_iommus(void)
                 iommu_set_exclusion_range(iommu);
                 iommu_init_msi(iommu);
                 iommu_enable(iommu);
+                iommu_flush_all_caches(iommu);
         }
 }
 
@@ -1274,8 +1306,8 @@ static void amd_iommu_resume(void)
          * we have to flush after the IOMMUs are enabled because a
          * disabled IOMMU will never execute the commands we send
          */
-        amd_iommu_flush_all_devices();
-        amd_iommu_flush_all_domains();
+        for_each_iommu(iommu)
+                iommu_flush_all_caches(iommu);
 }
 
 static int amd_iommu_suspend(void)
diff --git a/arch/x86/kernel/apb_timer.c b/arch/x86/kernel/apb_timer.c
index cd1ffed4ee22..289e92862fd9 100644
--- a/arch/x86/kernel/apb_timer.c
+++ b/arch/x86/kernel/apb_timer.c
@@ -177,7 +177,6 @@ static struct clocksource clocksource_apbt = {
         .rating         = APBT_CLOCKSOURCE_RATING,
         .read           = apbt_read_clocksource,
         .mask           = APBT_MASK,
-        .shift          = APBT_SHIFT,
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
         .resume         = apbt_restart_clocksource,
 };
@@ -543,14 +542,7 @@ static int apbt_clocksource_register(void)
         if (t1 == apbt_read_clocksource(&clocksource_apbt))
                 panic("APBT counter not counting. APBT disabled\n");
 
-        /*
-         * initialize and register APBT clocksource
-         * convert that to ns/clock cycle
-         * mult = (ns/c) * 2^APBT_SHIFT
-         */
-        clocksource_apbt.mult = div_sc(MSEC_PER_SEC,
-                                       (unsigned long) apbt_freq, APBT_SHIFT);
-        clocksource_register(&clocksource_apbt);
+        clocksource_register_khz(&clocksource_apbt, (u32)apbt_freq*1000);
 
         return 0;
 }
diff --git a/arch/x86/kernel/aperture_64.c b/arch/x86/kernel/aperture_64.c
index 73fb469908c6..3d2661ca6542 100644
--- a/arch/x86/kernel/aperture_64.c
+++ b/arch/x86/kernel/aperture_64.c
@@ -30,6 +30,22 @@
 #include <asm/amd_nb.h>
 #include <asm/x86_init.h>
 
+/*
+ * Using 512M as goal, in case kexec will load kernel_big
+ * that will do the on-position decompress, and could overlap with
+ * with the gart aperture that is used.
+ * Sequence:
+ * kernel_small
+ * ==> kexec (with kdump trigger path or gart still enabled)
+ * ==> kernel_small (gart area become e820_reserved)
+ * ==> kexec (with kdump trigger path or gart still enabled)
+ * ==> kerne_big (uncompressed size will be big than 64M or 128M)
+ * So don't use 512M below as gart iommu, leave the space for kernel
+ * code for safe.
+ */
+#define GART_MIN_ADDR   (512ULL << 20)
+#define GART_MAX_ADDR   (1ULL   << 32)
+
 int gart_iommu_aperture;
 int gart_iommu_aperture_disabled __initdata;
 int gart_iommu_aperture_allowed __initdata;
@@ -70,21 +86,9 @@ static u32 __init allocate_aperture(void)
          * memory. Unfortunately we cannot move it up because that would
          * make the IOMMU useless.
          */
-        /*
-         * using 512M as goal, in case kexec will load kernel_big
-         * that will do the on position decompress, and  could overlap with
-         * that position with gart that is used.
-         * sequende:
-         * kernel_small
-         * ==> kexec (with kdump trigger path or previous doesn't shutdown gart)
-         * ==> kernel_small(gart area become e820_reserved)
-         * ==> kexec (with kdump trigger path or previous doesn't shutdown gart)
-         * ==> kerne_big (uncompressed size will be big than 64M or 128M)
-         * so don't use 512M below as gart iommu, leave the space for kernel
-         * code for safe
-         */
-        addr = memblock_find_in_range(0, 1ULL<<32, aper_size, 512ULL<<20);
-        if (addr == MEMBLOCK_ERROR || addr + aper_size > 0xffffffff) {
+        addr = memblock_find_in_range(GART_MIN_ADDR, GART_MAX_ADDR,
+                                      aper_size, aper_size);
+        if (addr == MEMBLOCK_ERROR || addr + aper_size > GART_MAX_ADDR) {
                 printk(KERN_ERR
                         "Cannot allocate aperture memory hole (%lx,%uK)\n",
                                 addr, aper_size>>10);
diff --git a/arch/x86/kernel/apic/apic.c b/arch/x86/kernel/apic/apic.c
index fabf01eff771..f92a8e5d1e21 100644
--- a/arch/x86/kernel/apic/apic.c
+++ b/arch/x86/kernel/apic/apic.c
@@ -505,7 +505,7 @@ static void __cpuinit setup_APIC_timer(void)
 {
         struct clock_event_device *levt = &__get_cpu_var(lapic_events);
 
-        if (cpu_has(__this_cpu_ptr(&cpu_info), X86_FEATURE_ARAT)) {
+        if (this_cpu_has(X86_FEATURE_ARAT)) {
                 lapic_clockevent.features &= ~CLOCK_EVT_FEAT_C3STOP;
                 /* Make LAPIC timer preferrable over percpu HPET */
                 lapic_clockevent.rating = 150;
@@ -1237,6 +1237,17 @@ void __cpuinit setup_local_APIC(void)
         /* always use the value from LDR */
         early_per_cpu(x86_cpu_to_logical_apicid, cpu) =
                 logical_smp_processor_id();
+
+        /*
+         * Some NUMA implementations (NUMAQ) don't initialize apicid to
+         * node mapping during NUMA init.  Now that logical apicid is
+         * guaranteed to be known, give it another chance.  This is already
+         * a bit too late - percpu allocation has already happened without
+         * proper NUMA affinity.
+         */
+        if (apic->x86_32_numa_cpu_node)
+                set_apicid_to_node(early_per_cpu(x86_cpu_to_apicid, cpu),
+                                   apic->x86_32_numa_cpu_node(cpu));
 #endif
 
         /*
@@ -1812,30 +1823,41 @@ void smp_spurious_interrupt(struct pt_regs *regs)
  */
 void smp_error_interrupt(struct pt_regs *regs)
 {
-        u32 v, v1;
+        u32 v0, v1;
+        u32 i = 0;
+        static const char * const error_interrupt_reason[] = {
+                "Send CS error",                /* APIC Error Bit 0 */
+                "Receive CS error",             /* APIC Error Bit 1 */
+                "Send accept error",            /* APIC Error Bit 2 */
+                "Receive accept error",         /* APIC Error Bit 3 */
+                "Redirectable IPI",             /* APIC Error Bit 4 */
+                "Send illegal vector",          /* APIC Error Bit 5 */
+                "Received illegal vector",      /* APIC Error Bit 6 */
+                "Illegal register address",     /* APIC Error Bit 7 */
+        };
 
         exit_idle();
         irq_enter();
         /* First tickle the hardware, only then report what went on. -- REW */
-        v = apic_read(APIC_ESR);
+        v0 = apic_read(APIC_ESR);
         apic_write(APIC_ESR, 0);
         v1 = apic_read(APIC_ESR);
         ack_APIC_irq();
         atomic_inc(&irq_err_count);
 
-        /*
-         * Here is what the APIC error bits mean:
-         * 0: Send CS error
-         * 1: Receive CS error
-         * 2: Send accept error
-         * 3: Receive accept error
-         * 4: Reserved
-         * 5: Send illegal vector
-         * 6: Received illegal vector
-         * 7: Illegal register address
-         */
-        pr_debug("APIC error on CPU%d: %02x(%02x)\n",
-                smp_processor_id(), v , v1);
+        apic_printk(APIC_DEBUG, KERN_DEBUG "APIC error on CPU%d: %02x(%02x)",
+                    smp_processor_id(), v0 , v1);
+
+        v1 = v1 & 0xff;
+        while (v1) {
+                if (v1 & 0x1)
+                        apic_printk(APIC_DEBUG, KERN_CONT " : %s", error_interrupt_reason[i]);
+                i++;
+                v1 >>= 1;
+        };
+
+        apic_printk(APIC_DEBUG, KERN_CONT "\n");
+
         irq_exit();
 }
 
@@ -2003,21 +2025,6 @@ void default_init_apic_ldr(void)
         apic_write(APIC_LDR, val);
 }
 
-#ifdef CONFIG_X86_32
-int default_x86_32_numa_cpu_node(int cpu)
-{
-#ifdef CONFIG_NUMA
-        int apicid = early_per_cpu(x86_cpu_to_apicid, cpu);
-
-        if (apicid != BAD_APICID)
-                return __apicid_to_node[apicid];
-        return NUMA_NO_NODE;
-#else
-        return 0;
-#endif
-}
-#endif
-
 /*
  * Power management
  */
diff --git a/arch/x86/kernel/apic/apic_noop.c b/arch/x86/kernel/apic/apic_noop.c
index f1baa2dc087a..775b82bc655c 100644
--- a/arch/x86/kernel/apic/apic_noop.c
+++ b/arch/x86/kernel/apic/apic_noop.c
@@ -119,14 +119,6 @@ static void noop_apic_write(u32 reg, u32 v)
         WARN_ON_ONCE(cpu_has_apic && !disable_apic);
 }
 
-#ifdef CONFIG_X86_32
-static int noop_x86_32_numa_cpu_node(int cpu)
-{
-        /* we're always on node 0 */
-        return 0;
-}
-#endif
-
 struct apic apic_noop = {
         .name                           = "noop",
         .probe                          = noop_probe,
@@ -195,6 +187,5 @@ struct apic apic_noop = {
 
 #ifdef CONFIG_X86_32
         .x86_32_early_logical_apicid    = noop_x86_32_early_logical_apicid,
-        .x86_32_numa_cpu_node           = noop_x86_32_numa_cpu_node,
 #endif
 };
diff --git a/arch/x86/kernel/apic/bigsmp_32.c b/arch/x86/kernel/apic/bigsmp_32.c
index 541a2e431659..d84ac5a584b5 100644
--- a/arch/x86/kernel/apic/bigsmp_32.c
+++ b/arch/x86/kernel/apic/bigsmp_32.c
@@ -253,5 +253,4 @@ struct apic apic_bigsmp = {
         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
 
         .x86_32_early_logical_apicid    = bigsmp_early_logical_apicid,
-        .x86_32_numa_cpu_node           = default_x86_32_numa_cpu_node,
 };
diff --git a/arch/x86/kernel/apic/es7000_32.c b/arch/x86/kernel/apic/es7000_32.c
index 3e9de4854c5b..70533de5bd29 100644
--- a/arch/x86/kernel/apic/es7000_32.c
+++ b/arch/x86/kernel/apic/es7000_32.c
@@ -510,11 +510,6 @@ static void es7000_setup_apic_routing(void)
                 nr_ioapics, cpumask_bits(es7000_target_cpus())[0]);
 }
 
-static int es7000_numa_cpu_node(int cpu)
-{
-        return 0;
-}
-
 static int es7000_cpu_present_to_apicid(int mps_cpu)
 {
         if (!mps_cpu)
@@ -688,7 +683,6 @@ struct apic __refdata apic_es7000_cluster = {
         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
 
         .x86_32_early_logical_apicid    = es7000_early_logical_apicid,
-        .x86_32_numa_cpu_node           = es7000_numa_cpu_node,
 };
 
 struct apic __refdata apic_es7000 = {
@@ -752,5 +746,4 @@ struct apic __refdata apic_es7000 = {
         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
 
         .x86_32_early_logical_apicid    = es7000_early_logical_apicid,
-        .x86_32_numa_cpu_node           = es7000_numa_cpu_node,
 };
diff --git a/arch/x86/kernel/apic/numaq_32.c b/arch/x86/kernel/apic/numaq_32.c
index 6273eee5134b..30f13319e24b 100644
--- a/arch/x86/kernel/apic/numaq_32.c
+++ b/arch/x86/kernel/apic/numaq_32.c
@@ -48,8 +48,6 @@
 #include <asm/e820.h>
 #include <asm/ipi.h>
 
-#define MB_TO_PAGES(addr)               ((addr) << (20 - PAGE_SHIFT))
-
 int found_numaq;
 
 /*
@@ -79,31 +77,20 @@ int					quad_local_to_mp_bus_id[NR_CPUS/4][4];
 static inline void numaq_register_node(int node, struct sys_cfg_data *scd)
 {
         struct eachquadmem *eq = scd->eq + node;
+        u64 start = (u64)(eq->hi_shrd_mem_start - eq->priv_mem_size) << 20;
+        u64 end = (u64)(eq->hi_shrd_mem_start + eq->hi_shrd_mem_size) << 20;
+        int ret;
 
-        node_set_online(node);
-
-        /* Convert to pages */
-        node_start_pfn[node] =
-                 MB_TO_PAGES(eq->hi_shrd_mem_start - eq->priv_mem_size);
-
-        node_end_pfn[node] =
-                 MB_TO_PAGES(eq->hi_shrd_mem_start + eq->hi_shrd_mem_size);
-
-        memblock_x86_register_active_regions(node, node_start_pfn[node],
-                                                node_end_pfn[node]);
-
-        memory_present(node, node_start_pfn[node], node_end_pfn[node]);
-
-        node_remap_size[node] = node_memmap_size_bytes(node,
-                                        node_start_pfn[node],
-                                        node_end_pfn[node]);
+        node_set(node, numa_nodes_parsed);
+        ret = numa_add_memblk(node, start, end);
+        BUG_ON(ret < 0);
 }
 
 /*
  * Function: smp_dump_qct()
  *
  * Description: gets memory layout from the quad config table.  This
- * function also updates node_online_map with the nodes (quads) present.
+ * function also updates numa_nodes_parsed with the nodes (quads) present.
  */
 static void __init smp_dump_qct(void)
 {
@@ -112,7 +99,6 @@ static void __init smp_dump_qct(void)
 
         scd = (void *)__va(SYS_CFG_DATA_PRIV_ADDR);
 
-        nodes_clear(node_online_map);
         for_each_node(node) {
                 if (scd->quads_present31_0 & (1 << node))
                         numaq_register_node(node, scd);
@@ -282,14 +268,14 @@ static __init void early_check_numaq(void)
         }
 }
 
-int __init get_memcfg_numaq(void)
+int __init numaq_numa_init(void)
 {
         early_check_numaq();
         if (!found_numaq)
-                return 0;
+                return -ENOENT;
         smp_dump_qct();
 
-        return 1;
+        return 0;
 }
 
 #define NUMAQ_APIC_DFR_VALUE    (APIC_DFR_CLUSTER)
diff --git a/arch/x86/kernel/apic/probe_32.c b/arch/x86/kernel/apic/probe_32.c
index fc84c7b61108..6541e471fd91 100644
--- a/arch/x86/kernel/apic/probe_32.c
+++ b/arch/x86/kernel/apic/probe_32.c
@@ -172,7 +172,6 @@ struct apic apic_default = {
         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
 
         .x86_32_early_logical_apicid    = default_x86_32_early_logical_apicid,
-        .x86_32_numa_cpu_node           = default_x86_32_numa_cpu_node,
 };
 
 extern struct apic apic_numaq;
diff --git a/arch/x86/kernel/apic/summit_32.c b/arch/x86/kernel/apic/summit_32.c
index e4b8059b414a..35bcd7d995a1 100644
--- a/arch/x86/kernel/apic/summit_32.c
+++ b/arch/x86/kernel/apic/summit_32.c
@@ -551,5 +551,4 @@ struct apic apic_summit = {
         .safe_wait_icr_idle             = native_safe_apic_wait_icr_idle,
 
         .x86_32_early_logical_apicid    = summit_early_logical_apicid,
-        .x86_32_numa_cpu_node           = default_x86_32_numa_cpu_node,
 };
diff --git a/arch/x86/kernel/apic/x2apic_uv_x.c b/arch/x86/kernel/apic/x2apic_uv_x.c
index 33b10a0fc095..7acd2d2ac965 100644
--- a/arch/x86/kernel/apic/x2apic_uv_x.c
+++ b/arch/x86/kernel/apic/x2apic_uv_x.c
@@ -37,6 +37,13 @@
 #include <asm/smp.h>
 #include <asm/x86_init.h>
 #include <asm/emergency-restart.h>
+#include <asm/nmi.h>
+
+/* BMC sets a bit this MMR non-zero before sending an NMI */
+#define UVH_NMI_MMR                             UVH_SCRATCH5
+#define UVH_NMI_MMR_CLEAR                       (UVH_NMI_MMR + 8)
+#define UV_NMI_PENDING_MASK                     (1UL << 63)
+DEFINE_PER_CPU(unsigned long, cpu_last_nmi_count);
 
 DEFINE_PER_CPU(int, x2apic_extra_bits);
 
@@ -642,18 +649,46 @@ void __cpuinit uv_cpu_init(void)
  */
 int uv_handle_nmi(struct notifier_block *self, unsigned long reason, void *data)
 {
+        unsigned long real_uv_nmi;
+        int bid;
+
         if (reason != DIE_NMIUNKNOWN)
                 return NOTIFY_OK;
 
         if (in_crash_kexec)
                 /* do nothing if entering the crash kernel */
                 return NOTIFY_OK;
+
         /*
-         * Use a lock so only one cpu prints at a time
-         * to prevent intermixed output.
+         * Each blade has an MMR that indicates when an NMI has been sent
+         * to cpus on the blade. If an NMI is detected, atomically
+         * clear the MMR and update a per-blade NMI count used to
+         * cause each cpu on the blade to notice a new NMI.
+         */
+        bid = uv_numa_blade_id();
+        real_uv_nmi = (uv_read_local_mmr(UVH_NMI_MMR) & UV_NMI_PENDING_MASK);
+
+        if (unlikely(real_uv_nmi)) {
+                spin_lock(&uv_blade_info[bid].nmi_lock);
+                real_uv_nmi = (uv_read_local_mmr(UVH_NMI_MMR) & UV_NMI_PENDING_MASK);
+                if (real_uv_nmi) {
+                        uv_blade_info[bid].nmi_count++;
+                        uv_write_local_mmr(UVH_NMI_MMR_CLEAR, UV_NMI_PENDING_MASK);
+                }
+                spin_unlock(&uv_blade_info[bid].nmi_lock);
+        }
+
+        if (likely(__get_cpu_var(cpu_last_nmi_count) == uv_blade_info[bid].nmi_count))
+                return NOTIFY_DONE;
+
+        __get_cpu_var(cpu_last_nmi_count) = uv_blade_info[bid].nmi_count;
+
+        /*
+         * Use a lock so only one cpu prints at a time.
+         * This prevents intermixed output.
          */
         spin_lock(&uv_nmi_lock);
-        pr_info("NMI stack dump cpu %u:\n", smp_processor_id());
+        pr_info("UV NMI stack dump cpu %u:\n", smp_processor_id());
         dump_stack();
         spin_unlock(&uv_nmi_lock);
 
@@ -661,7 +696,8 @@ int uv_handle_nmi(struct notifier_block *self, unsigned long reason, void *data)
 }
 
 static struct notifier_block uv_dump_stack_nmi_nb = {
-        .notifier_call  = uv_handle_nmi
+        .notifier_call  = uv_handle_nmi,
+        .priority = NMI_LOCAL_LOW_PRIOR - 1,
 };
 
 void uv_register_nmi_notifier(void)
@@ -720,8 +756,9 @@ void __init uv_system_init(void)
         printk(KERN_DEBUG "UV: Found %d blades\n", uv_num_possible_blades());
 
         bytes = sizeof(struct uv_blade_info) * uv_num_possible_blades();
-        uv_blade_info = kmalloc(bytes, GFP_KERNEL);
+        uv_blade_info = kzalloc(bytes, GFP_KERNEL);
         BUG_ON(!uv_blade_info);
+
         for (blade = 0; blade < uv_num_possible_blades(); blade++)
                 uv_blade_info[blade].memory_nid = -1;
 
@@ -747,6 +784,7 @@ void __init uv_system_init(void)
                         uv_blade_info[blade].pnode = pnode;
                         uv_blade_info[blade].nr_possible_cpus = 0;
                         uv_blade_info[blade].nr_online_cpus = 0;
+                        spin_lock_init(&uv_blade_info[blade].nmi_lock);
                         max_pnode = max(pnode, max_pnode);
                         blade++;
                 }
diff --git a/arch/x86/kernel/apm_32.c b/arch/x86/kernel/apm_32.c
index adee12e0da1f..3bfa02235965 100644
--- a/arch/x86/kernel/apm_32.c
+++ b/arch/x86/kernel/apm_32.c
@@ -1238,7 +1238,6 @@ static int suspend(int vetoable)
         dpm_suspend_noirq(PMSG_SUSPEND);
 
         local_irq_disable();
-        sysdev_suspend(PMSG_SUSPEND);
         syscore_suspend();
 
         local_irq_enable();
@@ -1258,7 +1257,6 @@ static int suspend(int vetoable)
         err = (err == APM_SUCCESS) ? 0 : -EIO;
 
         syscore_resume();
-        sysdev_resume();
         local_irq_enable();
 
         dpm_resume_noirq(PMSG_RESUME);
@@ -1282,7 +1280,6 @@ static void standby(void)
         dpm_suspend_noirq(PMSG_SUSPEND);
 
         local_irq_disable();
-        sysdev_suspend(PMSG_SUSPEND);
         syscore_suspend();
         local_irq_enable();
 
@@ -1292,7 +1289,6 @@ static void standby(void)
 
         local_irq_disable();
         syscore_resume();
-        sysdev_resume();
         local_irq_enable();
 
         dpm_resume_noirq(PMSG_RESUME);
diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile
index 3f0ebe429a01..6042981d0309 100644
--- a/arch/x86/kernel/cpu/Makefile
+++ b/arch/x86/kernel/cpu/Makefile
@@ -30,7 +30,6 @@ obj-$(CONFIG_PERF_EVENTS)		+= perf_event.o
 
 obj-$(CONFIG_X86_MCE)                   += mcheck/
 obj-$(CONFIG_MTRR)                      += mtrr/
-obj-$(CONFIG_CPU_FREQ)                  += cpufreq/
 
 obj-$(CONFIG_X86_LOCAL_APIC)            += perfctr-watchdog.o
 
diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c
index bb9eb29a52dd..6f9d1f6063e9 100644
--- a/arch/x86/kernel/cpu/amd.c
+++ b/arch/x86/kernel/cpu/amd.c
@@ -613,7 +613,7 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
 #endif
 
         /* As a rule processors have APIC timer running in deep C states */
-        if (c->x86 >= 0xf && !cpu_has_amd_erratum(amd_erratum_400))
+        if (c->x86 > 0xf && !cpu_has_amd_erratum(amd_erratum_400))
                 set_cpu_cap(c, X86_FEATURE_ARAT);
 
         /*
@@ -698,7 +698,7 @@ cpu_dev_register(amd_cpu_dev);
  */
 
 const int amd_erratum_400[] =
-        AMD_OSVW_ERRATUM(1, AMD_MODEL_RANGE(0x0f, 0x4, 0x2, 0xff, 0xf),
+        AMD_OSVW_ERRATUM(1, AMD_MODEL_RANGE(0xf, 0x41, 0x2, 0xff, 0xf),
                             AMD_MODEL_RANGE(0x10, 0x2, 0x1, 0xff, 0xf));
 EXPORT_SYMBOL_GPL(amd_erratum_400);
 
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index e2ced0074a45..cbc70a27430c 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -254,6 +254,25 @@ static inline void squash_the_stupid_serial_number(struct cpuinfo_x86 *c)
 }
 #endif
 
+static int disable_smep __initdata;
+static __init int setup_disable_smep(char *arg)
+{
+        disable_smep = 1;
+        return 1;
+}
+__setup("nosmep", setup_disable_smep);
+
+static __init void setup_smep(struct cpuinfo_x86 *c)
+{
+        if (cpu_has(c, X86_FEATURE_SMEP)) {
+                if (unlikely(disable_smep)) {
+                        setup_clear_cpu_cap(X86_FEATURE_SMEP);
+                        clear_in_cr4(X86_CR4_SMEP);
+                } else
+                        set_in_cr4(X86_CR4_SMEP);
+        }
+}
+
 /*
  * Some CPU features depend on higher CPUID levels, which may not always
  * be available due to CPUID level capping or broken virtualization
@@ -565,8 +584,7 @@ void __cpuinit get_cpu_cap(struct cpuinfo_x86 *c)
 
                 cpuid_count(0x00000007, 0, &eax, &ebx, &ecx, &edx);
 
-                if (eax > 0)
-                        c->x86_capability[9] = ebx;
+                c->x86_capability[9] = ebx;
         }
 
         /* AMD-defined flags: level 0x80000001 */
@@ -668,6 +686,8 @@ static void __init early_identify_cpu(struct cpuinfo_x86 *c)
         c->cpu_index = 0;
 #endif
         filter_cpuid_features(c, false);
+
+        setup_smep(c);
 }
 
 void __init early_cpu_init(void)
@@ -753,6 +773,8 @@ static void __cpuinit generic_identify(struct cpuinfo_x86 *c)
 #endif
         }
 
+        setup_smep(c);
+
         get_model_name(c); /* Default name */
 
         detect_nopl(c);
diff --git a/arch/x86/kernel/cpu/cpufreq/Kconfig b/arch/x86/kernel/cpu/cpufreq/Kconfig
deleted file mode 100644
index 870e6cc6ad28..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/Kconfig
+++ /dev/null
@@ -1,266 +0,0 @@
-#
-# CPU Frequency scaling
-#
-
-menu "CPU Frequency scaling"
-
-source "drivers/cpufreq/Kconfig"
-
-if CPU_FREQ
-
-comment "CPUFreq processor drivers"
-
-config X86_PCC_CPUFREQ
-        tristate "Processor Clocking Control interface driver"
-        depends on ACPI && ACPI_PROCESSOR
-        help
-          This driver adds support for the PCC interface.
-
-          For details, take a look at:
-          <file:Documentation/cpu-freq/pcc-cpufreq.txt>.
-
-          To compile this driver as a module, choose M here: the
-          module will be called pcc-cpufreq.
-
-          If in doubt, say N.
-
-config X86_ACPI_CPUFREQ
-        tristate "ACPI Processor P-States driver"
-        select CPU_FREQ_TABLE
-        depends on ACPI_PROCESSOR
-        help
-          This driver adds a CPUFreq driver which utilizes the ACPI
-          Processor Performance States.
-          This driver also supports Intel Enhanced Speedstep.
-
-          To compile this driver as a module, choose M here: the
-          module will be called acpi-cpufreq.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config ELAN_CPUFREQ
-        tristate "AMD Elan SC400 and SC410"
-        select CPU_FREQ_TABLE
-        depends on X86_ELAN
-        ---help---
-          This adds the CPUFreq driver for AMD Elan SC400 and SC410
-          processors.
-
-          You need to specify the processor maximum speed as boot
-          parameter: elanfreq=maxspeed (in kHz) or as module
-          parameter "max_freq".
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config SC520_CPUFREQ
-        tristate "AMD Elan SC520"
-        select CPU_FREQ_TABLE
-        depends on X86_ELAN
-        ---help---
-          This adds the CPUFreq driver for AMD Elan SC520 processor.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-
-config X86_POWERNOW_K6
-        tristate "AMD Mobile K6-2/K6-3 PowerNow!"
-        select CPU_FREQ_TABLE
-        depends on X86_32
-        help
-          This adds the CPUFreq driver for mobile AMD K6-2+ and mobile
-          AMD K6-3+ processors.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_POWERNOW_K7
-        tristate "AMD Mobile Athlon/Duron PowerNow!"
-        select CPU_FREQ_TABLE
-        depends on X86_32
-        help
-          This adds the CPUFreq driver for mobile AMD K7 mobile processors.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_POWERNOW_K7_ACPI
-        bool
-        depends on X86_POWERNOW_K7 && ACPI_PROCESSOR
-        depends on !(X86_POWERNOW_K7 = y && ACPI_PROCESSOR = m)
-        depends on X86_32
-        default y
-
-config X86_POWERNOW_K8
-        tristate "AMD Opteron/Athlon64 PowerNow!"
-        select CPU_FREQ_TABLE
-        depends on ACPI && ACPI_PROCESSOR
-        help
-          This adds the CPUFreq driver for K8/K10 Opteron/Athlon64 processors.
-
-          To compile this driver as a module, choose M here: the
-          module will be called powernow-k8.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-config X86_GX_SUSPMOD
-        tristate "Cyrix MediaGX/NatSemi Geode Suspend Modulation"
-        depends on X86_32 && PCI
-        help
-         This add the CPUFreq driver for NatSemi Geode processors which
-         support suspend modulation.
-
-         For details, take a look at <file:Documentation/cpu-freq/>.
-
-         If in doubt, say N.
-
-config X86_SPEEDSTEP_CENTRINO
-        tristate "Intel Enhanced SpeedStep (deprecated)"
-        select CPU_FREQ_TABLE
-        select X86_SPEEDSTEP_CENTRINO_TABLE if X86_32
-        depends on X86_32 || (X86_64 && ACPI_PROCESSOR)
-        help
-          This is deprecated and this functionality is now merged into
-          acpi_cpufreq (X86_ACPI_CPUFREQ). Use that driver instead of
-          speedstep_centrino.
-          This adds the CPUFreq driver for Enhanced SpeedStep enabled
-          mobile CPUs.  This means Intel Pentium M (Centrino) CPUs
-          or 64bit enabled Intel Xeons.
-
-          To compile this driver as a module, choose M here: the
-          module will be called speedstep-centrino.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_SPEEDSTEP_CENTRINO_TABLE
-        bool "Built-in tables for Banias CPUs"
-        depends on X86_32 && X86_SPEEDSTEP_CENTRINO
-        default y
-        help
-          Use built-in tables for Banias CPUs if ACPI encoding
-          is not available.
-
-          If in doubt, say N.
-
-config X86_SPEEDSTEP_ICH
-        tristate "Intel Speedstep on ICH-M chipsets (ioport interface)"
-        select CPU_FREQ_TABLE
-        depends on X86_32
-        help
-          This adds the CPUFreq driver for certain mobile Intel Pentium III
-          (Coppermine), all mobile Intel Pentium III-M (Tualatin) and all
-          mobile Intel Pentium 4 P4-M on systems which have an Intel ICH2,
-          ICH3 or ICH4 southbridge.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_SPEEDSTEP_SMI
-        tristate "Intel SpeedStep on 440BX/ZX/MX chipsets (SMI interface)"
-        select CPU_FREQ_TABLE
-        depends on X86_32 && EXPERIMENTAL
-        help
-          This adds the CPUFreq driver for certain mobile Intel Pentium III
-          (Coppermine), all mobile Intel Pentium III-M (Tualatin)
-          on systems which have an Intel 440BX/ZX/MX southbridge.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_P4_CLOCKMOD
-        tristate "Intel Pentium 4 clock modulation"
-        select CPU_FREQ_TABLE
-        help
-          This adds the CPUFreq driver for Intel Pentium 4 / XEON
-          processors.  When enabled it will lower CPU temperature by skipping
-          clocks.
-
-          This driver should be only used in exceptional
-          circumstances when very low power is needed because it causes severe
-          slowdowns and noticeable latencies.  Normally Speedstep should be used
-          instead.
-
-          To compile this driver as a module, choose M here: the
-          module will be called p4-clockmod.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          Unless you are absolutely sure say N.
-
-config X86_CPUFREQ_NFORCE2
-        tristate "nVidia nForce2 FSB changing"
-        depends on X86_32 && EXPERIMENTAL
-        help
-          This adds the CPUFreq driver for FSB changing on nVidia nForce2
-          platforms.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_LONGRUN
-        tristate "Transmeta LongRun"
-        depends on X86_32
-        help
-          This adds the CPUFreq driver for Transmeta Crusoe and Efficeon processors
-          which support LongRun.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_LONGHAUL
-        tristate "VIA Cyrix III Longhaul"
-        select CPU_FREQ_TABLE
-        depends on X86_32 && ACPI_PROCESSOR
-        help
-          This adds the CPUFreq driver for VIA Samuel/CyrixIII,
-          VIA Cyrix Samuel/C3, VIA Cyrix Ezra and VIA Cyrix Ezra-T
-          processors.
-
-          For details, take a look at <file:Documentation/cpu-freq/>.
-
-          If in doubt, say N.
-
-config X86_E_POWERSAVER
-        tristate "VIA C7 Enhanced PowerSaver (DANGEROUS)"
-        select CPU_FREQ_TABLE
-        depends on X86_32 && EXPERIMENTAL
-        help
-          This adds the CPUFreq driver for VIA C7 processors.  However, this driver
-          does not have any safeguards to prevent operating the CPU out of spec
-          and is thus considered dangerous.  Please use the regular ACPI cpufreq
-          driver, enabled by CONFIG_X86_ACPI_CPUFREQ.
-
-          If in doubt, say N.
-
-comment "shared options"
-
-config X86_SPEEDSTEP_LIB
-        tristate
-        default (X86_SPEEDSTEP_ICH || X86_SPEEDSTEP_SMI || X86_P4_CLOCKMOD)
-
-config X86_SPEEDSTEP_RELAXED_CAP_CHECK
-        bool "Relaxed speedstep capability checks"
-        depends on X86_32 && (X86_SPEEDSTEP_SMI || X86_SPEEDSTEP_ICH)
-        help
-          Don't perform all checks for a speedstep capable system which would
-          normally be done. Some ancient or strange systems, though speedstep
-          capable, don't always indicate that they are speedstep capable. This
-          option lets the probing code bypass some of those checks if the
-          parameter "relaxed_check=1" is passed to the module.
-
-endif   # CPU_FREQ
-
-endmenu
diff --git a/arch/x86/kernel/cpu/cpufreq/Makefile b/arch/x86/kernel/cpu/cpufreq/Makefile
deleted file mode 100644
index bd54bf67e6fb..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/Makefile
+++ /dev/null
@@ -1,21 +0,0 @@
-# Link order matters. K8 is preferred to ACPI because of firmware bugs in early
-# K8 systems. ACPI is preferred to all other hardware-specific drivers.
-# speedstep-* is preferred over p4-clockmod.
-
-obj-$(CONFIG_X86_POWERNOW_K8)           += powernow-k8.o mperf.o
-obj-$(CONFIG_X86_ACPI_CPUFREQ)          += acpi-cpufreq.o mperf.o
-obj-$(CONFIG_X86_PCC_CPUFREQ)           += pcc-cpufreq.o
-obj-$(CONFIG_X86_POWERNOW_K6)           += powernow-k6.o
-obj-$(CONFIG_X86_POWERNOW_K7)           += powernow-k7.o
-obj-$(CONFIG_X86_LONGHAUL)              += longhaul.o
-obj-$(CONFIG_X86_E_POWERSAVER)          += e_powersaver.o
-obj-$(CONFIG_ELAN_CPUFREQ)              += elanfreq.o
-obj-$(CONFIG_SC520_CPUFREQ)             += sc520_freq.o
-obj-$(CONFIG_X86_LONGRUN)               += longrun.o  
-obj-$(CONFIG_X86_GX_SUSPMOD)            += gx-suspmod.o
-obj-$(CONFIG_X86_SPEEDSTEP_ICH)         += speedstep-ich.o
-obj-$(CONFIG_X86_SPEEDSTEP_LIB)         += speedstep-lib.o
-obj-$(CONFIG_X86_SPEEDSTEP_SMI)         += speedstep-smi.o
-obj-$(CONFIG_X86_SPEEDSTEP_CENTRINO)    += speedstep-centrino.o
-obj-$(CONFIG_X86_P4_CLOCKMOD)           += p4-clockmod.o
-obj-$(CONFIG_X86_CPUFREQ_NFORCE2)       += cpufreq-nforce2.o
diff --git a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
deleted file mode 100644
index a2baafb2fe6d..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ /dev/null
@@ -1,776 +0,0 @@
-/*
- * acpi-cpufreq.c - ACPI Processor P-States Driver
- *
- *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
- *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
- *  Copyright (C) 2002 - 2004 Dominik Brodowski <linux@brodo.de>
- *  Copyright (C) 2006       Denis Sadykov <denis.m.sadykov@intel.com>
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or (at
- *  your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but
- *  WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/smp.h>
-#include <linux/sched.h>
-#include <linux/cpufreq.h>
-#include <linux/compiler.h>
-#include <linux/dmi.h>
-#include <linux/slab.h>
-
-#include <linux/acpi.h>
-#include <linux/io.h>
-#include <linux/delay.h>
-#include <linux/uaccess.h>
-
-#include <acpi/processor.h>
-
-#include <asm/msr.h>
-#include <asm/processor.h>
-#include <asm/cpufeature.h>
-#include "mperf.h"
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "acpi-cpufreq", msg)
-
-MODULE_AUTHOR("Paul Diefenbaugh, Dominik Brodowski");
-MODULE_DESCRIPTION("ACPI Processor P-States Driver");
-MODULE_LICENSE("GPL");
-
-enum {
-        UNDEFINED_CAPABLE = 0,
-        SYSTEM_INTEL_MSR_CAPABLE,
-        SYSTEM_IO_CAPABLE,
-};
-
-#define INTEL_MSR_RANGE         (0xffff)
-
-struct acpi_cpufreq_data {
-        struct acpi_processor_performance *acpi_data;
-        struct cpufreq_frequency_table *freq_table;
-        unsigned int resume;
-        unsigned int cpu_feature;
-};
-
-static DEFINE_PER_CPU(struct acpi_cpufreq_data *, acfreq_data);
-
-/* acpi_perf_data is a pointer to percpu data. */
-static struct acpi_processor_performance __percpu *acpi_perf_data;
-
-static struct cpufreq_driver acpi_cpufreq_driver;
-
-static unsigned int acpi_pstate_strict;
-
-static int check_est_cpu(unsigned int cpuid)
-{
-        struct cpuinfo_x86 *cpu = &cpu_data(cpuid);
-
-        return cpu_has(cpu, X86_FEATURE_EST);
-}
-
-static unsigned extract_io(u32 value, struct acpi_cpufreq_data *data)
-{
-        struct acpi_processor_performance *perf;
-        int i;
-
-        perf = data->acpi_data;
-
-        for (i = 0; i < perf->state_count; i++) {
-                if (value == perf->states[i].status)
-                        return data->freq_table[i].frequency;
-        }
-        return 0;
-}
-
-static unsigned extract_msr(u32 msr, struct acpi_cpufreq_data *data)
-{
-        int i;
-        struct acpi_processor_performance *perf;
-
-        msr &= INTEL_MSR_RANGE;
-        perf = data->acpi_data;
-
-        for (i = 0; data->freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
-                if (msr == perf->states[data->freq_table[i].index].status)
-                        return data->freq_table[i].frequency;
-        }
-        return data->freq_table[0].frequency;
-}
-
-static unsigned extract_freq(u32 val, struct acpi_cpufreq_data *data)
-{
-        switch (data->cpu_feature) {
-        case SYSTEM_INTEL_MSR_CAPABLE:
-                return extract_msr(val, data);
-        case SYSTEM_IO_CAPABLE:
-                return extract_io(val, data);
-        default:
-                return 0;
-        }
-}
-
-struct msr_addr {
-        u32 reg;
-};
-
-struct io_addr {
-        u16 port;
-        u8 bit_width;
-};
-
-struct drv_cmd {
-        unsigned int type;
-        const struct cpumask *mask;
-        union {
-                struct msr_addr msr;
-                struct io_addr io;
-        } addr;
-        u32 val;
-};
-
-/* Called via smp_call_function_single(), on the target CPU */
-static void do_drv_read(void *_cmd)
-{
-        struct drv_cmd *cmd = _cmd;
-        u32 h;
-
-        switch (cmd->type) {
-        case SYSTEM_INTEL_MSR_CAPABLE:
-                rdmsr(cmd->addr.msr.reg, cmd->val, h);
-                break;
-        case SYSTEM_IO_CAPABLE:
-                acpi_os_read_port((acpi_io_address)cmd->addr.io.port,
-                                &cmd->val,
-                                (u32)cmd->addr.io.bit_width);
-                break;
-        default:
-                break;
-        }
-}
-
-/* Called via smp_call_function_many(), on the target CPUs */
-static void do_drv_write(void *_cmd)
-{
-        struct drv_cmd *cmd = _cmd;
-        u32 lo, hi;
-
-        switch (cmd->type) {
-        case SYSTEM_INTEL_MSR_CAPABLE:
-                rdmsr(cmd->addr.msr.reg, lo, hi);
-                lo = (lo & ~INTEL_MSR_RANGE) | (cmd->val & INTEL_MSR_RANGE);
-                wrmsr(cmd->addr.msr.reg, lo, hi);
-                break;
-        case SYSTEM_IO_CAPABLE:
-                acpi_os_write_port((acpi_io_address)cmd->addr.io.port,
-                                cmd->val,
-                                (u32)cmd->addr.io.bit_width);
-                break;
-        default:
-                break;
-        }
-}
-
-static void drv_read(struct drv_cmd *cmd)
-{
-        int err;
-        cmd->val = 0;
-
-        err = smp_call_function_any(cmd->mask, do_drv_read, cmd, 1);
-        WARN_ON_ONCE(err);      /* smp_call_function_any() was buggy? */
-}
-
-static void drv_write(struct drv_cmd *cmd)
-{
-        int this_cpu;
-
-        this_cpu = get_cpu();
-        if (cpumask_test_cpu(this_cpu, cmd->mask))
-                do_drv_write(cmd);
-        smp_call_function_many(cmd->mask, do_drv_write, cmd, 1);
-        put_cpu();
-}
-
-static u32 get_cur_val(const struct cpumask *mask)
-{
-        struct acpi_processor_performance *perf;
-        struct drv_cmd cmd;
-
-        if (unlikely(cpumask_empty(mask)))
-                return 0;
-
-        switch (per_cpu(acfreq_data, cpumask_first(mask))->cpu_feature) {
-        case SYSTEM_INTEL_MSR_CAPABLE:
-                cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
-                cmd.addr.msr.reg = MSR_IA32_PERF_STATUS;
-                break;
-        case SYSTEM_IO_CAPABLE:
-                cmd.type = SYSTEM_IO_CAPABLE;
-                perf = per_cpu(acfreq_data, cpumask_first(mask))->acpi_data;
-                cmd.addr.io.port = perf->control_register.address;
-                cmd.addr.io.bit_width = perf->control_register.bit_width;
-                break;
-        default:
-                return 0;
-        }
-
-        cmd.mask = mask;
-        drv_read(&cmd);
-
-        dprintk("get_cur_val = %u\n", cmd.val);
-
-        return cmd.val;
-}
-
-static unsigned int get_cur_freq_on_cpu(unsigned int cpu)
-{
-        struct acpi_cpufreq_data *data = per_cpu(acfreq_data, cpu);
-        unsigned int freq;
-        unsigned int cached_freq;
-
-        dprintk("get_cur_freq_on_cpu (%d)\n", cpu);
-
-        if (unlikely(data == NULL ||
-                     data->acpi_data == NULL || data->freq_table == NULL)) {
-                return 0;
-        }
-
-        cached_freq = data->freq_table[data->acpi_data->state].frequency;
-        freq = extract_freq(get_cur_val(cpumask_of(cpu)), data);
-        if (freq != cached_freq) {
-                /*
-                 * The dreaded BIOS frequency change behind our back.
-                 * Force set the frequency on next target call.
-                 */
-                data->resume = 1;
-        }
-
-        dprintk("cur freq = %u\n", freq);
-
-        return freq;
-}
-
-static unsigned int check_freqs(const struct cpumask *mask, unsigned int freq,
-                                struct acpi_cpufreq_data *data)
-{
-        unsigned int cur_freq;
-        unsigned int i;
-
-        for (i = 0; i < 100; i++) {
-                cur_freq = extract_freq(get_cur_val(mask), data);
-                if (cur_freq == freq)
-                        return 1;
-                udelay(10);
-        }
-        return 0;
-}
-
-static int acpi_cpufreq_target(struct cpufreq_policy *policy,
-                               unsigned int target_freq, unsigned int relation)
-{
-        struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
-        struct acpi_processor_performance *perf;
-        struct cpufreq_freqs freqs;
-        struct drv_cmd cmd;
-        unsigned int next_state = 0; /* Index into freq_table */
-        unsigned int next_perf_state = 0; /* Index into perf table */
-        unsigned int i;
-        int result = 0;
-
-        dprintk("acpi_cpufreq_target %d (%d)\n", target_freq, policy->cpu);
-
-        if (unlikely(data == NULL ||
-             data->acpi_data == NULL || data->freq_table == NULL)) {
-                return -ENODEV;
-        }
-
-        perf = data->acpi_data;
-        result = cpufreq_frequency_table_target(policy,
-                                                data->freq_table,
-                                                target_freq,
-                                                relation, &next_state);
-        if (unlikely(result)) {
-                result = -ENODEV;
-                goto out;
-        }
-
-        next_perf_state = data->freq_table[next_state].index;
-        if (perf->state == next_perf_state) {
-                if (unlikely(data->resume)) {
-                        dprintk("Called after resume, resetting to P%d\n",
-                                next_perf_state);
-                        data->resume = 0;
-                } else {
-                        dprintk("Already at target state (P%d)\n",
-                                next_perf_state);
-                        goto out;
-                }
-        }
-
-        switch (data->cpu_feature) {
-        case SYSTEM_INTEL_MSR_CAPABLE:
-                cmd.type = SYSTEM_INTEL_MSR_CAPABLE;
-                cmd.addr.msr.reg = MSR_IA32_PERF_CTL;
-                cmd.val = (u32) perf->states[next_perf_state].control;
-                break;
-        case SYSTEM_IO_CAPABLE:
-                cmd.type = SYSTEM_IO_CAPABLE;
-                cmd.addr.io.port = perf->control_register.address;
-                cmd.addr.io.bit_width = perf->control_register.bit_width;
-                cmd.val = (u32) perf->states[next_perf_state].control;
-                break;
-        default:
-                result = -ENODEV;
-                goto out;
-        }
-
-        /* cpufreq holds the hotplug lock, so we are safe from here on */
-        if (policy->shared_type != CPUFREQ_SHARED_TYPE_ANY)
-                cmd.mask = policy->cpus;
-        else
-                cmd.mask = cpumask_of(policy->cpu);
-
-        freqs.old = perf->states[perf->state].core_frequency * 1000;
-        freqs.new = data->freq_table[next_state].frequency;
-        for_each_cpu(i, policy->cpus) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        }
-
-        drv_write(&cmd);
-
-        if (acpi_pstate_strict) {
-                if (!check_freqs(cmd.mask, freqs.new, data)) {
-                        dprintk("acpi_cpufreq_target failed (%d)\n",
-                                policy->cpu);
-                        result = -EAGAIN;
-                        goto out;
-                }
-        }
-
-        for_each_cpu(i, policy->cpus) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        }
-        perf->state = next_perf_state;
-
-out:
-        return result;
-}
-
-static int acpi_cpufreq_verify(struct cpufreq_policy *policy)
-{
-        struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
-
-        dprintk("acpi_cpufreq_verify\n");
-
-        return cpufreq_frequency_table_verify(policy, data->freq_table);
-}
-
-static unsigned long
-acpi_cpufreq_guess_freq(struct acpi_cpufreq_data *data, unsigned int cpu)
-{
-        struct acpi_processor_performance *perf = data->acpi_data;
-
-        if (cpu_khz) {
-                /* search the closest match to cpu_khz */
-                unsigned int i;
-                unsigned long freq;
-                unsigned long freqn = perf->states[0].core_frequency * 1000;
-
-                for (i = 0; i < (perf->state_count-1); i++) {
-                        freq = freqn;
-                        freqn = perf->states[i+1].core_frequency * 1000;
-                        if ((2 * cpu_khz) > (freqn + freq)) {
-                                perf->state = i;
-                                return freq;
-                        }
-                }
-                perf->state = perf->state_count-1;
-                return freqn;
-        } else {
-                /* assume CPU is at P0... */
-                perf->state = 0;
-                return perf->states[0].core_frequency * 1000;
-        }
-}
-
-static void free_acpi_perf_data(void)
-{
-        unsigned int i;
-
-        /* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */
-        for_each_possible_cpu(i)
-                free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)
-                                 ->shared_cpu_map);
-        free_percpu(acpi_perf_data);
-}
-
-/*
- * acpi_cpufreq_early_init - initialize ACPI P-States library
- *
- * Initialize the ACPI P-States library (drivers/acpi/processor_perflib.c)
- * in order to determine correct frequency and voltage pairings. We can
- * do _PDC and _PSD and find out the processor dependency for the
- * actual init that will happen later...
- */
-static int __init acpi_cpufreq_early_init(void)
-{
-        unsigned int i;
-        dprintk("acpi_cpufreq_early_init\n");
-
-        acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
-        if (!acpi_perf_data) {
-                dprintk("Memory allocation error for acpi_perf_data.\n");
-                return -ENOMEM;
-        }
-        for_each_possible_cpu(i) {
-                if (!zalloc_cpumask_var_node(
-                        &per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,
-                        GFP_KERNEL, cpu_to_node(i))) {
-
-                        /* Freeing a NULL pointer is OK: alloc_percpu zeroes. */
-                        free_acpi_perf_data();
-                        return -ENOMEM;
-                }
-        }
-
-        /* Do initialization in ACPI core */
-        acpi_processor_preregister_performance(acpi_perf_data);
-        return 0;
-}
-
-#ifdef CONFIG_SMP
-/*
- * Some BIOSes do SW_ANY coordination internally, either set it up in hw
- * or do it in BIOS firmware and won't inform about it to OS. If not
- * detected, this has a side effect of making CPU run at a different speed
- * than OS intended it to run at. Detect it and handle it cleanly.
- */
-static int bios_with_sw_any_bug;
-
-static int sw_any_bug_found(const struct dmi_system_id *d)
-{
-        bios_with_sw_any_bug = 1;
-        return 0;
-}
-
-static const struct dmi_system_id sw_any_bug_dmi_table[] = {
-        {
-                .callback = sw_any_bug_found,
-                .ident = "Supermicro Server X6DLP",
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Supermicro"),
-                        DMI_MATCH(DMI_BIOS_VERSION, "080010"),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "X6DLP"),
-                },
-        },
-        { }
-};
-
-static int acpi_cpufreq_blacklist(struct cpuinfo_x86 *c)
-{
-        /* Intel Xeon Processor 7100 Series Specification Update
-         * http://www.intel.com/Assets/PDF/specupdate/314554.pdf
-         * AL30: A Machine Check Exception (MCE) Occurring during an
-         * Enhanced Intel SpeedStep Technology Ratio Change May Cause
-         * Both Processor Cores to Lock Up. */
-        if (c->x86_vendor == X86_VENDOR_INTEL) {
-                if ((c->x86 == 15) &&
-                    (c->x86_model == 6) &&
-                    (c->x86_mask == 8)) {
-                        printk(KERN_INFO "acpi-cpufreq: Intel(R) "
-                            "Xeon(R) 7100 Errata AL30, processors may "
-                            "lock up on frequency changes: disabling "
-                            "acpi-cpufreq.\n");
-                        return -ENODEV;
-                    }
-                }
-        return 0;
-}
-#endif
-
-static int acpi_cpufreq_cpu_init(struct cpufreq_policy *policy)
-{
-        unsigned int i;
-        unsigned int valid_states = 0;
-        unsigned int cpu = policy->cpu;
-        struct acpi_cpufreq_data *data;
-        unsigned int result = 0;
-        struct cpuinfo_x86 *c = &cpu_data(policy->cpu);
-        struct acpi_processor_performance *perf;
-#ifdef CONFIG_SMP
-        static int blacklisted;
-#endif
-
-        dprintk("acpi_cpufreq_cpu_init\n");
-
-#ifdef CONFIG_SMP
-        if (blacklisted)
-                return blacklisted;
-        blacklisted = acpi_cpufreq_blacklist(c);
-        if (blacklisted)
-                return blacklisted;
-#endif
-
-        data = kzalloc(sizeof(struct acpi_cpufreq_data), GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-
-        data->acpi_data = per_cpu_ptr(acpi_perf_data, cpu);
-        per_cpu(acfreq_data, cpu) = data;
-
-        if (cpu_has(c, X86_FEATURE_CONSTANT_TSC))
-                acpi_cpufreq_driver.flags |= CPUFREQ_CONST_LOOPS;
-
-        result = acpi_processor_register_performance(data->acpi_data, cpu);
-        if (result)
-                goto err_free;
-
-        perf = data->acpi_data;
-        policy->shared_type = perf->shared_type;
-
-        /*
-         * Will let policy->cpus know about dependency only when software
-         * coordination is required.
-         */
-        if (policy->shared_type == CPUFREQ_SHARED_TYPE_ALL ||
-            policy->shared_type == CPUFREQ_SHARED_TYPE_ANY) {
-                cpumask_copy(policy->cpus, perf->shared_cpu_map);
-        }
-        cpumask_copy(policy->related_cpus, perf->shared_cpu_map);
-
-#ifdef CONFIG_SMP
-        dmi_check_system(sw_any_bug_dmi_table);
-        if (bios_with_sw_any_bug && cpumask_weight(policy->cpus) == 1) {
-                policy->shared_type = CPUFREQ_SHARED_TYPE_ALL;
-                cpumask_copy(policy->cpus, cpu_core_mask(cpu));
-        }
-#endif
-
-        /* capability check */
-        if (perf->state_count <= 1) {
-                dprintk("No P-States\n");
-                result = -ENODEV;
-                goto err_unreg;
-        }
-
-        if (perf->control_register.space_id != perf->status_register.space_id) {
-                result = -ENODEV;
-                goto err_unreg;
-        }
-
-        switch (perf->control_register.space_id) {
-        case ACPI_ADR_SPACE_SYSTEM_IO:
-                dprintk("SYSTEM IO addr space\n");
-                data->cpu_feature = SYSTEM_IO_CAPABLE;
-                break;
-        case ACPI_ADR_SPACE_FIXED_HARDWARE:
-                dprintk("HARDWARE addr space\n");
-                if (!check_est_cpu(cpu)) {
-                        result = -ENODEV;
-                        goto err_unreg;
-                }
-                data->cpu_feature = SYSTEM_INTEL_MSR_CAPABLE;
-                break;
-        default:
-                dprintk("Unknown addr space %d\n",
-                        (u32) (perf->control_register.space_id));
-                result = -ENODEV;
-                goto err_unreg;
-        }
-
-        data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
-                    (perf->state_count+1), GFP_KERNEL);
-        if (!data->freq_table) {
-                result = -ENOMEM;
-                goto err_unreg;
-        }
-
-        /* detect transition latency */
-        policy->cpuinfo.transition_latency = 0;
-        for (i = 0; i < perf->state_count; i++) {
-                if ((perf->states[i].transition_latency * 1000) >
-                    policy->cpuinfo.transition_latency)
-                        policy->cpuinfo.transition_latency =
-                            perf->states[i].transition_latency * 1000;
-        }
-
-        /* Check for high latency (>20uS) from buggy BIOSes, like on T42 */
-        if (perf->control_register.space_id == ACPI_ADR_SPACE_FIXED_HARDWARE &&
-            policy->cpuinfo.transition_latency > 20 * 1000) {
-                policy->cpuinfo.transition_latency = 20 * 1000;
-                printk_once(KERN_INFO
-                            "P-state transition latency capped at 20 uS\n");
-        }
-
-        /* table init */
-        for (i = 0; i < perf->state_count; i++) {
-                if (i > 0 && perf->states[i].core_frequency >=
-                    data->freq_table[valid_states-1].frequency / 1000)
-                        continue;
-
-                data->freq_table[valid_states].index = i;
-                data->freq_table[valid_states].frequency =
-                    perf->states[i].core_frequency * 1000;
-                valid_states++;
-        }
-        data->freq_table[valid_states].frequency = CPUFREQ_TABLE_END;
-        perf->state = 0;
-
-        result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);
-        if (result)
-                goto err_freqfree;
-
-        if (perf->states[0].core_frequency * 1000 != policy->cpuinfo.max_freq)
-                printk(KERN_WARNING FW_WARN "P-state 0 is not max freq\n");
-
-        switch (perf->control_register.space_id) {
-        case ACPI_ADR_SPACE_SYSTEM_IO:
-                /* Current speed is unknown and not detectable by IO port */
-                policy->cur = acpi_cpufreq_guess_freq(data, policy->cpu);
-                break;
-        case ACPI_ADR_SPACE_FIXED_HARDWARE:
-                acpi_cpufreq_driver.get = get_cur_freq_on_cpu;
-                policy->cur = get_cur_freq_on_cpu(cpu);
-                break;
-        default:
-                break;
-        }
-
-        /* notify BIOS that we exist */
-        acpi_processor_notify_smm(THIS_MODULE);
-
-        /* Check for APERF/MPERF support in hardware */
-        if (cpu_has(c, X86_FEATURE_APERFMPERF))
-                acpi_cpufreq_driver.getavg = cpufreq_get_measured_perf;
-
-        dprintk("CPU%u - ACPI performance management activated.\n", cpu);
-        for (i = 0; i < perf->state_count; i++)
-                dprintk("     %cP%d: %d MHz, %d mW, %d uS\n",
-                        (i == perf->state ? '*' : ' '), i,
-                        (u32) perf->states[i].core_frequency,
-                        (u32) perf->states[i].power,
-                        (u32) perf->states[i].transition_latency);
-
-        cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);
-
-        /*
-         * the first call to ->target() should result in us actually
-         * writing something to the appropriate registers.
-         */
-        data->resume = 1;
-
-        return result;
-
-err_freqfree:
-        kfree(data->freq_table);
-err_unreg:
-        acpi_processor_unregister_performance(perf, cpu);
-err_free:
-        kfree(data);
-        per_cpu(acfreq_data, cpu) = NULL;
-
-        return result;
-}
-
-static int acpi_cpufreq_cpu_exit(struct cpufreq_policy *policy)
-{
-        struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
-
-        dprintk("acpi_cpufreq_cpu_exit\n");
-
-        if (data) {
-                cpufreq_frequency_table_put_attr(policy->cpu);
-                per_cpu(acfreq_data, policy->cpu) = NULL;
-                acpi_processor_unregister_performance(data->acpi_data,
-                                                      policy->cpu);
-                kfree(data->freq_table);
-                kfree(data);
-        }
-
-        return 0;
-}
-
-static int acpi_cpufreq_resume(struct cpufreq_policy *policy)
-{
-        struct acpi_cpufreq_data *data = per_cpu(acfreq_data, policy->cpu);
-
-        dprintk("acpi_cpufreq_resume\n");
-
-        data->resume = 1;
-
-        return 0;
-}
-
-static struct freq_attr *acpi_cpufreq_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver acpi_cpufreq_driver = {
-        .verify         = acpi_cpufreq_verify,
-        .target         = acpi_cpufreq_target,
-        .bios_limit     = acpi_processor_get_bios_limit,
-        .init           = acpi_cpufreq_cpu_init,
-        .exit           = acpi_cpufreq_cpu_exit,
-        .resume         = acpi_cpufreq_resume,
-        .name           = "acpi-cpufreq",
-        .owner          = THIS_MODULE,
-        .attr           = acpi_cpufreq_attr,
-};
-
-static int __init acpi_cpufreq_init(void)
-{
-        int ret;
-
-        if (acpi_disabled)
-                return 0;
-
-        dprintk("acpi_cpufreq_init\n");
-
-        ret = acpi_cpufreq_early_init();
-        if (ret)
-                return ret;
-
-        ret = cpufreq_register_driver(&acpi_cpufreq_driver);
-        if (ret)
-                free_acpi_perf_data();
-
-        return ret;
-}
-
-static void __exit acpi_cpufreq_exit(void)
-{
-        dprintk("acpi_cpufreq_exit\n");
-
-        cpufreq_unregister_driver(&acpi_cpufreq_driver);
-
-        free_percpu(acpi_perf_data);
-}
-
-module_param(acpi_pstate_strict, uint, 0644);
-MODULE_PARM_DESC(acpi_pstate_strict,
-        "value 0 or non-zero. non-zero -> strict ACPI checks are "
-        "performed during frequency changes.");
-
-late_initcall(acpi_cpufreq_init);
-module_exit(acpi_cpufreq_exit);
-
-MODULE_ALIAS("acpi");
diff --git a/arch/x86/kernel/cpu/cpufreq/cpufreq-nforce2.c b/arch/x86/kernel/cpu/cpufreq/cpufreq-nforce2.c
deleted file mode 100644
index 141abebc4516..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/cpufreq-nforce2.c
+++ /dev/null
@@ -1,446 +0,0 @@
-/*
- * (C) 2004-2006  Sebastian Witt <se.witt@gmx.net>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *  Based upon reverse engineered information
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/pci.h>
-#include <linux/delay.h>
-
-#define NFORCE2_XTAL 25
-#define NFORCE2_BOOTFSB 0x48
-#define NFORCE2_PLLENABLE 0xa8
-#define NFORCE2_PLLREG 0xa4
-#define NFORCE2_PLLADR 0xa0
-#define NFORCE2_PLL(mul, div) (0x100000 | (mul << 8) | div)
-
-#define NFORCE2_MIN_FSB 50
-#define NFORCE2_SAFE_DISTANCE 50
-
-/* Delay in ms between FSB changes */
-/* #define NFORCE2_DELAY 10 */
-
-/*
- * nforce2_chipset:
- * FSB is changed using the chipset
- */
-static struct pci_dev *nforce2_dev;
-
-/* fid:
- * multiplier * 10
- */
-static int fid;
-
-/* min_fsb, max_fsb:
- * minimum and maximum FSB (= FSB at boot time)
- */
-static int min_fsb;
-static int max_fsb;
-
-MODULE_AUTHOR("Sebastian Witt <se.witt@gmx.net>");
-MODULE_DESCRIPTION("nForce2 FSB changing cpufreq driver");
-MODULE_LICENSE("GPL");
-
-module_param(fid, int, 0444);
-module_param(min_fsb, int, 0444);
-
-MODULE_PARM_DESC(fid, "CPU multiplier to use (11.5 = 115)");
-MODULE_PARM_DESC(min_fsb,
-                "Minimum FSB to use, if not defined: current FSB - 50");
-
-#define PFX "cpufreq-nforce2: "
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "cpufreq-nforce2", msg)
-
-/**
- * nforce2_calc_fsb - calculate FSB
- * @pll: PLL value
- *
- *   Calculates FSB from PLL value
- */
-static int nforce2_calc_fsb(int pll)
-{
-        unsigned char mul, div;
-
-        mul = (pll >> 8) & 0xff;
-        div = pll & 0xff;
-
-        if (div > 0)
-                return NFORCE2_XTAL * mul / div;
-
-        return 0;
-}
-
-/**
- * nforce2_calc_pll - calculate PLL value
- * @fsb: FSB
- *
- *   Calculate PLL value for given FSB
- */
-static int nforce2_calc_pll(unsigned int fsb)
-{
-        unsigned char xmul, xdiv;
-        unsigned char mul = 0, div = 0;
-        int tried = 0;
-
-        /* Try to calculate multiplier and divider up to 4 times */
-        while (((mul == 0) || (div == 0)) && (tried <= 3)) {
-                for (xdiv = 2; xdiv <= 0x80; xdiv++)
-                        for (xmul = 1; xmul <= 0xfe; xmul++)
-                                if (nforce2_calc_fsb(NFORCE2_PLL(xmul, xdiv)) ==
-                                    fsb + tried) {
-                                        mul = xmul;
-                                        div = xdiv;
-                                }
-                tried++;
-        }
-
-        if ((mul == 0) || (div == 0))
-                return -1;
-
-        return NFORCE2_PLL(mul, div);
-}
-
-/**
- * nforce2_write_pll - write PLL value to chipset
- * @pll: PLL value
- *
- *   Writes new FSB PLL value to chipset
- */
-static void nforce2_write_pll(int pll)
-{
-        int temp;
-
-        /* Set the pll addr. to 0x00 */
-        pci_write_config_dword(nforce2_dev, NFORCE2_PLLADR, 0);
-
-        /* Now write the value in all 64 registers */
-        for (temp = 0; temp <= 0x3f; temp++)
-                pci_write_config_dword(nforce2_dev, NFORCE2_PLLREG, pll);
-
-        return;
-}
-
-/**
- * nforce2_fsb_read - Read FSB
- *
- *   Read FSB from chipset
- *   If bootfsb != 0, return FSB at boot-time
- */
-static unsigned int nforce2_fsb_read(int bootfsb)
-{
-        struct pci_dev *nforce2_sub5;
-        u32 fsb, temp = 0;
-
-        /* Get chipset boot FSB from subdevice 5 (FSB at boot-time) */
-        nforce2_sub5 = pci_get_subsys(PCI_VENDOR_ID_NVIDIA, 0x01EF,
-                                PCI_ANY_ID, PCI_ANY_ID, NULL);
-        if (!nforce2_sub5)
-                return 0;
-
-        pci_read_config_dword(nforce2_sub5, NFORCE2_BOOTFSB, &fsb);
-        fsb /= 1000000;
-
-        /* Check if PLL register is already set */
-        pci_read_config_byte(nforce2_dev, NFORCE2_PLLENABLE, (u8 *)&temp);
-
-        if (bootfsb || !temp)
-                return fsb;
-
-        /* Use PLL register FSB value */
-        pci_read_config_dword(nforce2_dev, NFORCE2_PLLREG, &temp);
-        fsb = nforce2_calc_fsb(temp);
-
-        return fsb;
-}
-
-/**
- * nforce2_set_fsb - set new FSB
- * @fsb: New FSB
- *
- *   Sets new FSB
- */
-static int nforce2_set_fsb(unsigned int fsb)
-{
-        u32 temp = 0;
-        unsigned int tfsb;
-        int diff;
-        int pll = 0;
-
-        if ((fsb > max_fsb) || (fsb < NFORCE2_MIN_FSB)) {
-                printk(KERN_ERR PFX "FSB %d is out of range!\n", fsb);
-                return -EINVAL;
-        }
-
-        tfsb = nforce2_fsb_read(0);
-        if (!tfsb) {
-                printk(KERN_ERR PFX "Error while reading the FSB\n");
-                return -EINVAL;
-        }
-
-        /* First write? Then set actual value */
-        pci_read_config_byte(nforce2_dev, NFORCE2_PLLENABLE, (u8 *)&temp);
-        if (!temp) {
-                pll = nforce2_calc_pll(tfsb);
-
-                if (pll < 0)
-                        return -EINVAL;
-
-                nforce2_write_pll(pll);
-        }
-
-        /* Enable write access */
-        temp = 0x01;
-        pci_write_config_byte(nforce2_dev, NFORCE2_PLLENABLE, (u8)temp);
-
-        diff = tfsb - fsb;
-
-        if (!diff)
-                return 0;
-
-        while ((tfsb != fsb) && (tfsb <= max_fsb) && (tfsb >= min_fsb)) {
-                if (diff < 0)
-                        tfsb++;
-                else
-                        tfsb--;
-
-                /* Calculate the PLL reg. value */
-                pll = nforce2_calc_pll(tfsb);
-                if (pll == -1)
-                        return -EINVAL;
-
-                nforce2_write_pll(pll);
-#ifdef NFORCE2_DELAY
-                mdelay(NFORCE2_DELAY);
-#endif
-        }
-
-        temp = 0x40;
-        pci_write_config_byte(nforce2_dev, NFORCE2_PLLADR, (u8)temp);
-
-        return 0;
-}
-
-/**
- * nforce2_get - get the CPU frequency
- * @cpu: CPU number
- *
- * Returns the CPU frequency
- */
-static unsigned int nforce2_get(unsigned int cpu)
-{
-        if (cpu)
-                return 0;
-        return nforce2_fsb_read(0) * fid * 100;
-}
-
-/**
- * nforce2_target - set a new CPUFreq policy
- * @policy: new policy
- * @target_freq: the target frequency
- * @relation: how that frequency relates to achieved frequency
- *  (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H)
- *
- * Sets a new CPUFreq policy.
- */
-static int nforce2_target(struct cpufreq_policy *policy,
-                          unsigned int target_freq, unsigned int relation)
-{
-/*        unsigned long         flags; */
-        struct cpufreq_freqs freqs;
-        unsigned int target_fsb;
-
-        if ((target_freq > policy->max) || (target_freq < policy->min))
-                return -EINVAL;
-
-        target_fsb = target_freq / (fid * 100);
-
-        freqs.old = nforce2_get(policy->cpu);
-        freqs.new = target_fsb * fid * 100;
-        freqs.cpu = 0;          /* Only one CPU on nForce2 platforms */
-
-        if (freqs.old == freqs.new)
-                return 0;
-
-        dprintk("Old CPU frequency %d kHz, new %d kHz\n",
-               freqs.old, freqs.new);
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        /* Disable IRQs */
-        /* local_irq_save(flags); */
-
-        if (nforce2_set_fsb(target_fsb) < 0)
-                printk(KERN_ERR PFX "Changing FSB to %d failed\n",
-                        target_fsb);
-        else
-                dprintk("Changed FSB successfully to %d\n",
-                        target_fsb);
-
-        /* Enable IRQs */
-        /* local_irq_restore(flags); */
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-
-        return 0;
-}
-
-/**
- * nforce2_verify - verifies a new CPUFreq policy
- * @policy: new policy
- */
-static int nforce2_verify(struct cpufreq_policy *policy)
-{
-        unsigned int fsb_pol_max;
-
-        fsb_pol_max = policy->max / (fid * 100);
-
-        if (policy->min < (fsb_pol_max * fid * 100))
-                policy->max = (fsb_pol_max + 1) * fid * 100;
-
-        cpufreq_verify_within_limits(policy,
-                                     policy->cpuinfo.min_freq,
-                                     policy->cpuinfo.max_freq);
-        return 0;
-}
-
-static int nforce2_cpu_init(struct cpufreq_policy *policy)
-{
-        unsigned int fsb;
-        unsigned int rfid;
-
-        /* capability check */
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        /* Get current FSB */
-        fsb = nforce2_fsb_read(0);
-
-        if (!fsb)
-                return -EIO;
-
-        /* FIX: Get FID from CPU */
-        if (!fid) {
-                if (!cpu_khz) {
-                        printk(KERN_WARNING PFX
-                        "cpu_khz not set, can't calculate multiplier!\n");
-                        return -ENODEV;
-                }
-
-                fid = cpu_khz / (fsb * 100);
-                rfid = fid % 5;
-
-                if (rfid) {
-                        if (rfid > 2)
-                                fid += 5 - rfid;
-                        else
-                                fid -= rfid;
-                }
-        }
-
-        printk(KERN_INFO PFX "FSB currently at %i MHz, FID %d.%d\n", fsb,
-               fid / 10, fid % 10);
-
-        /* Set maximum FSB to FSB at boot time */
-        max_fsb = nforce2_fsb_read(1);
-
-        if (!max_fsb)
-                return -EIO;
-
-        if (!min_fsb)
-                min_fsb = max_fsb - NFORCE2_SAFE_DISTANCE;
-
-        if (min_fsb < NFORCE2_MIN_FSB)
-                min_fsb = NFORCE2_MIN_FSB;
-
-        /* cpuinfo and default policy values */
-        policy->cpuinfo.min_freq = min_fsb * fid * 100;
-        policy->cpuinfo.max_freq = max_fsb * fid * 100;
-        policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
-        policy->cur = nforce2_get(policy->cpu);
-        policy->min = policy->cpuinfo.min_freq;
-        policy->max = policy->cpuinfo.max_freq;
-
-        return 0;
-}
-
-static int nforce2_cpu_exit(struct cpufreq_policy *policy)
-{
-        return 0;
-}
-
-static struct cpufreq_driver nforce2_driver = {
-        .name = "nforce2",
-        .verify = nforce2_verify,
-        .target = nforce2_target,
-        .get = nforce2_get,
-        .init = nforce2_cpu_init,
-        .exit = nforce2_cpu_exit,
-        .owner = THIS_MODULE,
-};
-
-/**
- * nforce2_detect_chipset - detect the Southbridge which contains FSB PLL logic
- *
- * Detects nForce2 A2 and C1 stepping
- *
- */
-static int nforce2_detect_chipset(void)
-{
-        nforce2_dev = pci_get_subsys(PCI_VENDOR_ID_NVIDIA,
-                                        PCI_DEVICE_ID_NVIDIA_NFORCE2,
-                                        PCI_ANY_ID, PCI_ANY_ID, NULL);
-
-        if (nforce2_dev == NULL)
-                return -ENODEV;
-
-        printk(KERN_INFO PFX "Detected nForce2 chipset revision %X\n",
-               nforce2_dev->revision);
-        printk(KERN_INFO PFX
-               "FSB changing is maybe unstable and can lead to "
-               "crashes and data loss.\n");
-
-        return 0;
-}
-
-/**
- * nforce2_init - initializes the nForce2 CPUFreq driver
- *
- * Initializes the nForce2 FSB support. Returns -ENODEV on unsupported
- * devices, -EINVAL on problems during initiatization, and zero on
- * success.
- */
-static int __init nforce2_init(void)
-{
-        /* TODO: do we need to detect the processor? */
-
-        /* detect chipset */
-        if (nforce2_detect_chipset()) {
-                printk(KERN_INFO PFX "No nForce2 chipset.\n");
-                return -ENODEV;
-        }
-
-        return cpufreq_register_driver(&nforce2_driver);
-}
-
-/**
- * nforce2_exit - unregisters cpufreq module
- *
- *   Unregisters nForce2 FSB change support.
- */
-static void __exit nforce2_exit(void)
-{
-        cpufreq_unregister_driver(&nforce2_driver);
-}
-
-module_init(nforce2_init);
-module_exit(nforce2_exit);
-
diff --git a/arch/x86/kernel/cpu/cpufreq/e_powersaver.c b/arch/x86/kernel/cpu/cpufreq/e_powersaver.c
deleted file mode 100644
index 35a257dd4bb7..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/e_powersaver.c
+++ /dev/null
@@ -1,367 +0,0 @@
-/*
- *  Based on documentation provided by Dave Jones. Thanks!
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/ioport.h>
-#include <linux/slab.h>
-#include <linux/timex.h>
-#include <linux/io.h>
-#include <linux/delay.h>
-
-#include <asm/msr.h>
-#include <asm/tsc.h>
-
-#define EPS_BRAND_C7M   0
-#define EPS_BRAND_C7    1
-#define EPS_BRAND_EDEN  2
-#define EPS_BRAND_C3    3
-#define EPS_BRAND_C7D   4
-
-struct eps_cpu_data {
-        u32 fsb;
-        struct cpufreq_frequency_table freq_table[];
-};
-
-static struct eps_cpu_data *eps_cpu[NR_CPUS];
-
-
-static unsigned int eps_get(unsigned int cpu)
-{
-        struct eps_cpu_data *centaur;
-        u32 lo, hi;
-
-        if (cpu)
-                return 0;
-        centaur = eps_cpu[cpu];
-        if (centaur == NULL)
-                return 0;
-
-        /* Return current frequency */
-        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-        return centaur->fsb * ((lo >> 8) & 0xff);
-}
-
-static int eps_set_state(struct eps_cpu_data *centaur,
-                         unsigned int cpu,
-                         u32 dest_state)
-{
-        struct cpufreq_freqs freqs;
-        u32 lo, hi;
-        int err = 0;
-        int i;
-
-        freqs.old = eps_get(cpu);
-        freqs.new = centaur->fsb * ((dest_state >> 8) & 0xff);
-        freqs.cpu = cpu;
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        /* Wait while CPU is busy */
-        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-        i = 0;
-        while (lo & ((1 << 16) | (1 << 17))) {
-                udelay(16);
-                rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-                i++;
-                if (unlikely(i > 64)) {
-                        err = -ENODEV;
-                        goto postchange;
-                }
-        }
-        /* Set new multiplier and voltage */
-        wrmsr(MSR_IA32_PERF_CTL, dest_state & 0xffff, 0);
-        /* Wait until transition end */
-        i = 0;
-        do {
-                udelay(16);
-                rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-                i++;
-                if (unlikely(i > 64)) {
-                        err = -ENODEV;
-                        goto postchange;
-                }
-        } while (lo & ((1 << 16) | (1 << 17)));
-
-        /* Return current frequency */
-postchange:
-        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-        freqs.new = centaur->fsb * ((lo >> 8) & 0xff);
-
-#ifdef DEBUG
-        {
-        u8 current_multiplier, current_voltage;
-
-        /* Print voltage and multiplier */
-        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-        current_voltage = lo & 0xff;
-        printk(KERN_INFO "eps: Current voltage = %dmV\n",
-                current_voltage * 16 + 700);
-        current_multiplier = (lo >> 8) & 0xff;
-        printk(KERN_INFO "eps: Current multiplier = %d\n",
-                current_multiplier);
-        }
-#endif
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        return err;
-}
-
-static int eps_target(struct cpufreq_policy *policy,
-                               unsigned int target_freq,
-                               unsigned int relation)
-{
-        struct eps_cpu_data *centaur;
-        unsigned int newstate = 0;
-        unsigned int cpu = policy->cpu;
-        unsigned int dest_state;
-        int ret;
-
-        if (unlikely(eps_cpu[cpu] == NULL))
-                return -ENODEV;
-        centaur = eps_cpu[cpu];
-
-        if (unlikely(cpufreq_frequency_table_target(policy,
-                        &eps_cpu[cpu]->freq_table[0],
-                        target_freq,
-                        relation,
-                        &newstate))) {
-                return -EINVAL;
-        }
-
-        /* Make frequency transition */
-        dest_state = centaur->freq_table[newstate].index & 0xffff;
-        ret = eps_set_state(centaur, cpu, dest_state);
-        if (ret)
-                printk(KERN_ERR "eps: Timeout!\n");
-        return ret;
-}
-
-static int eps_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy,
-                        &eps_cpu[policy->cpu]->freq_table[0]);
-}
-
-static int eps_cpu_init(struct cpufreq_policy *policy)
-{
-        unsigned int i;
-        u32 lo, hi;
-        u64 val;
-        u8 current_multiplier, current_voltage;
-        u8 max_multiplier, max_voltage;
-        u8 min_multiplier, min_voltage;
-        u8 brand = 0;
-        u32 fsb;
-        struct eps_cpu_data *centaur;
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        struct cpufreq_frequency_table *f_table;
-        int k, step, voltage;
-        int ret;
-        int states;
-
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        /* Check brand */
-        printk(KERN_INFO "eps: Detected VIA ");
-
-        switch (c->x86_model) {
-        case 10:
-                rdmsr(0x1153, lo, hi);
-                brand = (((lo >> 2) ^ lo) >> 18) & 3;
-                printk(KERN_CONT "Model A ");
-                break;
-        case 13:
-                rdmsr(0x1154, lo, hi);
-                brand = (((lo >> 4) ^ (lo >> 2))) & 0x000000ff;
-                printk(KERN_CONT "Model D ");
-                break;
-        }
-
-        switch (brand) {
-        case EPS_BRAND_C7M:
-                printk(KERN_CONT "C7-M\n");
-                break;
-        case EPS_BRAND_C7:
-                printk(KERN_CONT "C7\n");
-                break;
-        case EPS_BRAND_EDEN:
-                printk(KERN_CONT "Eden\n");
-                break;
-        case EPS_BRAND_C7D:
-                printk(KERN_CONT "C7-D\n");
-                break;
-        case EPS_BRAND_C3:
-                printk(KERN_CONT "C3\n");
-                return -ENODEV;
-                break;
-        }
-        /* Enable Enhanced PowerSaver */
-        rdmsrl(MSR_IA32_MISC_ENABLE, val);
-        if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
-                val |= MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP;
-                wrmsrl(MSR_IA32_MISC_ENABLE, val);
-                /* Can be locked at 0 */
-                rdmsrl(MSR_IA32_MISC_ENABLE, val);
-                if (!(val & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
-                        printk(KERN_INFO "eps: Can't enable Enhanced PowerSaver\n");
-                        return -ENODEV;
-                }
-        }
-
-        /* Print voltage and multiplier */
-        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-        current_voltage = lo & 0xff;
-        printk(KERN_INFO "eps: Current voltage = %dmV\n",
-                        current_voltage * 16 + 700);
-        current_multiplier = (lo >> 8) & 0xff;
-        printk(KERN_INFO "eps: Current multiplier = %d\n", current_multiplier);
-
-        /* Print limits */
-        max_voltage = hi & 0xff;
-        printk(KERN_INFO "eps: Highest voltage = %dmV\n",
-                        max_voltage * 16 + 700);
-        max_multiplier = (hi >> 8) & 0xff;
-        printk(KERN_INFO "eps: Highest multiplier = %d\n", max_multiplier);
-        min_voltage = (hi >> 16) & 0xff;
-        printk(KERN_INFO "eps: Lowest voltage = %dmV\n",
-                        min_voltage * 16 + 700);
-        min_multiplier = (hi >> 24) & 0xff;
-        printk(KERN_INFO "eps: Lowest multiplier = %d\n", min_multiplier);
-
-        /* Sanity checks */
-        if (current_multiplier == 0 || max_multiplier == 0
-            || min_multiplier == 0)
-                return -EINVAL;
-        if (current_multiplier > max_multiplier
-            || max_multiplier <= min_multiplier)
-                return -EINVAL;
-        if (current_voltage > 0x1f || max_voltage > 0x1f)
-                return -EINVAL;
-        if (max_voltage < min_voltage)
-                return -EINVAL;
-
-        /* Calc FSB speed */
-        fsb = cpu_khz / current_multiplier;
-        /* Calc number of p-states supported */
-        if (brand == EPS_BRAND_C7M)
-                states = max_multiplier - min_multiplier + 1;
-        else
-                states = 2;
-
-        /* Allocate private data and frequency table for current cpu */
-        centaur = kzalloc(sizeof(struct eps_cpu_data)
-                    + (states + 1) * sizeof(struct cpufreq_frequency_table),
-                    GFP_KERNEL);
-        if (!centaur)
-                return -ENOMEM;
-        eps_cpu[0] = centaur;
-
-        /* Copy basic values */
-        centaur->fsb = fsb;
-
-        /* Fill frequency and MSR value table */
-        f_table = &centaur->freq_table[0];
-        if (brand != EPS_BRAND_C7M) {
-                f_table[0].frequency = fsb * min_multiplier;
-                f_table[0].index = (min_multiplier << 8) | min_voltage;
-                f_table[1].frequency = fsb * max_multiplier;
-                f_table[1].index = (max_multiplier << 8) | max_voltage;
-                f_table[2].frequency = CPUFREQ_TABLE_END;
-        } else {
-                k = 0;
-                step = ((max_voltage - min_voltage) * 256)
-                        / (max_multiplier - min_multiplier);
-                for (i = min_multiplier; i <= max_multiplier; i++) {
-                        voltage = (k * step) / 256 + min_voltage;
-                        f_table[k].frequency = fsb * i;
-                        f_table[k].index = (i << 8) | voltage;
-                        k++;
-                }
-                f_table[k].frequency = CPUFREQ_TABLE_END;
-        }
-
-        policy->cpuinfo.transition_latency = 140000; /* 844mV -> 700mV in ns */
-        policy->cur = fsb * current_multiplier;
-
-        ret = cpufreq_frequency_table_cpuinfo(policy, &centaur->freq_table[0]);
-        if (ret) {
-                kfree(centaur);
-                return ret;
-        }
-
-        cpufreq_frequency_table_get_attr(&centaur->freq_table[0], policy->cpu);
-        return 0;
-}
-
-static int eps_cpu_exit(struct cpufreq_policy *policy)
-{
-        unsigned int cpu = policy->cpu;
-        struct eps_cpu_data *centaur;
-        u32 lo, hi;
-
-        if (eps_cpu[cpu] == NULL)
-                return -ENODEV;
-        centaur = eps_cpu[cpu];
-
-        /* Get max frequency */
-        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-        /* Set max frequency */
-        eps_set_state(centaur, cpu, hi & 0xffff);
-        /* Bye */
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        kfree(eps_cpu[cpu]);
-        eps_cpu[cpu] = NULL;
-        return 0;
-}
-
-static struct freq_attr *eps_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver eps_driver = {
-        .verify         = eps_verify,
-        .target         = eps_target,
-        .init           = eps_cpu_init,
-        .exit           = eps_cpu_exit,
-        .get            = eps_get,
-        .name           = "e_powersaver",
-        .owner          = THIS_MODULE,
-        .attr           = eps_attr,
-};
-
-static int __init eps_init(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-
-        /* This driver will work only on Centaur C7 processors with
-         * Enhanced SpeedStep/PowerSaver registers */
-        if (c->x86_vendor != X86_VENDOR_CENTAUR
-            || c->x86 != 6 || c->x86_model < 10)
-                return -ENODEV;
-        if (!cpu_has(c, X86_FEATURE_EST))
-                return -ENODEV;
-
-        if (cpufreq_register_driver(&eps_driver))
-                return -EINVAL;
-        return 0;
-}
-
-static void __exit eps_exit(void)
-{
-        cpufreq_unregister_driver(&eps_driver);
-}
-
-MODULE_AUTHOR("Rafal Bilski <rafalbilski@interia.pl>");
-MODULE_DESCRIPTION("Enhanced PowerSaver driver for VIA C7 CPU's.");
-MODULE_LICENSE("GPL");
-
-module_init(eps_init);
-module_exit(eps_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/elanfreq.c b/arch/x86/kernel/cpu/cpufreq/elanfreq.c
deleted file mode 100644
index c587db472a75..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/elanfreq.c
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- *      elanfreq:       cpufreq driver for the AMD ELAN family
- *
- *      (c) Copyright 2002 Robert Schwebel <r.schwebel@pengutronix.de>
- *
- *      Parts of this code are (c) Sven Geggus <sven@geggus.net>
- *
- *      All Rights Reserved.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- *      2002-02-13: - initial revision for 2.4.18-pre9 by Robert Schwebel
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-
-#include <linux/delay.h>
-#include <linux/cpufreq.h>
-
-#include <asm/msr.h>
-#include <linux/timex.h>
-#include <linux/io.h>
-
-#define REG_CSCIR 0x22          /* Chip Setup and Control Index Register    */
-#define REG_CSCDR 0x23          /* Chip Setup and Control Data  Register    */
-
-/* Module parameter */
-static int max_freq;
-
-struct s_elan_multiplier {
-        int clock;              /* frequency in kHz                         */
-        int val40h;             /* PMU Force Mode register                  */
-        int val80h;             /* CPU Clock Speed Register                 */
-};
-
-/*
- * It is important that the frequencies
- * are listed in ascending order here!
- */
-static struct s_elan_multiplier elan_multiplier[] = {
-        {1000,  0x02,   0x18},
-        {2000,  0x02,   0x10},
-        {4000,  0x02,   0x08},
-        {8000,  0x00,   0x00},
-        {16000, 0x00,   0x02},
-        {33000, 0x00,   0x04},
-        {66000, 0x01,   0x04},
-        {99000, 0x01,   0x05}
-};
-
-static struct cpufreq_frequency_table elanfreq_table[] = {
-        {0,     1000},
-        {1,     2000},
-        {2,     4000},
-        {3,     8000},
-        {4,     16000},
-        {5,     33000},
-        {6,     66000},
-        {7,     99000},
-        {0,     CPUFREQ_TABLE_END},
-};
-
-
-/**
- *      elanfreq_get_cpu_frequency: determine current cpu speed
- *
- *      Finds out at which frequency the CPU of the Elan SOC runs
- *      at the moment. Frequencies from 1 to 33 MHz are generated
- *      the normal way, 66 and 99 MHz are called "Hyperspeed Mode"
- *      and have the rest of the chip running with 33 MHz.
- */
-
-static unsigned int elanfreq_get_cpu_frequency(unsigned int cpu)
-{
-        u8 clockspeed_reg;    /* Clock Speed Register */
-
-        local_irq_disable();
-        outb_p(0x80, REG_CSCIR);
-        clockspeed_reg = inb_p(REG_CSCDR);
-        local_irq_enable();
-
-        if ((clockspeed_reg & 0xE0) == 0xE0)
-                return 0;
-
-        /* Are we in CPU clock multiplied mode (66/99 MHz)? */
-        if ((clockspeed_reg & 0xE0) == 0xC0) {
-                if ((clockspeed_reg & 0x01) == 0)
-                        return 66000;
-                else
-                        return 99000;
-        }
-
-        /* 33 MHz is not 32 MHz... */
-        if ((clockspeed_reg & 0xE0) == 0xA0)
-                return 33000;
-
-        return (1<<((clockspeed_reg & 0xE0) >> 5)) * 1000;
-}
-
-
-/**
- *      elanfreq_set_cpu_frequency: Change the CPU core frequency
- *      @cpu: cpu number
- *      @freq: frequency in kHz
- *
- *      This function takes a frequency value and changes the CPU frequency
- *      according to this. Note that the frequency has to be checked by
- *      elanfreq_validatespeed() for correctness!
- *
- *      There is no return value.
- */
-
-static void elanfreq_set_cpu_state(unsigned int state)
-{
-        struct cpufreq_freqs    freqs;
-
-        freqs.old = elanfreq_get_cpu_frequency(0);
-        freqs.new = elan_multiplier[state].clock;
-        freqs.cpu = 0; /* elanfreq.c is UP only driver */
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        printk(KERN_INFO "elanfreq: attempting to set frequency to %i kHz\n",
-                        elan_multiplier[state].clock);
-
-
-        /*
-         * Access to the Elan's internal registers is indexed via
-         * 0x22: Chip Setup & Control Register Index Register (CSCI)
-         * 0x23: Chip Setup & Control Register Data  Register (CSCD)
-         *
-         */
-
-        /*
-         * 0x40 is the Power Management Unit's Force Mode Register.
-         * Bit 6 enables Hyperspeed Mode (66/100 MHz core frequency)
-         */
-
-        local_irq_disable();
-        outb_p(0x40, REG_CSCIR);                /* Disable hyperspeed mode */
-        outb_p(0x00, REG_CSCDR);
-        local_irq_enable();             /* wait till internal pipelines and */
-        udelay(1000);                   /* buffers have cleaned up          */
-
-        local_irq_disable();
-
-        /* now, set the CPU clock speed register (0x80) */
-        outb_p(0x80, REG_CSCIR);
-        outb_p(elan_multiplier[state].val80h, REG_CSCDR);
-
-        /* now, the hyperspeed bit in PMU Force Mode Register (0x40) */
-        outb_p(0x40, REG_CSCIR);
-        outb_p(elan_multiplier[state].val40h, REG_CSCDR);
-        udelay(10000);
-        local_irq_enable();
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-};
-
-
-/**
- *      elanfreq_validatespeed: test if frequency range is valid
- *      @policy: the policy to validate
- *
- *      This function checks if a given frequency range in kHz is valid
- *      for the hardware supported by the driver.
- */
-
-static int elanfreq_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, &elanfreq_table[0]);
-}
-
-static int elanfreq_target(struct cpufreq_policy *policy,
-                            unsigned int target_freq,
-                            unsigned int relation)
-{
-        unsigned int newstate = 0;
-
-        if (cpufreq_frequency_table_target(policy, &elanfreq_table[0],
-                                target_freq, relation, &newstate))
-                return -EINVAL;
-
-        elanfreq_set_cpu_state(newstate);
-
-        return 0;
-}
-
-
-/*
- *      Module init and exit code
- */
-
-static int elanfreq_cpu_init(struct cpufreq_policy *policy)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        unsigned int i;
-        int result;
-
-        /* capability check */
-        if ((c->x86_vendor != X86_VENDOR_AMD) ||
-            (c->x86 != 4) || (c->x86_model != 10))
-                return -ENODEV;
-
-        /* max freq */
-        if (!max_freq)
-                max_freq = elanfreq_get_cpu_frequency(0);
-
-        /* table init */
-        for (i = 0; (elanfreq_table[i].frequency != CPUFREQ_TABLE_END); i++) {
-                if (elanfreq_table[i].frequency > max_freq)
-                        elanfreq_table[i].frequency = CPUFREQ_ENTRY_INVALID;
-        }
-
-        /* cpuinfo and default policy values */
-        policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
-        policy->cur = elanfreq_get_cpu_frequency(0);
-
-        result = cpufreq_frequency_table_cpuinfo(policy, elanfreq_table);
-        if (result)
-                return result;
-
-        cpufreq_frequency_table_get_attr(elanfreq_table, policy->cpu);
-        return 0;
-}
-
-
-static int elanfreq_cpu_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
-
-#ifndef MODULE
-/**
- * elanfreq_setup - elanfreq command line parameter parsing
- *
- * elanfreq command line parameter.  Use:
- *  elanfreq=66000
- * to set the maximum CPU frequency to 66 MHz. Note that in
- * case you do not give this boot parameter, the maximum
- * frequency will fall back to _current_ CPU frequency which
- * might be lower. If you build this as a module, use the
- * max_freq module parameter instead.
- */
-static int __init elanfreq_setup(char *str)
-{
-        max_freq = simple_strtoul(str, &str, 0);
-        printk(KERN_WARNING "You're using the deprecated elanfreq command line option. Use elanfreq.max_freq instead, please!\n");
-        return 1;
-}
-__setup("elanfreq=", elanfreq_setup);
-#endif
-
-
-static struct freq_attr *elanfreq_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-
-static struct cpufreq_driver elanfreq_driver = {
-        .get            = elanfreq_get_cpu_frequency,
-        .verify         = elanfreq_verify,
-        .target         = elanfreq_target,
-        .init           = elanfreq_cpu_init,
-        .exit           = elanfreq_cpu_exit,
-        .name           = "elanfreq",
-        .owner          = THIS_MODULE,
-        .attr           = elanfreq_attr,
-};
-
-
-static int __init elanfreq_init(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-
-        /* Test if we have the right hardware */
-        if ((c->x86_vendor != X86_VENDOR_AMD) ||
-                (c->x86 != 4) || (c->x86_model != 10)) {
-                printk(KERN_INFO "elanfreq: error: no Elan processor found!\n");
-                return -ENODEV;
-        }
-        return cpufreq_register_driver(&elanfreq_driver);
-}
-
-
-static void __exit elanfreq_exit(void)
-{
-        cpufreq_unregister_driver(&elanfreq_driver);
-}
-
-
-module_param(max_freq, int, 0444);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Robert Schwebel <r.schwebel@pengutronix.de>, "
-                "Sven Geggus <sven@geggus.net>");
-MODULE_DESCRIPTION("cpufreq driver for AMD's Elan CPUs");
-
-module_init(elanfreq_init);
-module_exit(elanfreq_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/gx-suspmod.c b/arch/x86/kernel/cpu/cpufreq/gx-suspmod.c
deleted file mode 100644
index 32974cf84232..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/gx-suspmod.c
+++ /dev/null
@@ -1,517 +0,0 @@
-/*
- *      Cyrix MediaGX and NatSemi Geode Suspend Modulation
- *      (C) 2002 Zwane Mwaikambo <zwane@commfireservices.com>
- *      (C) 2002 Hiroshi Miura   <miura@da-cha.org>
- *      All Rights Reserved
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      version 2 as published by the Free Software Foundation
- *
- *      The author(s) of this software shall not be held liable for damages
- *      of any nature resulting due to the use of this software. This
- *      software is provided AS-IS with no warranties.
- *
- * Theoretical note:
- *
- *      (see Geode(tm) CS5530 manual (rev.4.1) page.56)
- *
- *      CPU frequency control on NatSemi Geode GX1/GXLV processor and CS55x0
- *      are based on Suspend Modulation.
- *
- *      Suspend Modulation works by asserting and de-asserting the SUSP# pin
- *      to CPU(GX1/GXLV) for configurable durations. When asserting SUSP#
- *      the CPU enters an idle state. GX1 stops its core clock when SUSP# is
- *      asserted then power consumption is reduced.
- *
- *      Suspend Modulation's OFF/ON duration are configurable
- *      with 'Suspend Modulation OFF Count Register'
- *      and 'Suspend Modulation ON Count Register'.
- *      These registers are 8bit counters that represent the number of
- *      32us intervals which the SUSP# pin is asserted(ON)/de-asserted(OFF)
- *      to the processor.
- *
- *      These counters define a ratio which is the effective frequency
- *      of operation of the system.
- *
- *                             OFF Count
- *      F_eff = Fgx * ----------------------
- *                      OFF Count + ON Count
- *
- *      0 <= On Count, Off Count <= 255
- *
- *      From these limits, we can get register values
- *
- *      off_duration + on_duration <= MAX_DURATION
- *      on_duration = off_duration * (stock_freq - freq) / freq
- *
- *      off_duration  =  (freq * DURATION) / stock_freq
- *      on_duration = DURATION - off_duration
- *
- *
- *---------------------------------------------------------------------------
- *
- * ChangeLog:
- *      Dec. 12, 2003   Hiroshi Miura <miura@da-cha.org>
- *              - fix on/off register mistake
- *              - fix cpu_khz calc when it stops cpu modulation.
- *
- *      Dec. 11, 2002   Hiroshi Miura <miura@da-cha.org>
- *              - rewrite for Cyrix MediaGX Cx5510/5520 and
- *                NatSemi Geode Cs5530(A).
- *
- *      Jul. ??, 2002  Zwane Mwaikambo <zwane@commfireservices.com>
- *              - cs5530_mod patch for 2.4.19-rc1.
- *
- *---------------------------------------------------------------------------
- *
- * Todo
- *      Test on machines with 5510, 5530, 5530A
- */
-
-/************************************************************************
- *                      Suspend Modulation - Definitions                *
- ************************************************************************/
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/smp.h>
-#include <linux/cpufreq.h>
-#include <linux/pci.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-
-#include <asm/processor-cyrix.h>
-
-/* PCI config registers, all at F0 */
-#define PCI_PMER1       0x80    /* power management enable register 1 */
-#define PCI_PMER2       0x81    /* power management enable register 2 */
-#define PCI_PMER3       0x82    /* power management enable register 3 */
-#define PCI_IRQTC       0x8c    /* irq speedup timer counter register:typical 2 to 4ms */
-#define PCI_VIDTC       0x8d    /* video speedup timer counter register: typical 50 to 100ms */
-#define PCI_MODOFF      0x94    /* suspend modulation OFF counter register, 1 = 32us */
-#define PCI_MODON       0x95    /* suspend modulation ON counter register */
-#define PCI_SUSCFG      0x96    /* suspend configuration register */
-
-/* PMER1 bits */
-#define GPM             (1<<0)  /* global power management */
-#define GIT             (1<<1)  /* globally enable PM device idle timers */
-#define GTR             (1<<2)  /* globally enable IO traps */
-#define IRQ_SPDUP       (1<<3)  /* disable clock throttle during interrupt handling */
-#define VID_SPDUP       (1<<4)  /* disable clock throttle during vga video handling */
-
-/* SUSCFG bits */
-#define SUSMOD          (1<<0)  /* enable/disable suspend modulation */
-/* the below is supported only with cs5530 (after rev.1.2)/cs5530A */
-#define SMISPDUP        (1<<1)  /* select how SMI re-enable suspend modulation: */
-                                /* IRQTC timer or read SMI speedup disable reg.(F1BAR[08-09h]) */
-#define SUSCFG          (1<<2)  /* enable powering down a GXLV processor. "Special 3Volt Suspend" mode */
-/* the below is supported only with cs5530A */
-#define PWRSVE_ISA      (1<<3)  /* stop ISA clock  */
-#define PWRSVE          (1<<4)  /* active idle */
-
-struct gxfreq_params {
-        u8 on_duration;
-        u8 off_duration;
-        u8 pci_suscfg;
-        u8 pci_pmer1;
-        u8 pci_pmer2;
-        struct pci_dev *cs55x0;
-};
-
-static struct gxfreq_params *gx_params;
-static int stock_freq;
-
-/* PCI bus clock - defaults to 30.000 if cpu_khz is not available */
-static int pci_busclk;
-module_param(pci_busclk, int, 0444);
-
-/* maximum duration for which the cpu may be suspended
- * (32us * MAX_DURATION). If no parameter is given, this defaults
- * to 255.
- * Note that this leads to a maximum of 8 ms(!) where the CPU clock
- * is suspended -- processing power is just 0.39% of what it used to be,
- * though. 781.25 kHz(!) for a 200 MHz processor -- wow. */
-static int max_duration = 255;
-module_param(max_duration, int, 0444);
-
-/* For the default policy, we want at least some processing power
- * - let's say 5%. (min = maxfreq / POLICY_MIN_DIV)
- */
-#define POLICY_MIN_DIV 20
-
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "gx-suspmod", msg)
-
-/**
- * we can detect a core multipiler from dir0_lsb
- * from GX1 datasheet p.56,
- *      MULT[3:0]:
- *      0000 = SYSCLK multiplied by 4 (test only)
- *      0001 = SYSCLK multiplied by 10
- *      0010 = SYSCLK multiplied by 4
- *      0011 = SYSCLK multiplied by 6
- *      0100 = SYSCLK multiplied by 9
- *      0101 = SYSCLK multiplied by 5
- *      0110 = SYSCLK multiplied by 7
- *      0111 = SYSCLK multiplied by 8
- *              of 33.3MHz
- **/
-static int gx_freq_mult[16] = {
-                4, 10, 4, 6, 9, 5, 7, 8,
-                0, 0, 0, 0, 0, 0, 0, 0
-};
-
-
-/****************************************************************
- *      Low Level chipset interface                             *
- ****************************************************************/
-static struct pci_device_id gx_chipset_tbl[] __initdata = {
-        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5530_LEGACY), },
-        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5520), },
-        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5510), },
-        { 0, },
-};
-
-static void gx_write_byte(int reg, int value)
-{
-        pci_write_config_byte(gx_params->cs55x0, reg, value);
-}
-
-/**
- * gx_detect_chipset:
- *
- **/
-static __init struct pci_dev *gx_detect_chipset(void)
-{
-        struct pci_dev *gx_pci = NULL;
-
-        /* check if CPU is a MediaGX or a Geode. */
-        if ((boot_cpu_data.x86_vendor != X86_VENDOR_NSC) &&
-            (boot_cpu_data.x86_vendor != X86_VENDOR_CYRIX)) {
-                dprintk("error: no MediaGX/Geode processor found!\n");
-                return NULL;
-        }
-
-        /* detect which companion chip is used */
-        for_each_pci_dev(gx_pci) {
-                if ((pci_match_id(gx_chipset_tbl, gx_pci)) != NULL)
-                        return gx_pci;
-        }
-
-        dprintk("error: no supported chipset found!\n");
-        return NULL;
-}
-
-/**
- * gx_get_cpuspeed:
- *
- * Finds out at which efficient frequency the Cyrix MediaGX/NatSemi
- * Geode CPU runs.
- */
-static unsigned int gx_get_cpuspeed(unsigned int cpu)
-{
-        if ((gx_params->pci_suscfg & SUSMOD) == 0)
-                return stock_freq;
-
-        return (stock_freq * gx_params->off_duration)
-                / (gx_params->on_duration + gx_params->off_duration);
-}
-
-/**
- *      gx_validate_speed:
- *      determine current cpu speed
- *
- **/
-
-static unsigned int gx_validate_speed(unsigned int khz, u8 *on_duration,
-                u8 *off_duration)
-{
-        unsigned int i;
-        u8 tmp_on, tmp_off;
-        int old_tmp_freq = stock_freq;
-        int tmp_freq;
-
-        *off_duration = 1;
-        *on_duration = 0;
-
-        for (i = max_duration; i > 0; i--) {
-                tmp_off = ((khz * i) / stock_freq) & 0xff;
-                tmp_on = i - tmp_off;
-                tmp_freq = (stock_freq * tmp_off) / i;
-                /* if this relation is closer to khz, use this. If it's equal,
-                 * prefer it, too - lower latency */
-                if (abs(tmp_freq - khz) <= abs(old_tmp_freq - khz)) {
-                        *on_duration = tmp_on;
-                        *off_duration = tmp_off;
-                        old_tmp_freq = tmp_freq;
-                }
-        }
-
-        return old_tmp_freq;
-}
-
-
-/**
- * gx_set_cpuspeed:
- * set cpu speed in khz.
- **/
-
-static void gx_set_cpuspeed(unsigned int khz)
-{
-        u8 suscfg, pmer1;
-        unsigned int new_khz;
-        unsigned long flags;
-        struct cpufreq_freqs freqs;
-
-        freqs.cpu = 0;
-        freqs.old = gx_get_cpuspeed(0);
-
-        new_khz = gx_validate_speed(khz, &gx_params->on_duration,
-                        &gx_params->off_duration);
-
-        freqs.new = new_khz;
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        local_irq_save(flags);
-
-
-
-        if (new_khz != stock_freq) {
-                /* if new khz == 100% of CPU speed, it is special case */
-                switch (gx_params->cs55x0->device) {
-                case PCI_DEVICE_ID_CYRIX_5530_LEGACY:
-                        pmer1 = gx_params->pci_pmer1 | IRQ_SPDUP | VID_SPDUP;
-                        /* FIXME: need to test other values -- Zwane,Miura */
-                        /* typical 2 to 4ms */
-                        gx_write_byte(PCI_IRQTC, 4);
-                        /* typical 50 to 100ms */
-                        gx_write_byte(PCI_VIDTC, 100);
-                        gx_write_byte(PCI_PMER1, pmer1);
-
-                        if (gx_params->cs55x0->revision < 0x10) {
-                                /* CS5530(rev 1.2, 1.3) */
-                                suscfg = gx_params->pci_suscfg|SUSMOD;
-                        } else {
-                                /* CS5530A,B.. */
-                                suscfg = gx_params->pci_suscfg|SUSMOD|PWRSVE;
-                        }
-                        break;
-                case PCI_DEVICE_ID_CYRIX_5520:
-                case PCI_DEVICE_ID_CYRIX_5510:
-                        suscfg = gx_params->pci_suscfg | SUSMOD;
-                        break;
-                default:
-                        local_irq_restore(flags);
-                        dprintk("fatal: try to set unknown chipset.\n");
-                        return;
-                }
-        } else {
-                suscfg = gx_params->pci_suscfg & ~(SUSMOD);
-                gx_params->off_duration = 0;
-                gx_params->on_duration = 0;
-                dprintk("suspend modulation disabled: cpu runs 100%% speed.\n");
-        }
-
-        gx_write_byte(PCI_MODOFF, gx_params->off_duration);
-        gx_write_byte(PCI_MODON, gx_params->on_duration);
-
-        gx_write_byte(PCI_SUSCFG, suscfg);
-        pci_read_config_byte(gx_params->cs55x0, PCI_SUSCFG, &suscfg);
-
-        local_irq_restore(flags);
-
-        gx_params->pci_suscfg = suscfg;
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-
-        dprintk("suspend modulation w/ duration of ON:%d us, OFF:%d us\n",
-                gx_params->on_duration * 32, gx_params->off_duration * 32);
-        dprintk("suspend modulation w/ clock speed: %d kHz.\n", freqs.new);
-}
-
-/****************************************************************
- *             High level functions                             *
- ****************************************************************/
-
-/*
- *      cpufreq_gx_verify: test if frequency range is valid
- *
- *      This function checks if a given frequency range in kHz is valid
- *      for the hardware supported by the driver.
- */
-
-static int cpufreq_gx_verify(struct cpufreq_policy *policy)
-{
-        unsigned int tmp_freq = 0;
-        u8 tmp1, tmp2;
-
-        if (!stock_freq || !policy)
-                return -EINVAL;
-
-        policy->cpu = 0;
-        cpufreq_verify_within_limits(policy, (stock_freq / max_duration),
-                        stock_freq);
-
-        /* it needs to be assured that at least one supported frequency is
-         * within policy->min and policy->max. If it is not, policy->max
-         * needs to be increased until one freuqency is supported.
-         * policy->min may not be decreased, though. This way we guarantee a
-         * specific processing capacity.
-         */
-        tmp_freq = gx_validate_speed(policy->min, &tmp1, &tmp2);
-        if (tmp_freq < policy->min)
-                tmp_freq += stock_freq / max_duration;
-        policy->min = tmp_freq;
-        if (policy->min > policy->max)
-                policy->max = tmp_freq;
-        tmp_freq = gx_validate_speed(policy->max, &tmp1, &tmp2);
-        if (tmp_freq > policy->max)
-                tmp_freq -= stock_freq / max_duration;
-        policy->max = tmp_freq;
-        if (policy->max < policy->min)
-                policy->max = policy->min;
-        cpufreq_verify_within_limits(policy, (stock_freq / max_duration),
-                        stock_freq);
-
-        return 0;
-}
-
-/*
- *      cpufreq_gx_target:
- *
- */
-static int cpufreq_gx_target(struct cpufreq_policy *policy,
-                             unsigned int target_freq,
-                             unsigned int relation)
-{
-        u8 tmp1, tmp2;
-        unsigned int tmp_freq;
-
-        if (!stock_freq || !policy)
-                return -EINVAL;
-
-        policy->cpu = 0;
-
-        tmp_freq = gx_validate_speed(target_freq, &tmp1, &tmp2);
-        while (tmp_freq < policy->min) {
-                tmp_freq += stock_freq / max_duration;
-                tmp_freq = gx_validate_speed(tmp_freq, &tmp1, &tmp2);
-        }
-        while (tmp_freq > policy->max) {
-                tmp_freq -= stock_freq / max_duration;
-                tmp_freq = gx_validate_speed(tmp_freq, &tmp1, &tmp2);
-        }
-
-        gx_set_cpuspeed(tmp_freq);
-
-        return 0;
-}
-
-static int cpufreq_gx_cpu_init(struct cpufreq_policy *policy)
-{
-        unsigned int maxfreq, curfreq;
-
-        if (!policy || policy->cpu != 0)
-                return -ENODEV;
-
-        /* determine maximum frequency */
-        if (pci_busclk)
-                maxfreq = pci_busclk * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f];
-        else if (cpu_khz)
-                maxfreq = cpu_khz;
-        else
-                maxfreq = 30000 * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f];
-
-        stock_freq = maxfreq;
-        curfreq = gx_get_cpuspeed(0);
-
-        dprintk("cpu max frequency is %d.\n", maxfreq);
-        dprintk("cpu current frequency is %dkHz.\n", curfreq);
-
-        /* setup basic struct for cpufreq API */
-        policy->cpu = 0;
-
-        if (max_duration < POLICY_MIN_DIV)
-                policy->min = maxfreq / max_duration;
-        else
-                policy->min = maxfreq / POLICY_MIN_DIV;
-        policy->max = maxfreq;
-        policy->cur = curfreq;
-        policy->cpuinfo.min_freq = maxfreq / max_duration;
-        policy->cpuinfo.max_freq = maxfreq;
-        policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
-
-        return 0;
-}
-
-/*
- * cpufreq_gx_init:
- *   MediaGX/Geode GX initialize cpufreq driver
- */
-static struct cpufreq_driver gx_suspmod_driver = {
-        .get            = gx_get_cpuspeed,
-        .verify         = cpufreq_gx_verify,
-        .target         = cpufreq_gx_target,
-        .init           = cpufreq_gx_cpu_init,
-        .name           = "gx-suspmod",
-        .owner          = THIS_MODULE,
-};
-
-static int __init cpufreq_gx_init(void)
-{
-        int ret;
-        struct gxfreq_params *params;
-        struct pci_dev *gx_pci;
-
-        /* Test if we have the right hardware */
-        gx_pci = gx_detect_chipset();
-        if (gx_pci == NULL)
-                return -ENODEV;
-
-        /* check whether module parameters are sane */
-        if (max_duration > 0xff)
-                max_duration = 0xff;
-
-        dprintk("geode suspend modulation available.\n");
-
-        params = kzalloc(sizeof(struct gxfreq_params), GFP_KERNEL);
-        if (params == NULL)
-                return -ENOMEM;
-
-        params->cs55x0 = gx_pci;
-        gx_params = params;
-
-        /* keep cs55x0 configurations */
-        pci_read_config_byte(params->cs55x0, PCI_SUSCFG, &(params->pci_suscfg));
-        pci_read_config_byte(params->cs55x0, PCI_PMER1, &(params->pci_pmer1));
-        pci_read_config_byte(params->cs55x0, PCI_PMER2, &(params->pci_pmer2));
-        pci_read_config_byte(params->cs55x0, PCI_MODON, &(params->on_duration));
-        pci_read_config_byte(params->cs55x0, PCI_MODOFF,
-                        &(params->off_duration));
-
-        ret = cpufreq_register_driver(&gx_suspmod_driver);
-        if (ret) {
-                kfree(params);
-                return ret;                   /* register error! */
-        }
-
-        return 0;
-}
-
-static void __exit cpufreq_gx_exit(void)
-{
-        cpufreq_unregister_driver(&gx_suspmod_driver);
-        pci_dev_put(gx_params->cs55x0);
-        kfree(gx_params);
-}
-
-MODULE_AUTHOR("Hiroshi Miura <miura@da-cha.org>");
-MODULE_DESCRIPTION("Cpufreq driver for Cyrix MediaGX and NatSemi Geode");
-MODULE_LICENSE("GPL");
-
-module_init(cpufreq_gx_init);
-module_exit(cpufreq_gx_exit);
-
diff --git a/arch/x86/kernel/cpu/cpufreq/longhaul.c b/arch/x86/kernel/cpu/cpufreq/longhaul.c
deleted file mode 100644
index cf48cdd6907d..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/longhaul.c
+++ /dev/null
@@ -1,1029 +0,0 @@
-/*
- *  (C) 2001-2004  Dave Jones. <davej@redhat.com>
- *  (C) 2002  Padraig Brady. <padraig@antefacto.com>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *  Based upon datasheets & sample CPUs kindly provided by VIA.
- *
- *  VIA have currently 3 different versions of Longhaul.
- *  Version 1 (Longhaul) uses the BCR2 MSR at 0x1147.
- *   It is present only in Samuel 1 (C5A), Samuel 2 (C5B) stepping 0.
- *  Version 2 of longhaul is backward compatible with v1, but adds
- *   LONGHAUL MSR for purpose of both frequency and voltage scaling.
- *   Present in Samuel 2 (steppings 1-7 only) (C5B), and Ezra (C5C).
- *  Version 3 of longhaul got renamed to Powersaver and redesigned
- *   to use only the POWERSAVER MSR at 0x110a.
- *   It is present in Ezra-T (C5M), Nehemiah (C5X) and above.
- *   It's pretty much the same feature wise to longhaul v2, though
- *   there is provision for scaling FSB too, but this doesn't work
- *   too well in practice so we don't even try to use this.
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/pci.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/delay.h>
-#include <linux/timex.h>
-#include <linux/io.h>
-#include <linux/acpi.h>
-
-#include <asm/msr.h>
-#include <acpi/processor.h>
-
-#include "longhaul.h"
-
-#define PFX "longhaul: "
-
-#define TYPE_LONGHAUL_V1        1
-#define TYPE_LONGHAUL_V2        2
-#define TYPE_POWERSAVER         3
-
-#define CPU_SAMUEL      1
-#define CPU_SAMUEL2     2
-#define CPU_EZRA        3
-#define CPU_EZRA_T      4
-#define CPU_NEHEMIAH    5
-#define CPU_NEHEMIAH_C  6
-
-/* Flags */
-#define USE_ACPI_C3             (1 << 1)
-#define USE_NORTHBRIDGE         (1 << 2)
-
-static int cpu_model;
-static unsigned int numscales = 16;
-static unsigned int fsb;
-
-static const struct mV_pos *vrm_mV_table;
-static const unsigned char *mV_vrm_table;
-
-static unsigned int highest_speed, lowest_speed; /* kHz */
-static unsigned int minmult, maxmult;
-static int can_scale_voltage;
-static struct acpi_processor *pr;
-static struct acpi_processor_cx *cx;
-static u32 acpi_regs_addr;
-static u8 longhaul_flags;
-static unsigned int longhaul_index;
-
-/* Module parameters */
-static int scale_voltage;
-static int disable_acpi_c3;
-static int revid_errata;
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "longhaul", msg)
-
-
-/* Clock ratios multiplied by 10 */
-static int mults[32];
-static int eblcr[32];
-static int longhaul_version;
-static struct cpufreq_frequency_table *longhaul_table;
-
-#ifdef CONFIG_CPU_FREQ_DEBUG
-static char speedbuffer[8];
-
-static char *print_speed(int speed)
-{
-        if (speed < 1000) {
-                snprintf(speedbuffer, sizeof(speedbuffer), "%dMHz", speed);
-                return speedbuffer;
-        }
-
-        if (speed%1000 == 0)
-                snprintf(speedbuffer, sizeof(speedbuffer),
-                        "%dGHz", speed/1000);
-        else
-                snprintf(speedbuffer, sizeof(speedbuffer),
-                        "%d.%dGHz", speed/1000, (speed%1000)/100);
-
-        return speedbuffer;
-}
-#endif
-
-
-static unsigned int calc_speed(int mult)
-{
-        int khz;
-        khz = (mult/10)*fsb;
-        if (mult%10)
-                khz += fsb/2;
-        khz *= 1000;
-        return khz;
-}
-
-
-static int longhaul_get_cpu_mult(void)
-{
-        unsigned long invalue = 0, lo, hi;
-
-        rdmsr(MSR_IA32_EBL_CR_POWERON, lo, hi);
-        invalue = (lo & (1<<22|1<<23|1<<24|1<<25))>>22;
-        if (longhaul_version == TYPE_LONGHAUL_V2 ||
-            longhaul_version == TYPE_POWERSAVER) {
-                if (lo & (1<<27))
-                        invalue += 16;
-        }
-        return eblcr[invalue];
-}
-
-/* For processor with BCR2 MSR */
-
-static void do_longhaul1(unsigned int mults_index)
-{
-        union msr_bcr2 bcr2;
-
-        rdmsrl(MSR_VIA_BCR2, bcr2.val);
-        /* Enable software clock multiplier */
-        bcr2.bits.ESOFTBF = 1;
-        bcr2.bits.CLOCKMUL = mults_index & 0xff;
-
-        /* Sync to timer tick */
-        safe_halt();
-        /* Change frequency on next halt or sleep */
-        wrmsrl(MSR_VIA_BCR2, bcr2.val);
-        /* Invoke transition */
-        ACPI_FLUSH_CPU_CACHE();
-        halt();
-
-        /* Disable software clock multiplier */
-        local_irq_disable();
-        rdmsrl(MSR_VIA_BCR2, bcr2.val);
-        bcr2.bits.ESOFTBF = 0;
-        wrmsrl(MSR_VIA_BCR2, bcr2.val);
-}
-
-/* For processor with Longhaul MSR */
-
-static void do_powersaver(int cx_address, unsigned int mults_index,
-                          unsigned int dir)
-{
-        union msr_longhaul longhaul;
-        u32 t;
-
-        rdmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-        /* Setup new frequency */
-        if (!revid_errata)
-                longhaul.bits.RevisionKey = longhaul.bits.RevisionID;
-        else
-                longhaul.bits.RevisionKey = 0;
-        longhaul.bits.SoftBusRatio = mults_index & 0xf;
-        longhaul.bits.SoftBusRatio4 = (mults_index & 0x10) >> 4;
-        /* Setup new voltage */
-        if (can_scale_voltage)
-                longhaul.bits.SoftVID = (mults_index >> 8) & 0x1f;
-        /* Sync to timer tick */
-        safe_halt();
-        /* Raise voltage if necessary */
-        if (can_scale_voltage && dir) {
-                longhaul.bits.EnableSoftVID = 1;
-                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-                /* Change voltage */
-                if (!cx_address) {
-                        ACPI_FLUSH_CPU_CACHE();
-                        halt();
-                } else {
-                        ACPI_FLUSH_CPU_CACHE();
-                        /* Invoke C3 */
-                        inb(cx_address);
-                        /* Dummy op - must do something useless after P_LVL3
-                         * read */
-                        t = inl(acpi_gbl_FADT.xpm_timer_block.address);
-                }
-                longhaul.bits.EnableSoftVID = 0;
-                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-        }
-
-        /* Change frequency on next halt or sleep */
-        longhaul.bits.EnableSoftBusRatio = 1;
-        wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-        if (!cx_address) {
-                ACPI_FLUSH_CPU_CACHE();
-                halt();
-        } else {
-                ACPI_FLUSH_CPU_CACHE();
-                /* Invoke C3 */
-                inb(cx_address);
-                /* Dummy op - must do something useless after P_LVL3 read */
-                t = inl(acpi_gbl_FADT.xpm_timer_block.address);
-        }
-        /* Disable bus ratio bit */
-        longhaul.bits.EnableSoftBusRatio = 0;
-        wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-
-        /* Reduce voltage if necessary */
-        if (can_scale_voltage && !dir) {
-                longhaul.bits.EnableSoftVID = 1;
-                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-                /* Change voltage */
-                if (!cx_address) {
-                        ACPI_FLUSH_CPU_CACHE();
-                        halt();
-                } else {
-                        ACPI_FLUSH_CPU_CACHE();
-                        /* Invoke C3 */
-                        inb(cx_address);
-                        /* Dummy op - must do something useless after P_LVL3
-                         * read */
-                        t = inl(acpi_gbl_FADT.xpm_timer_block.address);
-                }
-                longhaul.bits.EnableSoftVID = 0;
-                wrmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-        }
-}
-
-/**
- * longhaul_set_cpu_frequency()
- * @mults_index : bitpattern of the new multiplier.
- *
- * Sets a new clock ratio.
- */
-
-static void longhaul_setstate(unsigned int table_index)
-{
-        unsigned int mults_index;
-        int speed, mult;
-        struct cpufreq_freqs freqs;
-        unsigned long flags;
-        unsigned int pic1_mask, pic2_mask;
-        u16 bm_status = 0;
-        u32 bm_timeout = 1000;
-        unsigned int dir = 0;
-
-        mults_index = longhaul_table[table_index].index;
-        /* Safety precautions */
-        mult = mults[mults_index & 0x1f];
-        if (mult == -1)
-                return;
-        speed = calc_speed(mult);
-        if ((speed > highest_speed) || (speed < lowest_speed))
-                return;
-        /* Voltage transition before frequency transition? */
-        if (can_scale_voltage && longhaul_index < table_index)
-                dir = 1;
-
-        freqs.old = calc_speed(longhaul_get_cpu_mult());
-        freqs.new = speed;
-        freqs.cpu = 0; /* longhaul.c is UP only driver */
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        dprintk("Setting to FSB:%dMHz Mult:%d.%dx (%s)\n",
-                        fsb, mult/10, mult%10, print_speed(speed/1000));
-retry_loop:
-        preempt_disable();
-        local_irq_save(flags);
-
-        pic2_mask = inb(0xA1);
-        pic1_mask = inb(0x21);  /* works on C3. save mask. */
-        outb(0xFF, 0xA1);       /* Overkill */
-        outb(0xFE, 0x21);       /* TMR0 only */
-
-        /* Wait while PCI bus is busy. */
-        if (acpi_regs_addr && (longhaul_flags & USE_NORTHBRIDGE
-            || ((pr != NULL) && pr->flags.bm_control))) {
-                bm_status = inw(acpi_regs_addr);
-                bm_status &= 1 << 4;
-                while (bm_status && bm_timeout) {
-                        outw(1 << 4, acpi_regs_addr);
-                        bm_timeout--;
-                        bm_status = inw(acpi_regs_addr);
-                        bm_status &= 1 << 4;
-                }
-        }
-
-        if (longhaul_flags & USE_NORTHBRIDGE) {
-                /* Disable AGP and PCI arbiters */
-                outb(3, 0x22);
-        } else if ((pr != NULL) && pr->flags.bm_control) {
-                /* Disable bus master arbitration */
-                acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
-        }
-        switch (longhaul_version) {
-
-        /*
-         * Longhaul v1. (Samuel[C5A] and Samuel2 stepping 0[C5B])
-         * Software controlled multipliers only.
-         */
-        case TYPE_LONGHAUL_V1:
-                do_longhaul1(mults_index);
-                break;
-
-        /*
-         * Longhaul v2 appears in Samuel2 Steppings 1->7 [C5B] and Ezra [C5C]
-         *
-         * Longhaul v3 (aka Powersaver). (Ezra-T [C5M] & Nehemiah [C5N])
-         * Nehemiah can do FSB scaling too, but this has never been proven
-         * to work in practice.
-         */
-        case TYPE_LONGHAUL_V2:
-        case TYPE_POWERSAVER:
-                if (longhaul_flags & USE_ACPI_C3) {
-                        /* Don't allow wakeup */
-                        acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 0);
-                        do_powersaver(cx->address, mults_index, dir);
-                } else {
-                        do_powersaver(0, mults_index, dir);
-                }
-                break;
-        }
-
-        if (longhaul_flags & USE_NORTHBRIDGE) {
-                /* Enable arbiters */
-                outb(0, 0x22);
-        } else if ((pr != NULL) && pr->flags.bm_control) {
-                /* Enable bus master arbitration */
-                acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
-        }
-        outb(pic2_mask, 0xA1);  /* restore mask */
-        outb(pic1_mask, 0x21);
-
-        local_irq_restore(flags);
-        preempt_enable();
-
-        freqs.new = calc_speed(longhaul_get_cpu_mult());
-        /* Check if requested frequency is set. */
-        if (unlikely(freqs.new != speed)) {
-                printk(KERN_INFO PFX "Failed to set requested frequency!\n");
-                /* Revision ID = 1 but processor is expecting revision key
-                 * equal to 0. Jumpers at the bottom of processor will change
-                 * multiplier and FSB, but will not change bits in Longhaul
-                 * MSR nor enable voltage scaling. */
-                if (!revid_errata) {
-                        printk(KERN_INFO PFX "Enabling \"Ignore Revision ID\" "
-                                                "option.\n");
-                        revid_errata = 1;
-                        msleep(200);
-                        goto retry_loop;
-                }
-                /* Why ACPI C3 sometimes doesn't work is a mystery for me.
-                 * But it does happen. Processor is entering ACPI C3 state,
-                 * but it doesn't change frequency. I tried poking various
-                 * bits in northbridge registers, but without success. */
-                if (longhaul_flags & USE_ACPI_C3) {
-                        printk(KERN_INFO PFX "Disabling ACPI C3 support.\n");
-                        longhaul_flags &= ~USE_ACPI_C3;
-                        if (revid_errata) {
-                                printk(KERN_INFO PFX "Disabling \"Ignore "
-                                                "Revision ID\" option.\n");
-                                revid_errata = 0;
-                        }
-                        msleep(200);
-                        goto retry_loop;
-                }
-                /* This shouldn't happen. Longhaul ver. 2 was reported not
-                 * working on processors without voltage scaling, but with
-                 * RevID = 1. RevID errata will make things right. Just
-                 * to be 100% sure. */
-                if (longhaul_version == TYPE_LONGHAUL_V2) {
-                        printk(KERN_INFO PFX "Switching to Longhaul ver. 1\n");
-                        longhaul_version = TYPE_LONGHAUL_V1;
-                        msleep(200);
-                        goto retry_loop;
-                }
-        }
-        /* Report true CPU frequency */
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-
-        if (!bm_timeout)
-                printk(KERN_INFO PFX "Warning: Timeout while waiting for "
-                                "idle PCI bus.\n");
-}
-
-/*
- * Centaur decided to make life a little more tricky.
- * Only longhaul v1 is allowed to read EBLCR BSEL[0:1].
- * Samuel2 and above have to try and guess what the FSB is.
- * We do this by assuming we booted at maximum multiplier, and interpolate
- * between that value multiplied by possible FSBs and cpu_mhz which
- * was calculated at boot time. Really ugly, but no other way to do this.
- */
-
-#define ROUNDING        0xf
-
-static int guess_fsb(int mult)
-{
-        int speed = cpu_khz / 1000;
-        int i;
-        int speeds[] = { 666, 1000, 1333, 2000 };
-        int f_max, f_min;
-
-        for (i = 0; i < 4; i++) {
-                f_max = ((speeds[i] * mult) + 50) / 100;
-                f_max += (ROUNDING / 2);
-                f_min = f_max - ROUNDING;
-                if ((speed <= f_max) && (speed >= f_min))
-                        return speeds[i] / 10;
-        }
-        return 0;
-}
-
-
-static int __cpuinit longhaul_get_ranges(void)
-{
-        unsigned int i, j, k = 0;
-        unsigned int ratio;
-        int mult;
-
-        /* Get current frequency */
-        mult = longhaul_get_cpu_mult();
-        if (mult == -1) {
-                printk(KERN_INFO PFX "Invalid (reserved) multiplier!\n");
-                return -EINVAL;
-        }
-        fsb = guess_fsb(mult);
-        if (fsb == 0) {
-                printk(KERN_INFO PFX "Invalid (reserved) FSB!\n");
-                return -EINVAL;
-        }
-        /* Get max multiplier - as we always did.
-         * Longhaul MSR is useful only when voltage scaling is enabled.
-         * C3 is booting at max anyway. */
-        maxmult = mult;
-        /* Get min multiplier */
-        switch (cpu_model) {
-        case CPU_NEHEMIAH:
-                minmult = 50;
-                break;
-        case CPU_NEHEMIAH_C:
-                minmult = 40;
-                break;
-        default:
-                minmult = 30;
-                break;
-        }
-
-        dprintk("MinMult:%d.%dx MaxMult:%d.%dx\n",
-                 minmult/10, minmult%10, maxmult/10, maxmult%10);
-
-        highest_speed = calc_speed(maxmult);
-        lowest_speed = calc_speed(minmult);
-        dprintk("FSB:%dMHz  Lowest speed: %s   Highest speed:%s\n", fsb,
-                 print_speed(lowest_speed/1000),
-                 print_speed(highest_speed/1000));
-
-        if (lowest_speed == highest_speed) {
-                printk(KERN_INFO PFX "highestspeed == lowest, aborting.\n");
-                return -EINVAL;
-        }
-        if (lowest_speed > highest_speed) {
-                printk(KERN_INFO PFX "nonsense! lowest (%d > %d) !\n",
-                        lowest_speed, highest_speed);
-                return -EINVAL;
-        }
-
-        longhaul_table = kmalloc((numscales + 1) * sizeof(*longhaul_table),
-                        GFP_KERNEL);
-        if (!longhaul_table)
-                return -ENOMEM;
-
-        for (j = 0; j < numscales; j++) {
-                ratio = mults[j];
-                if (ratio == -1)
-                        continue;
-                if (ratio > maxmult || ratio < minmult)
-                        continue;
-                longhaul_table[k].frequency = calc_speed(ratio);
-                longhaul_table[k].index = j;
-                k++;
-        }
-        if (k <= 1) {
-                kfree(longhaul_table);
-                return -ENODEV;
-        }
-        /* Sort */
-        for (j = 0; j < k - 1; j++) {
-                unsigned int min_f, min_i;
-                min_f = longhaul_table[j].frequency;
-                min_i = j;
-                for (i = j + 1; i < k; i++) {
-                        if (longhaul_table[i].frequency < min_f) {
-                                min_f = longhaul_table[i].frequency;
-                                min_i = i;
-                        }
-                }
-                if (min_i != j) {
-                        swap(longhaul_table[j].frequency,
-                             longhaul_table[min_i].frequency);
-                        swap(longhaul_table[j].index,
-                             longhaul_table[min_i].index);
-                }
-        }
-
-        longhaul_table[k].frequency = CPUFREQ_TABLE_END;
-
-        /* Find index we are running on */
-        for (j = 0; j < k; j++) {
-                if (mults[longhaul_table[j].index & 0x1f] == mult) {
-                        longhaul_index = j;
-                        break;
-                }
-        }
-        return 0;
-}
-
-
-static void __cpuinit longhaul_setup_voltagescaling(void)
-{
-        union msr_longhaul longhaul;
-        struct mV_pos minvid, maxvid, vid;
-        unsigned int j, speed, pos, kHz_step, numvscales;
-        int min_vid_speed;
-
-        rdmsrl(MSR_VIA_LONGHAUL, longhaul.val);
-        if (!(longhaul.bits.RevisionID & 1)) {
-                printk(KERN_INFO PFX "Voltage scaling not supported by CPU.\n");
-                return;
-        }
-
-        if (!longhaul.bits.VRMRev) {
-                printk(KERN_INFO PFX "VRM 8.5\n");
-                vrm_mV_table = &vrm85_mV[0];
-                mV_vrm_table = &mV_vrm85[0];
-        } else {
-                printk(KERN_INFO PFX "Mobile VRM\n");
-                if (cpu_model < CPU_NEHEMIAH)
-                        return;
-                vrm_mV_table = &mobilevrm_mV[0];
-                mV_vrm_table = &mV_mobilevrm[0];
-        }
-
-        minvid = vrm_mV_table[longhaul.bits.MinimumVID];
-        maxvid = vrm_mV_table[longhaul.bits.MaximumVID];
-
-        if (minvid.mV == 0 || maxvid.mV == 0 || minvid.mV > maxvid.mV) {
-                printk(KERN_INFO PFX "Bogus values Min:%d.%03d Max:%d.%03d. "
-                                        "Voltage scaling disabled.\n",
-                                        minvid.mV/1000, minvid.mV%1000,
-                                        maxvid.mV/1000, maxvid.mV%1000);
-                return;
-        }
-
-        if (minvid.mV == maxvid.mV) {
-                printk(KERN_INFO PFX "Claims to support voltage scaling but "
-                                "min & max are both %d.%03d. "
-                                "Voltage scaling disabled\n",
-                                maxvid.mV/1000, maxvid.mV%1000);
-                return;
-        }
-
-        /* How many voltage steps*/
-        numvscales = maxvid.pos - minvid.pos + 1;
-        printk(KERN_INFO PFX
-                "Max VID=%d.%03d  "
-                "Min VID=%d.%03d, "
-                "%d possible voltage scales\n",
-                maxvid.mV/1000, maxvid.mV%1000,
-                minvid.mV/1000, minvid.mV%1000,
-                numvscales);
-
-        /* Calculate max frequency at min voltage */
-        j = longhaul.bits.MinMHzBR;
-        if (longhaul.bits.MinMHzBR4)
-                j += 16;
-        min_vid_speed = eblcr[j];
-        if (min_vid_speed == -1)
-                return;
-        switch (longhaul.bits.MinMHzFSB) {
-        case 0:
-                min_vid_speed *= 13333;
-                break;
-        case 1:
-                min_vid_speed *= 10000;
-                break;
-        case 3:
-                min_vid_speed *= 6666;
-                break;
-        default:
-                return;
-                break;
-        }
-        if (min_vid_speed >= highest_speed)
-                return;
-        /* Calculate kHz for one voltage step */
-        kHz_step = (highest_speed - min_vid_speed) / numvscales;
-
-        j = 0;
-        while (longhaul_table[j].frequency != CPUFREQ_TABLE_END) {
-                speed = longhaul_table[j].frequency;
-                if (speed > min_vid_speed)
-                        pos = (speed - min_vid_speed) / kHz_step + minvid.pos;
-                else
-                        pos = minvid.pos;
-                longhaul_table[j].index |= mV_vrm_table[pos] << 8;
-                vid = vrm_mV_table[mV_vrm_table[pos]];
-                printk(KERN_INFO PFX "f: %d kHz, index: %d, vid: %d mV\n",
-                                speed, j, vid.mV);
-                j++;
-        }
-
-        can_scale_voltage = 1;
-        printk(KERN_INFO PFX "Voltage scaling enabled.\n");
-}
-
-
-static int longhaul_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, longhaul_table);
-}
-
-
-static int longhaul_target(struct cpufreq_policy *policy,
-                            unsigned int target_freq, unsigned int relation)
-{
-        unsigned int table_index = 0;
-        unsigned int i;
-        unsigned int dir = 0;
-        u8 vid, current_vid;
-
-        if (cpufreq_frequency_table_target(policy, longhaul_table, target_freq,
-                                relation, &table_index))
-                return -EINVAL;
-
-        /* Don't set same frequency again */
-        if (longhaul_index == table_index)
-                return 0;
-
-        if (!can_scale_voltage)
-                longhaul_setstate(table_index);
-        else {
-                /* On test system voltage transitions exceeding single
-                 * step up or down were turning motherboard off. Both
-                 * "ondemand" and "userspace" are unsafe. C7 is doing
-                 * this in hardware, C3 is old and we need to do this
-                 * in software. */
-                i = longhaul_index;
-                current_vid = (longhaul_table[longhaul_index].index >> 8);
-                current_vid &= 0x1f;
-                if (table_index > longhaul_index)
-                        dir = 1;
-                while (i != table_index) {
-                        vid = (longhaul_table[i].index >> 8) & 0x1f;
-                        if (vid != current_vid) {
-                                longhaul_setstate(i);
-                                current_vid = vid;
-                                msleep(200);
-                        }
-                        if (dir)
-                                i++;
-                        else
-                                i--;
-                }
-                longhaul_setstate(table_index);
-        }
-        longhaul_index = table_index;
-        return 0;
-}
-
-
-static unsigned int longhaul_get(unsigned int cpu)
-{
-        if (cpu)
-                return 0;
-        return calc_speed(longhaul_get_cpu_mult());
-}
-
-static acpi_status longhaul_walk_callback(acpi_handle obj_handle,
-                                          u32 nesting_level,
-                                          void *context, void **return_value)
-{
-        struct acpi_device *d;
-
-        if (acpi_bus_get_device(obj_handle, &d))
-                return 0;
-
-        *return_value = acpi_driver_data(d);
-        return 1;
-}
-
-/* VIA don't support PM2 reg, but have something similar */
-static int enable_arbiter_disable(void)
-{
-        struct pci_dev *dev;
-        int status = 1;
-        int reg;
-        u8 pci_cmd;
-
-        /* Find PLE133 host bridge */
-        reg = 0x78;
-        dev = pci_get_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8601_0,
-                             NULL);
-        /* Find PM133/VT8605 host bridge */
-        if (dev == NULL)
-                dev = pci_get_device(PCI_VENDOR_ID_VIA,
-                                     PCI_DEVICE_ID_VIA_8605_0, NULL);
-        /* Find CLE266 host bridge */
-        if (dev == NULL) {
-                reg = 0x76;
-                dev = pci_get_device(PCI_VENDOR_ID_VIA,
-                                     PCI_DEVICE_ID_VIA_862X_0, NULL);
-                /* Find CN400 V-Link host bridge */
-                if (dev == NULL)
-                        dev = pci_get_device(PCI_VENDOR_ID_VIA, 0x7259, NULL);
-        }
-        if (dev != NULL) {
-                /* Enable access to port 0x22 */
-                pci_read_config_byte(dev, reg, &pci_cmd);
-                if (!(pci_cmd & 1<<7)) {
-                        pci_cmd |= 1<<7;
-                        pci_write_config_byte(dev, reg, pci_cmd);
-                        pci_read_config_byte(dev, reg, &pci_cmd);
-                        if (!(pci_cmd & 1<<7)) {
-                                printk(KERN_ERR PFX
-                                        "Can't enable access to port 0x22.\n");
-                                status = 0;
-                        }
-                }
-                pci_dev_put(dev);
-                return status;
-        }
-        return 0;
-}
-
-static int longhaul_setup_southbridge(void)
-{
-        struct pci_dev *dev;
-        u8 pci_cmd;
-
-        /* Find VT8235 southbridge */
-        dev = pci_get_device(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235, NULL);
-        if (dev == NULL)
-                /* Find VT8237 southbridge */
-                dev = pci_get_device(PCI_VENDOR_ID_VIA,
-                                     PCI_DEVICE_ID_VIA_8237, NULL);
-        if (dev != NULL) {
-                /* Set transition time to max */
-                pci_read_config_byte(dev, 0xec, &pci_cmd);
-                pci_cmd &= ~(1 << 2);
-                pci_write_config_byte(dev, 0xec, pci_cmd);
-                pci_read_config_byte(dev, 0xe4, &pci_cmd);
-                pci_cmd &= ~(1 << 7);
-                pci_write_config_byte(dev, 0xe4, pci_cmd);
-                pci_read_config_byte(dev, 0xe5, &pci_cmd);
-                pci_cmd |= 1 << 7;
-                pci_write_config_byte(dev, 0xe5, pci_cmd);
-                /* Get address of ACPI registers block*/
-                pci_read_config_byte(dev, 0x81, &pci_cmd);
-                if (pci_cmd & 1 << 7) {
-                        pci_read_config_dword(dev, 0x88, &acpi_regs_addr);
-                        acpi_regs_addr &= 0xff00;
-                        printk(KERN_INFO PFX "ACPI I/O at 0x%x\n",
-                                        acpi_regs_addr);
-                }
-
-                pci_dev_put(dev);
-                return 1;
-        }
-        return 0;
-}
-
-static int __cpuinit longhaul_cpu_init(struct cpufreq_policy *policy)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        char *cpuname = NULL;
-        int ret;
-        u32 lo, hi;
-
-        /* Check what we have on this motherboard */
-        switch (c->x86_model) {
-        case 6:
-                cpu_model = CPU_SAMUEL;
-                cpuname = "C3 'Samuel' [C5A]";
-                longhaul_version = TYPE_LONGHAUL_V1;
-                memcpy(mults, samuel1_mults, sizeof(samuel1_mults));
-                memcpy(eblcr, samuel1_eblcr, sizeof(samuel1_eblcr));
-                break;
-
-        case 7:
-                switch (c->x86_mask) {
-                case 0:
-                        longhaul_version = TYPE_LONGHAUL_V1;
-                        cpu_model = CPU_SAMUEL2;
-                        cpuname = "C3 'Samuel 2' [C5B]";
-                        /* Note, this is not a typo, early Samuel2's had
-                         * Samuel1 ratios. */
-                        memcpy(mults, samuel1_mults, sizeof(samuel1_mults));
-                        memcpy(eblcr, samuel2_eblcr, sizeof(samuel2_eblcr));
-                        break;
-                case 1 ... 15:
-                        longhaul_version = TYPE_LONGHAUL_V2;
-                        if (c->x86_mask < 8) {
-                                cpu_model = CPU_SAMUEL2;
-                                cpuname = "C3 'Samuel 2' [C5B]";
-                        } else {
-                                cpu_model = CPU_EZRA;
-                                cpuname = "C3 'Ezra' [C5C]";
-                        }
-                        memcpy(mults, ezra_mults, sizeof(ezra_mults));
-                        memcpy(eblcr, ezra_eblcr, sizeof(ezra_eblcr));
-                        break;
-                }
-                break;
-
-        case 8:
-                cpu_model = CPU_EZRA_T;
-                cpuname = "C3 'Ezra-T' [C5M]";
-                longhaul_version = TYPE_POWERSAVER;
-                numscales = 32;
-                memcpy(mults, ezrat_mults, sizeof(ezrat_mults));
-                memcpy(eblcr, ezrat_eblcr, sizeof(ezrat_eblcr));
-                break;
-
-        case 9:
-                longhaul_version = TYPE_POWERSAVER;
-                numscales = 32;
-                memcpy(mults, nehemiah_mults, sizeof(nehemiah_mults));
-                memcpy(eblcr, nehemiah_eblcr, sizeof(nehemiah_eblcr));
-                switch (c->x86_mask) {
-                case 0 ... 1:
-                        cpu_model = CPU_NEHEMIAH;
-                        cpuname = "C3 'Nehemiah A' [C5XLOE]";
-                        break;
-                case 2 ... 4:
-                        cpu_model = CPU_NEHEMIAH;
-                        cpuname = "C3 'Nehemiah B' [C5XLOH]";
-                        break;
-                case 5 ... 15:
-                        cpu_model = CPU_NEHEMIAH_C;
-                        cpuname = "C3 'Nehemiah C' [C5P]";
-                        break;
-                }
-                break;
-
-        default:
-                cpuname = "Unknown";
-                break;
-        }
-        /* Check Longhaul ver. 2 */
-        if (longhaul_version == TYPE_LONGHAUL_V2) {
-                rdmsr(MSR_VIA_LONGHAUL, lo, hi);
-                if (lo == 0 && hi == 0)
-                        /* Looks like MSR isn't present */
-                        longhaul_version = TYPE_LONGHAUL_V1;
-        }
-
-        printk(KERN_INFO PFX "VIA %s CPU detected.  ", cpuname);
-        switch (longhaul_version) {
-        case TYPE_LONGHAUL_V1:
-        case TYPE_LONGHAUL_V2:
-                printk(KERN_CONT "Longhaul v%d supported.\n", longhaul_version);
-                break;
-        case TYPE_POWERSAVER:
-                printk(KERN_CONT "Powersaver supported.\n");
-                break;
-        };
-
-        /* Doesn't hurt */
-        longhaul_setup_southbridge();
-
-        /* Find ACPI data for processor */
-        acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
-                                ACPI_UINT32_MAX, &longhaul_walk_callback, NULL,
-                                NULL, (void *)&pr);
-
-        /* Check ACPI support for C3 state */
-        if (pr != NULL && longhaul_version == TYPE_POWERSAVER) {
-                cx = &pr->power.states[ACPI_STATE_C3];
-                if (cx->address > 0 && cx->latency <= 1000)
-                        longhaul_flags |= USE_ACPI_C3;
-        }
-        /* Disable if it isn't working */
-        if (disable_acpi_c3)
-                longhaul_flags &= ~USE_ACPI_C3;
-        /* Check if northbridge is friendly */
-        if (enable_arbiter_disable())
-                longhaul_flags |= USE_NORTHBRIDGE;
-
-        /* Check ACPI support for bus master arbiter disable */
-        if (!(longhaul_flags & USE_ACPI_C3
-             || longhaul_flags & USE_NORTHBRIDGE)
-            && ((pr == NULL) || !(pr->flags.bm_control))) {
-                printk(KERN_ERR PFX
-                        "No ACPI support. Unsupported northbridge.\n");
-                return -ENODEV;
-        }
-
-        if (longhaul_flags & USE_NORTHBRIDGE)
-                printk(KERN_INFO PFX "Using northbridge support.\n");
-        if (longhaul_flags & USE_ACPI_C3)
-                printk(KERN_INFO PFX "Using ACPI support.\n");
-
-        ret = longhaul_get_ranges();
-        if (ret != 0)
-                return ret;
-
-        if ((longhaul_version != TYPE_LONGHAUL_V1) && (scale_voltage != 0))
-                longhaul_setup_voltagescaling();
-
-        policy->cpuinfo.transition_latency = 200000;    /* nsec */
-        policy->cur = calc_speed(longhaul_get_cpu_mult());
-
-        ret = cpufreq_frequency_table_cpuinfo(policy, longhaul_table);
-        if (ret)
-                return ret;
-
-        cpufreq_frequency_table_get_attr(longhaul_table, policy->cpu);
-
-        return 0;
-}
-
-static int __devexit longhaul_cpu_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
-static struct freq_attr *longhaul_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver longhaul_driver = {
-        .verify = longhaul_verify,
-        .target = longhaul_target,
-        .get    = longhaul_get,
-        .init   = longhaul_cpu_init,
-        .exit   = __devexit_p(longhaul_cpu_exit),
-        .name   = "longhaul",
-        .owner  = THIS_MODULE,
-        .attr   = longhaul_attr,
-};
-
-
-static int __init longhaul_init(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-
-        if (c->x86_vendor != X86_VENDOR_CENTAUR || c->x86 != 6)
-                return -ENODEV;
-
-#ifdef CONFIG_SMP
-        if (num_online_cpus() > 1) {
-                printk(KERN_ERR PFX "More than 1 CPU detected, "
-                                "longhaul disabled.\n");
-                return -ENODEV;
-        }
-#endif
-#ifdef CONFIG_X86_IO_APIC
-        if (cpu_has_apic) {
-                printk(KERN_ERR PFX "APIC detected. Longhaul is currently "
-                                "broken in this configuration.\n");
-                return -ENODEV;
-        }
-#endif
-        switch (c->x86_model) {
-        case 6 ... 9:
-                return cpufreq_register_driver(&longhaul_driver);
-        case 10:
-                printk(KERN_ERR PFX "Use acpi-cpufreq driver for VIA C7\n");
-        default:
-                ;
-        }
-
-        return -ENODEV;
-}
-
-
-static void __exit longhaul_exit(void)
-{
-        int i;
-
-        for (i = 0; i < numscales; i++) {
-                if (mults[i] == maxmult) {
-                        longhaul_setstate(i);
-                        break;
-                }
-        }
-
-        cpufreq_unregister_driver(&longhaul_driver);
-        kfree(longhaul_table);
-}
-
-/* Even if BIOS is exporting ACPI C3 state, and it is used
- * with success when CPU is idle, this state doesn't
- * trigger frequency transition in some cases. */
-module_param(disable_acpi_c3, int, 0644);
-MODULE_PARM_DESC(disable_acpi_c3, "Don't use ACPI C3 support");
-/* Change CPU voltage with frequency. Very useful to save
- * power, but most VIA C3 processors aren't supporting it. */
-module_param(scale_voltage, int, 0644);
-MODULE_PARM_DESC(scale_voltage, "Scale voltage of processor");
-/* Force revision key to 0 for processors which doesn't
- * support voltage scaling, but are introducing itself as
- * such. */
-module_param(revid_errata, int, 0644);
-MODULE_PARM_DESC(revid_errata, "Ignore CPU Revision ID");
-
-MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
-MODULE_DESCRIPTION("Longhaul driver for VIA Cyrix processors.");
-MODULE_LICENSE("GPL");
-
-late_initcall(longhaul_init);
-module_exit(longhaul_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/longhaul.h b/arch/x86/kernel/cpu/cpufreq/longhaul.h
deleted file mode 100644
index cbf48fbca881..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/longhaul.h
+++ /dev/null
@@ -1,353 +0,0 @@
-/*
- *  longhaul.h
- *  (C) 2003 Dave Jones.
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- *  VIA-specific information
- */
-
-union msr_bcr2 {
-        struct {
-                unsigned Reseved:19,    // 18:0
-                ESOFTBF:1,              // 19
-                Reserved2:3,            // 22:20
-                CLOCKMUL:4,             // 26:23
-                Reserved3:5;            // 31:27
-        } bits;
-        unsigned long val;
-};
-
-union msr_longhaul {
-        struct {
-                unsigned RevisionID:4,  // 3:0
-                RevisionKey:4,          // 7:4
-                EnableSoftBusRatio:1,   // 8
-                EnableSoftVID:1,        // 9
-                EnableSoftBSEL:1,       // 10
-                Reserved:3,             // 11:13
-                SoftBusRatio4:1,        // 14
-                VRMRev:1,               // 15
-                SoftBusRatio:4,         // 19:16
-                SoftVID:5,              // 24:20
-                Reserved2:3,            // 27:25
-                SoftBSEL:2,             // 29:28
-                Reserved3:2,            // 31:30
-                MaxMHzBR:4,             // 35:32
-                MaximumVID:5,           // 40:36
-                MaxMHzFSB:2,            // 42:41
-                MaxMHzBR4:1,            // 43
-                Reserved4:4,            // 47:44
-                MinMHzBR:4,             // 51:48
-                MinimumVID:5,           // 56:52
-                MinMHzFSB:2,            // 58:57
-                MinMHzBR4:1,            // 59
-                Reserved5:4;            // 63:60
-        } bits;
-        unsigned long long val;
-};
-
-/*
- * Clock ratio tables. Div/Mod by 10 to get ratio.
- * The eblcr values specify the ratio read from the CPU.
- * The mults values specify what to write to the CPU.
- */
-
-/*
- * VIA C3 Samuel 1  & Samuel 2 (stepping 0)
- */
-static const int __cpuinitdata samuel1_mults[16] = {
-        -1, /* 0000 -> RESERVED */
-        30, /* 0001 ->  3.0x */
-        40, /* 0010 ->  4.0x */
-        -1, /* 0011 -> RESERVED */
-        -1, /* 0100 -> RESERVED */
-        35, /* 0101 ->  3.5x */
-        45, /* 0110 ->  4.5x */
-        55, /* 0111 ->  5.5x */
-        60, /* 1000 ->  6.0x */
-        70, /* 1001 ->  7.0x */
-        80, /* 1010 ->  8.0x */
-        50, /* 1011 ->  5.0x */
-        65, /* 1100 ->  6.5x */
-        75, /* 1101 ->  7.5x */
-        -1, /* 1110 -> RESERVED */
-        -1, /* 1111 -> RESERVED */
-};
-
-static const int __cpuinitdata samuel1_eblcr[16] = {
-        50, /* 0000 -> RESERVED */
-        30, /* 0001 ->  3.0x */
-        40, /* 0010 ->  4.0x */
-        -1, /* 0011 -> RESERVED */
-        55, /* 0100 ->  5.5x */
-        35, /* 0101 ->  3.5x */
-        45, /* 0110 ->  4.5x */
-        -1, /* 0111 -> RESERVED */
-        -1, /* 1000 -> RESERVED */
-        70, /* 1001 ->  7.0x */
-        80, /* 1010 ->  8.0x */
-        60, /* 1011 ->  6.0x */
-        -1, /* 1100 -> RESERVED */
-        75, /* 1101 ->  7.5x */
-        -1, /* 1110 -> RESERVED */
-        65, /* 1111 ->  6.5x */
-};
-
-/*
- * VIA C3 Samuel2 Stepping 1->15
- */
-static const int __cpuinitdata samuel2_eblcr[16] = {
-        50,  /* 0000 ->  5.0x */
-        30,  /* 0001 ->  3.0x */
-        40,  /* 0010 ->  4.0x */
-        100, /* 0011 -> 10.0x */
-        55,  /* 0100 ->  5.5x */
-        35,  /* 0101 ->  3.5x */
-        45,  /* 0110 ->  4.5x */
-        110, /* 0111 -> 11.0x */
-        90,  /* 1000 ->  9.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        60,  /* 1011 ->  6.0x */
-        120, /* 1100 -> 12.0x */
-        75,  /* 1101 ->  7.5x */
-        130, /* 1110 -> 13.0x */
-        65,  /* 1111 ->  6.5x */
-};
-
-/*
- * VIA C3 Ezra
- */
-static const int __cpuinitdata ezra_mults[16] = {
-        100, /* 0000 -> 10.0x */
-        30,  /* 0001 ->  3.0x */
-        40,  /* 0010 ->  4.0x */
-        90,  /* 0011 ->  9.0x */
-        95,  /* 0100 ->  9.5x */
-        35,  /* 0101 ->  3.5x */
-        45,  /* 0110 ->  4.5x */
-        55,  /* 0111 ->  5.5x */
-        60,  /* 1000 ->  6.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        50,  /* 1011 ->  5.0x */
-        65,  /* 1100 ->  6.5x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        120, /* 1111 -> 12.0x */
-};
-
-static const int __cpuinitdata ezra_eblcr[16] = {
-        50,  /* 0000 ->  5.0x */
-        30,  /* 0001 ->  3.0x */
-        40,  /* 0010 ->  4.0x */
-        100, /* 0011 -> 10.0x */
-        55,  /* 0100 ->  5.5x */
-        35,  /* 0101 ->  3.5x */
-        45,  /* 0110 ->  4.5x */
-        95,  /* 0111 ->  9.5x */
-        90,  /* 1000 ->  9.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        60,  /* 1011 ->  6.0x */
-        120, /* 1100 -> 12.0x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        65,  /* 1111 ->  6.5x */
-};
-
-/*
- * VIA C3 (Ezra-T) [C5M].
- */
-static const int __cpuinitdata ezrat_mults[32] = {
-        100, /* 0000 -> 10.0x */
-        30,  /* 0001 ->  3.0x */
-        40,  /* 0010 ->  4.0x */
-        90,  /* 0011 ->  9.0x */
-        95,  /* 0100 ->  9.5x */
-        35,  /* 0101 ->  3.5x */
-        45,  /* 0110 ->  4.5x */
-        55,  /* 0111 ->  5.5x */
-        60,  /* 1000 ->  6.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        50,  /* 1011 ->  5.0x */
-        65,  /* 1100 ->  6.5x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        120, /* 1111 ->  12.0x */
-
-        -1,  /* 0000 -> RESERVED (10.0x) */
-        110, /* 0001 -> 11.0x */
-        -1, /* 0010 -> 12.0x */
-        -1,  /* 0011 -> RESERVED (9.0x)*/
-        105, /* 0100 -> 10.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        135, /* 0111 -> 13.5x */
-        140, /* 1000 -> 14.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        130, /* 1011 -> 13.0x */
-        145, /* 1100 -> 14.5x */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        -1,  /* 1111 -> RESERVED (12.0x) */
-};
-
-static const int __cpuinitdata ezrat_eblcr[32] = {
-        50,  /* 0000 ->  5.0x */
-        30,  /* 0001 ->  3.0x */
-        40,  /* 0010 ->  4.0x */
-        100, /* 0011 -> 10.0x */
-        55,  /* 0100 ->  5.5x */
-        35,  /* 0101 ->  3.5x */
-        45,  /* 0110 ->  4.5x */
-        95,  /* 0111 ->  9.5x */
-        90,  /* 1000 ->  9.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        60,  /* 1011 ->  6.0x */
-        120, /* 1100 -> 12.0x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        65,  /* 1111 ->  6.5x */
-
-        -1,  /* 0000 -> RESERVED (9.0x) */
-        110, /* 0001 -> 11.0x */
-        120, /* 0010 -> 12.0x */
-        -1,  /* 0011 -> RESERVED (10.0x)*/
-        135, /* 0100 -> 13.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        105, /* 0111 -> 10.5x */
-        130, /* 1000 -> 13.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        140, /* 1011 -> 14.0x */
-        -1,  /* 1100 -> RESERVED (12.0x) */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        145, /* 1111 -> 14.5x */
-};
-
-/*
- * VIA C3 Nehemiah */
-
-static const int __cpuinitdata nehemiah_mults[32] = {
-        100, /* 0000 -> 10.0x */
-        -1, /* 0001 -> 16.0x */
-        40,  /* 0010 ->  4.0x */
-        90,  /* 0011 ->  9.0x */
-        95,  /* 0100 ->  9.5x */
-        -1,  /* 0101 ->  RESERVED */
-        45,  /* 0110 ->  4.5x */
-        55,  /* 0111 ->  5.5x */
-        60,  /* 1000 ->  6.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        50,  /* 1011 ->  5.0x */
-        65,  /* 1100 ->  6.5x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        120, /* 1111 -> 12.0x */
-        -1, /* 0000 -> 10.0x */
-        110, /* 0001 -> 11.0x */
-        -1, /* 0010 -> 12.0x */
-        -1,  /* 0011 ->  9.0x */
-        105, /* 0100 -> 10.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        135, /* 0111 -> 13.5x */
-        140, /* 1000 -> 14.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        130, /* 1011 -> 13.0x */
-        145, /* 1100 -> 14.5x */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        -1, /* 1111 -> 12.0x */
-};
-
-static const int __cpuinitdata nehemiah_eblcr[32] = {
-        50,  /* 0000 ->  5.0x */
-        160, /* 0001 -> 16.0x */
-        40,  /* 0010 ->  4.0x */
-        100, /* 0011 -> 10.0x */
-        55,  /* 0100 ->  5.5x */
-        -1,  /* 0101 ->  RESERVED */
-        45,  /* 0110 ->  4.5x */
-        95,  /* 0111 ->  9.5x */
-        90,  /* 1000 ->  9.0x */
-        70,  /* 1001 ->  7.0x */
-        80,  /* 1010 ->  8.0x */
-        60,  /* 1011 ->  6.0x */
-        120, /* 1100 -> 12.0x */
-        75,  /* 1101 ->  7.5x */
-        85,  /* 1110 ->  8.5x */
-        65,  /* 1111 ->  6.5x */
-        90,  /* 0000 ->  9.0x */
-        110, /* 0001 -> 11.0x */
-        120, /* 0010 -> 12.0x */
-        100, /* 0011 -> 10.0x */
-        135, /* 0100 -> 13.5x */
-        115, /* 0101 -> 11.5x */
-        125, /* 0110 -> 12.5x */
-        105, /* 0111 -> 10.5x */
-        130, /* 1000 -> 13.0x */
-        150, /* 1001 -> 15.0x */
-        160, /* 1010 -> 16.0x */
-        140, /* 1011 -> 14.0x */
-        120, /* 1100 -> 12.0x */
-        155, /* 1101 -> 15.5x */
-        -1,  /* 1110 -> RESERVED (13.0x) */
-        145 /* 1111 -> 14.5x */
-};
-
-/*
- * Voltage scales. Div/Mod by 1000 to get actual voltage.
- * Which scale to use depends on the VRM type in use.
- */
-
-struct mV_pos {
-        unsigned short mV;
-        unsigned short pos;
-};
-
-static const struct mV_pos __cpuinitdata vrm85_mV[32] = {
-        {1250, 8},      {1200, 6},      {1150, 4},      {1100, 2},
-        {1050, 0},      {1800, 30},     {1750, 28},     {1700, 26},
-        {1650, 24},     {1600, 22},     {1550, 20},     {1500, 18},
-        {1450, 16},     {1400, 14},     {1350, 12},     {1300, 10},
-        {1275, 9},      {1225, 7},      {1175, 5},      {1125, 3},
-        {1075, 1},      {1825, 31},     {1775, 29},     {1725, 27},
-        {1675, 25},     {1625, 23},     {1575, 21},     {1525, 19},
-        {1475, 17},     {1425, 15},     {1375, 13},     {1325, 11}
-};
-
-static const unsigned char __cpuinitdata mV_vrm85[32] = {
-        0x04,   0x14,   0x03,   0x13,   0x02,   0x12,   0x01,   0x11,
-        0x00,   0x10,   0x0f,   0x1f,   0x0e,   0x1e,   0x0d,   0x1d,
-        0x0c,   0x1c,   0x0b,   0x1b,   0x0a,   0x1a,   0x09,   0x19,
-        0x08,   0x18,   0x07,   0x17,   0x06,   0x16,   0x05,   0x15
-};
-
-static const struct mV_pos __cpuinitdata mobilevrm_mV[32] = {
-        {1750, 31},     {1700, 30},     {1650, 29},     {1600, 28},
-        {1550, 27},     {1500, 26},     {1450, 25},     {1400, 24},
-        {1350, 23},     {1300, 22},     {1250, 21},     {1200, 20},
-        {1150, 19},     {1100, 18},     {1050, 17},     {1000, 16},
-        {975, 15},      {950, 14},      {925, 13},      {900, 12},
-        {875, 11},      {850, 10},      {825, 9},       {800, 8},
-        {775, 7},       {750, 6},       {725, 5},       {700, 4},
-        {675, 3},       {650, 2},       {625, 1},       {600, 0}
-};
-
-static const unsigned char __cpuinitdata mV_mobilevrm[32] = {
-        0x1f,   0x1e,   0x1d,   0x1c,   0x1b,   0x1a,   0x19,   0x18,
-        0x17,   0x16,   0x15,   0x14,   0x13,   0x12,   0x11,   0x10,
-        0x0f,   0x0e,   0x0d,   0x0c,   0x0b,   0x0a,   0x09,   0x08,
-        0x07,   0x06,   0x05,   0x04,   0x03,   0x02,   0x01,   0x00
-};
-
diff --git a/arch/x86/kernel/cpu/cpufreq/longrun.c b/arch/x86/kernel/cpu/cpufreq/longrun.c
deleted file mode 100644
index d9f51367666b..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/longrun.c
+++ /dev/null
@@ -1,327 +0,0 @@
-/*
- * (C) 2002 - 2003  Dominik Brodowski <linux@brodo.de>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/timex.h>
-
-#include <asm/msr.h>
-#include <asm/processor.h>
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "longrun", msg)
-
-static struct cpufreq_driver    longrun_driver;
-
-/**
- * longrun_{low,high}_freq is needed for the conversion of cpufreq kHz
- * values into per cent values. In TMTA microcode, the following is valid:
- * performance_pctg = (current_freq - low_freq)/(high_freq - low_freq)
- */
-static unsigned int longrun_low_freq, longrun_high_freq;
-
-
-/**
- * longrun_get_policy - get the current LongRun policy
- * @policy: struct cpufreq_policy where current policy is written into
- *
- * Reads the current LongRun policy by access to MSR_TMTA_LONGRUN_FLAGS
- * and MSR_TMTA_LONGRUN_CTRL
- */
-static void __cpuinit longrun_get_policy(struct cpufreq_policy *policy)
-{
-        u32 msr_lo, msr_hi;
-
-        rdmsr(MSR_TMTA_LONGRUN_FLAGS, msr_lo, msr_hi);
-        dprintk("longrun flags are %x - %x\n", msr_lo, msr_hi);
-        if (msr_lo & 0x01)
-                policy->policy = CPUFREQ_POLICY_PERFORMANCE;
-        else
-                policy->policy = CPUFREQ_POLICY_POWERSAVE;
-
-        rdmsr(MSR_TMTA_LONGRUN_CTRL, msr_lo, msr_hi);
-        dprintk("longrun ctrl is %x - %x\n", msr_lo, msr_hi);
-        msr_lo &= 0x0000007F;
-        msr_hi &= 0x0000007F;
-
-        if (longrun_high_freq <= longrun_low_freq) {
-                /* Assume degenerate Longrun table */
-                policy->min = policy->max = longrun_high_freq;
-        } else {
-                policy->min = longrun_low_freq + msr_lo *
-                        ((longrun_high_freq - longrun_low_freq) / 100);
-                policy->max = longrun_low_freq + msr_hi *
-                        ((longrun_high_freq - longrun_low_freq) / 100);
-        }
-        policy->cpu = 0;
-}
-
-
-/**
- * longrun_set_policy - sets a new CPUFreq policy
- * @policy: new policy
- *
- * Sets a new CPUFreq policy on LongRun-capable processors. This function
- * has to be called with cpufreq_driver locked.
- */
-static int longrun_set_policy(struct cpufreq_policy *policy)
-{
-        u32 msr_lo, msr_hi;
-        u32 pctg_lo, pctg_hi;
-
-        if (!policy)
-                return -EINVAL;
-
-        if (longrun_high_freq <= longrun_low_freq) {
-                /* Assume degenerate Longrun table */
-                pctg_lo = pctg_hi = 100;
-        } else {
-                pctg_lo = (policy->min - longrun_low_freq) /
-                        ((longrun_high_freq - longrun_low_freq) / 100);
-                pctg_hi = (policy->max - longrun_low_freq) /
-                        ((longrun_high_freq - longrun_low_freq) / 100);
-        }
-
-        if (pctg_hi > 100)
-                pctg_hi = 100;
-        if (pctg_lo > pctg_hi)
-                pctg_lo = pctg_hi;
-
-        /* performance or economy mode */
-        rdmsr(MSR_TMTA_LONGRUN_FLAGS, msr_lo, msr_hi);
-        msr_lo &= 0xFFFFFFFE;
-        switch (policy->policy) {
-        case CPUFREQ_POLICY_PERFORMANCE:
-                msr_lo |= 0x00000001;
-                break;
-        case CPUFREQ_POLICY_POWERSAVE:
-                break;
-        }
-        wrmsr(MSR_TMTA_LONGRUN_FLAGS, msr_lo, msr_hi);
-
-        /* lower and upper boundary */
-        rdmsr(MSR_TMTA_LONGRUN_CTRL, msr_lo, msr_hi);
-        msr_lo &= 0xFFFFFF80;
-        msr_hi &= 0xFFFFFF80;
-        msr_lo |= pctg_lo;
-        msr_hi |= pctg_hi;
-        wrmsr(MSR_TMTA_LONGRUN_CTRL, msr_lo, msr_hi);
-
-        return 0;
-}
-
-
-/**
- * longrun_verify_poliy - verifies a new CPUFreq policy
- * @policy: the policy to verify
- *
- * Validates a new CPUFreq policy. This function has to be called with
- * cpufreq_driver locked.
- */
-static int longrun_verify_policy(struct cpufreq_policy *policy)
-{
-        if (!policy)
-                return -EINVAL;
-
-        policy->cpu = 0;
-        cpufreq_verify_within_limits(policy,
-                policy->cpuinfo.min_freq,
-                policy->cpuinfo.max_freq);
-
-        if ((policy->policy != CPUFREQ_POLICY_POWERSAVE) &&
-            (policy->policy != CPUFREQ_POLICY_PERFORMANCE))
-                return -EINVAL;
-
-        return 0;
-}
-
-static unsigned int longrun_get(unsigned int cpu)
-{
-        u32 eax, ebx, ecx, edx;
-
-        if (cpu)
-                return 0;
-
-        cpuid(0x80860007, &eax, &ebx, &ecx, &edx);
-        dprintk("cpuid eax is %u\n", eax);
-
-        return eax * 1000;
-}
-
-/**
- * longrun_determine_freqs - determines the lowest and highest possible core frequency
- * @low_freq: an int to put the lowest frequency into
- * @high_freq: an int to put the highest frequency into
- *
- * Determines the lowest and highest possible core frequencies on this CPU.
- * This is necessary to calculate the performance percentage according to
- * TMTA rules:
- * performance_pctg = (target_freq - low_freq)/(high_freq - low_freq)
- */
-static int __cpuinit longrun_determine_freqs(unsigned int *low_freq,
-                                                      unsigned int *high_freq)
-{
-        u32 msr_lo, msr_hi;
-        u32 save_lo, save_hi;
-        u32 eax, ebx, ecx, edx;
-        u32 try_hi;
-        struct cpuinfo_x86 *c = &cpu_data(0);
-
-        if (!low_freq || !high_freq)
-                return -EINVAL;
-
-        if (cpu_has(c, X86_FEATURE_LRTI)) {
-                /* if the LongRun Table Interface is present, the
-                 * detection is a bit easier:
-                 * For minimum frequency, read out the maximum
-                 * level (msr_hi), write that into "currently
-                 * selected level", and read out the frequency.
-                 * For maximum frequency, read out level zero.
-                 */
-                /* minimum */
-                rdmsr(MSR_TMTA_LRTI_READOUT, msr_lo, msr_hi);
-                wrmsr(MSR_TMTA_LRTI_READOUT, msr_hi, msr_hi);
-                rdmsr(MSR_TMTA_LRTI_VOLT_MHZ, msr_lo, msr_hi);
-                *low_freq = msr_lo * 1000; /* to kHz */
-
-                /* maximum */
-                wrmsr(MSR_TMTA_LRTI_READOUT, 0, msr_hi);
-                rdmsr(MSR_TMTA_LRTI_VOLT_MHZ, msr_lo, msr_hi);
-                *high_freq = msr_lo * 1000; /* to kHz */
-
-                dprintk("longrun table interface told %u - %u kHz\n",
-                                *low_freq, *high_freq);
-
-                if (*low_freq > *high_freq)
-                        *low_freq = *high_freq;
-                return 0;
-        }
-
-        /* set the upper border to the value determined during TSC init */
-        *high_freq = (cpu_khz / 1000);
-        *high_freq = *high_freq * 1000;
-        dprintk("high frequency is %u kHz\n", *high_freq);
-
-        /* get current borders */
-        rdmsr(MSR_TMTA_LONGRUN_CTRL, msr_lo, msr_hi);
-        save_lo = msr_lo & 0x0000007F;
-        save_hi = msr_hi & 0x0000007F;
-
-        /* if current perf_pctg is larger than 90%, we need to decrease the
-         * upper limit to make the calculation more accurate.
-         */
-        cpuid(0x80860007, &eax, &ebx, &ecx, &edx);
-        /* try decreasing in 10% steps, some processors react only
-         * on some barrier values */
-        for (try_hi = 80; try_hi > 0 && ecx > 90; try_hi -= 10) {
-                /* set to 0 to try_hi perf_pctg */
-                msr_lo &= 0xFFFFFF80;
-                msr_hi &= 0xFFFFFF80;
-                msr_hi |= try_hi;
-                wrmsr(MSR_TMTA_LONGRUN_CTRL, msr_lo, msr_hi);
-
-                /* read out current core MHz and current perf_pctg */
-                cpuid(0x80860007, &eax, &ebx, &ecx, &edx);
-
-                /* restore values */
-                wrmsr(MSR_TMTA_LONGRUN_CTRL, save_lo, save_hi);
-        }
-        dprintk("percentage is %u %%, freq is %u MHz\n", ecx, eax);
-
-        /* performance_pctg = (current_freq - low_freq)/(high_freq - low_freq)
-         * eqals
-         * low_freq * (1 - perf_pctg) = (cur_freq - high_freq * perf_pctg)
-         *
-         * high_freq * perf_pctg is stored tempoarily into "ebx".
-         */
-        ebx = (((cpu_khz / 1000) * ecx) / 100); /* to MHz */
-
-        if ((ecx > 95) || (ecx == 0) || (eax < ebx))
-                return -EIO;
-
-        edx = ((eax - ebx) * 100) / (100 - ecx);
-        *low_freq = edx * 1000; /* back to kHz */
-
-        dprintk("low frequency is %u kHz\n", *low_freq);
-
-        if (*low_freq > *high_freq)
-                *low_freq = *high_freq;
-
-        return 0;
-}
-
-
-static int __cpuinit longrun_cpu_init(struct cpufreq_policy *policy)
-{
-        int result = 0;
-
-        /* capability check */
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        /* detect low and high frequency */
-        result = longrun_determine_freqs(&longrun_low_freq, &longrun_high_freq);
-        if (result)
-                return result;
-
-        /* cpuinfo and default policy values */
-        policy->cpuinfo.min_freq = longrun_low_freq;
-        policy->cpuinfo.max_freq = longrun_high_freq;
-        policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
-        longrun_get_policy(policy);
-
-        return 0;
-}
-
-
-static struct cpufreq_driver longrun_driver = {
-        .flags          = CPUFREQ_CONST_LOOPS,
-        .verify         = longrun_verify_policy,
-        .setpolicy      = longrun_set_policy,
-        .get            = longrun_get,
-        .init           = longrun_cpu_init,
-        .name           = "longrun",
-        .owner          = THIS_MODULE,
-};
-
-
-/**
- * longrun_init - initializes the Transmeta Crusoe LongRun CPUFreq driver
- *
- * Initializes the LongRun support.
- */
-static int __init longrun_init(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-
-        if (c->x86_vendor != X86_VENDOR_TRANSMETA ||
-            !cpu_has(c, X86_FEATURE_LONGRUN))
-                return -ENODEV;
-
-        return cpufreq_register_driver(&longrun_driver);
-}
-
-
-/**
- * longrun_exit - unregisters LongRun support
- */
-static void __exit longrun_exit(void)
-{
-        cpufreq_unregister_driver(&longrun_driver);
-}
-
-
-MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
-MODULE_DESCRIPTION("LongRun driver for Transmeta Crusoe and "
-                "Efficeon processors.");
-MODULE_LICENSE("GPL");
-
-module_init(longrun_init);
-module_exit(longrun_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/mperf.c b/arch/x86/kernel/cpu/cpufreq/mperf.c
deleted file mode 100644
index 911e193018ae..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/mperf.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <linux/kernel.h>
-#include <linux/smp.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/slab.h>
-
-#include "mperf.h"
-
-static DEFINE_PER_CPU(struct aperfmperf, acfreq_old_perf);
-
-/* Called via smp_call_function_single(), on the target CPU */
-static void read_measured_perf_ctrs(void *_cur)
-{
-        struct aperfmperf *am = _cur;
-
-        get_aperfmperf(am);
-}
-
-/*
- * Return the measured active (C0) frequency on this CPU since last call
- * to this function.
- * Input: cpu number
- * Return: Average CPU frequency in terms of max frequency (zero on error)
- *
- * We use IA32_MPERF and IA32_APERF MSRs to get the measured performance
- * over a period of time, while CPU is in C0 state.
- * IA32_MPERF counts at the rate of max advertised frequency
- * IA32_APERF counts at the rate of actual CPU frequency
- * Only IA32_APERF/IA32_MPERF ratio is architecturally defined and
- * no meaning should be associated with absolute values of these MSRs.
- */
-unsigned int cpufreq_get_measured_perf(struct cpufreq_policy *policy,
-                                        unsigned int cpu)
-{
-        struct aperfmperf perf;
-        unsigned long ratio;
-        unsigned int retval;
-
-        if (smp_call_function_single(cpu, read_measured_perf_ctrs, &perf, 1))
-                return 0;
-
-        ratio = calc_aperfmperf_ratio(&per_cpu(acfreq_old_perf, cpu), &perf);
-        per_cpu(acfreq_old_perf, cpu) = perf;
-
-        retval = (policy->cpuinfo.max_freq * ratio) >> APERFMPERF_SHIFT;
-
-        return retval;
-}
-EXPORT_SYMBOL_GPL(cpufreq_get_measured_perf);
-MODULE_LICENSE("GPL");
diff --git a/arch/x86/kernel/cpu/cpufreq/mperf.h b/arch/x86/kernel/cpu/cpufreq/mperf.h
deleted file mode 100644
index 5dbf2950dc22..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/mperf.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
- *  (c) 2010 Advanced Micro Devices, Inc.
- *  Your use of this code is subject to the terms and conditions of the
- *  GNU general public license version 2. See "COPYING" or
- *  http://www.gnu.org/licenses/gpl.html
- */
-
-unsigned int cpufreq_get_measured_perf(struct cpufreq_policy *policy,
-                                        unsigned int cpu);
diff --git a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c b/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
deleted file mode 100644
index 52c93648e492..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/p4-clockmod.c
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- *      Pentium 4/Xeon CPU on demand clock modulation/speed scaling
- *      (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
- *      (C) 2002 Zwane Mwaikambo <zwane@commfireservices.com>
- *      (C) 2002 Arjan van de Ven <arjanv@redhat.com>
- *      (C) 2002 Tora T. Engstad
- *      All Rights Reserved
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- *      The author(s) of this software shall not be held liable for damages
- *      of any nature resulting due to the use of this software. This
- *      software is provided AS-IS with no warranties.
- *
- *      Date            Errata                  Description
- *      20020525        N44, O17        12.5% or 25% DC causes lockup
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/smp.h>
-#include <linux/cpufreq.h>
-#include <linux/cpumask.h>
-#include <linux/timex.h>
-
-#include <asm/processor.h>
-#include <asm/msr.h>
-#include <asm/timer.h>
-
-#include "speedstep-lib.h"
-
-#define PFX     "p4-clockmod: "
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "p4-clockmod", msg)
-
-/*
- * Duty Cycle (3bits), note DC_DISABLE is not specified in
- * intel docs i just use it to mean disable
- */
-enum {
-        DC_RESV, DC_DFLT, DC_25PT, DC_38PT, DC_50PT,
-        DC_64PT, DC_75PT, DC_88PT, DC_DISABLE
-};
-
-#define DC_ENTRIES      8
-
-
-static int has_N44_O17_errata[NR_CPUS];
-static unsigned int stock_freq;
-static struct cpufreq_driver p4clockmod_driver;
-static unsigned int cpufreq_p4_get(unsigned int cpu);
-
-static int cpufreq_p4_setdc(unsigned int cpu, unsigned int newstate)
-{
-        u32 l, h;
-
-        if (!cpu_online(cpu) ||
-            (newstate > DC_DISABLE) || (newstate == DC_RESV))
-                return -EINVAL;
-
-        rdmsr_on_cpu(cpu, MSR_IA32_THERM_STATUS, &l, &h);
-
-        if (l & 0x01)
-                dprintk("CPU#%d currently thermal throttled\n", cpu);
-
-        if (has_N44_O17_errata[cpu] &&
-            (newstate == DC_25PT || newstate == DC_DFLT))
-                newstate = DC_38PT;
-
-        rdmsr_on_cpu(cpu, MSR_IA32_THERM_CONTROL, &l, &h);
-        if (newstate == DC_DISABLE) {
-                dprintk("CPU#%d disabling modulation\n", cpu);
-                wrmsr_on_cpu(cpu, MSR_IA32_THERM_CONTROL, l & ~(1<<4), h);
-        } else {
-                dprintk("CPU#%d setting duty cycle to %d%%\n",
-                        cpu, ((125 * newstate) / 10));
-                /* bits 63 - 5  : reserved
-                 * bit  4       : enable/disable
-                 * bits 3-1     : duty cycle
-                 * bit  0       : reserved
-                 */
-                l = (l & ~14);
-                l = l | (1<<4) | ((newstate & 0x7)<<1);
-                wrmsr_on_cpu(cpu, MSR_IA32_THERM_CONTROL, l, h);
-        }
-
-        return 0;
-}
-
-
-static struct cpufreq_frequency_table p4clockmod_table[] = {
-        {DC_RESV, CPUFREQ_ENTRY_INVALID},
-        {DC_DFLT, 0},
-        {DC_25PT, 0},
-        {DC_38PT, 0},
-        {DC_50PT, 0},
-        {DC_64PT, 0},
-        {DC_75PT, 0},
-        {DC_88PT, 0},
-        {DC_DISABLE, 0},
-        {DC_RESV, CPUFREQ_TABLE_END},
-};
-
-
-static int cpufreq_p4_target(struct cpufreq_policy *policy,
-                             unsigned int target_freq,
-                             unsigned int relation)
-{
-        unsigned int    newstate = DC_RESV;
-        struct cpufreq_freqs freqs;
-        int i;
-
-        if (cpufreq_frequency_table_target(policy, &p4clockmod_table[0],
-                                target_freq, relation, &newstate))
-                return -EINVAL;
-
-        freqs.old = cpufreq_p4_get(policy->cpu);
-        freqs.new = stock_freq * p4clockmod_table[newstate].index / 8;
-
-        if (freqs.new == freqs.old)
-                return 0;
-
-        /* notifiers */
-        for_each_cpu(i, policy->cpus) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        }
-
-        /* run on each logical CPU,
-         * see section 13.15.3 of IA32 Intel Architecture Software
-         * Developer's Manual, Volume 3
-         */
-        for_each_cpu(i, policy->cpus)
-                cpufreq_p4_setdc(i, p4clockmod_table[newstate].index);
-
-        /* notifiers */
-        for_each_cpu(i, policy->cpus) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        }
-
-        return 0;
-}
-
-
-static int cpufreq_p4_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, &p4clockmod_table[0]);
-}
-
-
-static unsigned int cpufreq_p4_get_frequency(struct cpuinfo_x86 *c)
-{
-        if (c->x86 == 0x06) {
-                if (cpu_has(c, X86_FEATURE_EST))
-                        printk_once(KERN_WARNING PFX "Warning: EST-capable "
-                               "CPU detected. The acpi-cpufreq module offers "
-                               "voltage scaling in addition to frequency "
-                               "scaling. You should use that instead of "
-                               "p4-clockmod, if possible.\n");
-                switch (c->x86_model) {
-                case 0x0E: /* Core */
-                case 0x0F: /* Core Duo */
-                case 0x16: /* Celeron Core */
-                case 0x1C: /* Atom */
-                        p4clockmod_driver.flags |= CPUFREQ_CONST_LOOPS;
-                        return speedstep_get_frequency(SPEEDSTEP_CPU_PCORE);
-                case 0x0D: /* Pentium M (Dothan) */
-                        p4clockmod_driver.flags |= CPUFREQ_CONST_LOOPS;
-                        /* fall through */
-                case 0x09: /* Pentium M (Banias) */
-                        return speedstep_get_frequency(SPEEDSTEP_CPU_PM);
-                }
-        }
-
-        if (c->x86 != 0xF)
-                return 0;
-
-        /* on P-4s, the TSC runs with constant frequency independent whether
-         * throttling is active or not. */
-        p4clockmod_driver.flags |= CPUFREQ_CONST_LOOPS;
-
-        if (speedstep_detect_processor() == SPEEDSTEP_CPU_P4M) {
-                printk(KERN_WARNING PFX "Warning: Pentium 4-M detected. "
-                       "The speedstep-ich or acpi cpufreq modules offer "
-                       "voltage scaling in addition of frequency scaling. "
-                       "You should use either one instead of p4-clockmod, "
-                       "if possible.\n");
-                return speedstep_get_frequency(SPEEDSTEP_CPU_P4M);
-        }
-
-        return speedstep_get_frequency(SPEEDSTEP_CPU_P4D);
-}
-
-
-
-static int cpufreq_p4_cpu_init(struct cpufreq_policy *policy)
-{
-        struct cpuinfo_x86 *c = &cpu_data(policy->cpu);
-        int cpuid = 0;
-        unsigned int i;
-
-#ifdef CONFIG_SMP
-        cpumask_copy(policy->cpus, cpu_sibling_mask(policy->cpu));
-#endif
-
-        /* Errata workaround */
-        cpuid = (c->x86 << 8) | (c->x86_model << 4) | c->x86_mask;
-        switch (cpuid) {
-        case 0x0f07:
-        case 0x0f0a:
-        case 0x0f11:
-        case 0x0f12:
-                has_N44_O17_errata[policy->cpu] = 1;
-                dprintk("has errata -- disabling low frequencies\n");
-        }
-
-        if (speedstep_detect_processor() == SPEEDSTEP_CPU_P4D &&
-            c->x86_model < 2) {
-                /* switch to maximum frequency and measure result */
-                cpufreq_p4_setdc(policy->cpu, DC_DISABLE);
-                recalibrate_cpu_khz();
-        }
-        /* get max frequency */
-        stock_freq = cpufreq_p4_get_frequency(c);
-        if (!stock_freq)
-                return -EINVAL;
-
-        /* table init */
-        for (i = 1; (p4clockmod_table[i].frequency != CPUFREQ_TABLE_END); i++) {
-                if ((i < 2) && (has_N44_O17_errata[policy->cpu]))
-                        p4clockmod_table[i].frequency = CPUFREQ_ENTRY_INVALID;
-                else
-                        p4clockmod_table[i].frequency = (stock_freq * i)/8;
-        }
-        cpufreq_frequency_table_get_attr(p4clockmod_table, policy->cpu);
-
-        /* cpuinfo and default policy values */
-
-        /* the transition latency is set to be 1 higher than the maximum
-         * transition latency of the ondemand governor */
-        policy->cpuinfo.transition_latency = 10000001;
-        policy->cur = stock_freq;
-
-        return cpufreq_frequency_table_cpuinfo(policy, &p4clockmod_table[0]);
-}
-
-
-static int cpufreq_p4_cpu_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
-static unsigned int cpufreq_p4_get(unsigned int cpu)
-{
-        u32 l, h;
-
-        rdmsr_on_cpu(cpu, MSR_IA32_THERM_CONTROL, &l, &h);
-
-        if (l & 0x10) {
-                l = l >> 1;
-                l &= 0x7;
-        } else
-                l = DC_DISABLE;
-
-        if (l != DC_DISABLE)
-                return stock_freq * l / 8;
-
-        return stock_freq;
-}
-
-static struct freq_attr *p4clockmod_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver p4clockmod_driver = {
-        .verify         = cpufreq_p4_verify,
-        .target         = cpufreq_p4_target,
-        .init           = cpufreq_p4_cpu_init,
-        .exit           = cpufreq_p4_cpu_exit,
-        .get            = cpufreq_p4_get,
-        .name           = "p4-clockmod",
-        .owner          = THIS_MODULE,
-        .attr           = p4clockmod_attr,
-};
-
-
-static int __init cpufreq_p4_init(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        int ret;
-
-        /*
-         * THERM_CONTROL is architectural for IA32 now, so
-         * we can rely on the capability checks
-         */
-        if (c->x86_vendor != X86_VENDOR_INTEL)
-                return -ENODEV;
-
-        if (!test_cpu_cap(c, X86_FEATURE_ACPI) ||
-                                !test_cpu_cap(c, X86_FEATURE_ACC))
-                return -ENODEV;
-
-        ret = cpufreq_register_driver(&p4clockmod_driver);
-        if (!ret)
-                printk(KERN_INFO PFX "P4/Xeon(TM) CPU On-Demand Clock "
-                                "Modulation available\n");
-
-        return ret;
-}
-
-
-static void __exit cpufreq_p4_exit(void)
-{
-        cpufreq_unregister_driver(&p4clockmod_driver);
-}
-
-
-MODULE_AUTHOR("Zwane Mwaikambo <zwane@commfireservices.com>");
-MODULE_DESCRIPTION("cpufreq driver for Pentium(TM) 4/Xeon(TM)");
-MODULE_LICENSE("GPL");
-
-late_initcall(cpufreq_p4_init);
-module_exit(cpufreq_p4_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/pcc-cpufreq.c b/arch/x86/kernel/cpu/cpufreq/pcc-cpufreq.c
deleted file mode 100644
index 755a31e0f5b0..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/pcc-cpufreq.c
+++ /dev/null
@@ -1,624 +0,0 @@
-/*
- *  pcc-cpufreq.c - Processor Clocking Control firmware cpufreq interface
- *
- *  Copyright (C) 2009 Red Hat, Matthew Garrett <mjg@redhat.com>
- *  Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
- *      Nagananda Chumbalkar <nagananda.chumbalkar@hp.com>
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; version 2 of the License.
- *
- *  This program is distributed in the hope that it will be useful, but
- *  WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or NON
- *  INFRINGEMENT. See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/smp.h>
-#include <linux/sched.h>
-#include <linux/cpufreq.h>
-#include <linux/compiler.h>
-#include <linux/slab.h>
-
-#include <linux/acpi.h>
-#include <linux/io.h>
-#include <linux/spinlock.h>
-#include <linux/uaccess.h>
-
-#include <acpi/processor.h>
-
-#define PCC_VERSION     "1.00.00"
-#define POLL_LOOPS      300
-
-#define CMD_COMPLETE    0x1
-#define CMD_GET_FREQ    0x0
-#define CMD_SET_FREQ    0x1
-
-#define BUF_SZ          4
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER,      \
-                                             "pcc-cpufreq", msg)
-
-struct pcc_register_resource {
-        u8 descriptor;
-        u16 length;
-        u8 space_id;
-        u8 bit_width;
-        u8 bit_offset;
-        u8 access_size;
-        u64 address;
-} __attribute__ ((packed));
-
-struct pcc_memory_resource {
-        u8 descriptor;
-        u16 length;
-        u8 space_id;
-        u8 resource_usage;
-        u8 type_specific;
-        u64 granularity;
-        u64 minimum;
-        u64 maximum;
-        u64 translation_offset;
-        u64 address_length;
-} __attribute__ ((packed));
-
-static struct cpufreq_driver pcc_cpufreq_driver;
-
-struct pcc_header {
-        u32 signature;
-        u16 length;
-        u8 major;
-        u8 minor;
-        u32 features;
-        u16 command;
-        u16 status;
-        u32 latency;
-        u32 minimum_time;
-        u32 maximum_time;
-        u32 nominal;
-        u32 throttled_frequency;
-        u32 minimum_frequency;
-};
-
-static void __iomem *pcch_virt_addr;
-static struct pcc_header __iomem *pcch_hdr;
-
-static DEFINE_SPINLOCK(pcc_lock);
-
-static struct acpi_generic_address doorbell;
-
-static u64 doorbell_preserve;
-static u64 doorbell_write;
-
-static u8 OSC_UUID[16] = {0x63, 0x9B, 0x2C, 0x9F, 0x70, 0x91, 0x49, 0x1f,
-                          0xBB, 0x4F, 0xA5, 0x98, 0x2F, 0xA1, 0xB5, 0x46};
-
-struct pcc_cpu {
-        u32 input_offset;
-        u32 output_offset;
-};
-
-static struct pcc_cpu __percpu *pcc_cpu_info;
-
-static int pcc_cpufreq_verify(struct cpufreq_policy *policy)
-{
-        cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
-                                     policy->cpuinfo.max_freq);
-        return 0;
-}
-
-static inline void pcc_cmd(void)
-{
-        u64 doorbell_value;
-        int i;
-
-        acpi_read(&doorbell_value, &doorbell);
-        acpi_write((doorbell_value & doorbell_preserve) | doorbell_write,
-                   &doorbell);
-
-        for (i = 0; i < POLL_LOOPS; i++) {
-                if (ioread16(&pcch_hdr->status) & CMD_COMPLETE)
-                        break;
-        }
-}
-
-static inline void pcc_clear_mapping(void)
-{
-        if (pcch_virt_addr)
-                iounmap(pcch_virt_addr);
-        pcch_virt_addr = NULL;
-}
-
-static unsigned int pcc_get_freq(unsigned int cpu)
-{
-        struct pcc_cpu *pcc_cpu_data;
-        unsigned int curr_freq;
-        unsigned int freq_limit;
-        u16 status;
-        u32 input_buffer;
-        u32 output_buffer;
-
-        spin_lock(&pcc_lock);
-
-        dprintk("get: get_freq for CPU %d\n", cpu);
-        pcc_cpu_data = per_cpu_ptr(pcc_cpu_info, cpu);
-
-        input_buffer = 0x1;
-        iowrite32(input_buffer,
-                        (pcch_virt_addr + pcc_cpu_data->input_offset));
-        iowrite16(CMD_GET_FREQ, &pcch_hdr->command);
-
-        pcc_cmd();
-
-        output_buffer =
-                ioread32(pcch_virt_addr + pcc_cpu_data->output_offset);
-
-        /* Clear the input buffer - we are done with the current command */
-        memset_io((pcch_virt_addr + pcc_cpu_data->input_offset), 0, BUF_SZ);
-
-        status = ioread16(&pcch_hdr->status);
-        if (status != CMD_COMPLETE) {
-                dprintk("get: FAILED: for CPU %d, status is %d\n",
-                        cpu, status);
-                goto cmd_incomplete;
-        }
-        iowrite16(0, &pcch_hdr->status);
-        curr_freq = (((ioread32(&pcch_hdr->nominal) * (output_buffer & 0xff))
-                        / 100) * 1000);
-
-        dprintk("get: SUCCESS: (virtual) output_offset for cpu %d is "
-                "0x%x, contains a value of: 0x%x. Speed is: %d MHz\n",
-                cpu, (pcch_virt_addr + pcc_cpu_data->output_offset),
-                output_buffer, curr_freq);
-
-        freq_limit = (output_buffer >> 8) & 0xff;
-        if (freq_limit != 0xff) {
-                dprintk("get: frequency for cpu %d is being temporarily"
-                        " capped at %d\n", cpu, curr_freq);
-        }
-
-        spin_unlock(&pcc_lock);
-        return curr_freq;
-
-cmd_incomplete:
-        iowrite16(0, &pcch_hdr->status);
-        spin_unlock(&pcc_lock);
-        return 0;
-}
-
-static int pcc_cpufreq_target(struct cpufreq_policy *policy,
-                              unsigned int target_freq,
-                              unsigned int relation)
-{
-        struct pcc_cpu *pcc_cpu_data;
-        struct cpufreq_freqs freqs;
-        u16 status;
-        u32 input_buffer;
-        int cpu;
-
-        spin_lock(&pcc_lock);
-        cpu = policy->cpu;
-        pcc_cpu_data = per_cpu_ptr(pcc_cpu_info, cpu);
-
-        dprintk("target: CPU %d should go to target freq: %d "
-                "(virtual) input_offset is 0x%x\n",
-                cpu, target_freq,
-                (pcch_virt_addr + pcc_cpu_data->input_offset));
-
-        freqs.new = target_freq;
-        freqs.cpu = cpu;
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        input_buffer = 0x1 | (((target_freq * 100)
-                               / (ioread32(&pcch_hdr->nominal) * 1000)) << 8);
-        iowrite32(input_buffer,
-                        (pcch_virt_addr + pcc_cpu_data->input_offset));
-        iowrite16(CMD_SET_FREQ, &pcch_hdr->command);
-
-        pcc_cmd();
-
-        /* Clear the input buffer - we are done with the current command */
-        memset_io((pcch_virt_addr + pcc_cpu_data->input_offset), 0, BUF_SZ);
-
-        status = ioread16(&pcch_hdr->status);
-        if (status != CMD_COMPLETE) {
-                dprintk("target: FAILED for cpu %d, with status: 0x%x\n",
-                        cpu, status);
-                goto cmd_incomplete;
-        }
-        iowrite16(0, &pcch_hdr->status);
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        dprintk("target: was SUCCESSFUL for cpu %d\n", cpu);
-        spin_unlock(&pcc_lock);
-
-        return 0;
-
-cmd_incomplete:
-        iowrite16(0, &pcch_hdr->status);
-        spin_unlock(&pcc_lock);
-        return -EINVAL;
-}
-
-static int pcc_get_offset(int cpu)
-{
-        acpi_status status;
-        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
-        union acpi_object *pccp, *offset;
-        struct pcc_cpu *pcc_cpu_data;
-        struct acpi_processor *pr;
-        int ret = 0;
-
-        pr = per_cpu(processors, cpu);
-        pcc_cpu_data = per_cpu_ptr(pcc_cpu_info, cpu);
-
-        status = acpi_evaluate_object(pr->handle, "PCCP", NULL, &buffer);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        pccp = buffer.pointer;
-        if (!pccp || pccp->type != ACPI_TYPE_PACKAGE) {
-                ret = -ENODEV;
-                goto out_free;
-        };
-
-        offset = &(pccp->package.elements[0]);
-        if (!offset || offset->type != ACPI_TYPE_INTEGER) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        pcc_cpu_data->input_offset = offset->integer.value;
-
-        offset = &(pccp->package.elements[1]);
-        if (!offset || offset->type != ACPI_TYPE_INTEGER) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        pcc_cpu_data->output_offset = offset->integer.value;
-
-        memset_io((pcch_virt_addr + pcc_cpu_data->input_offset), 0, BUF_SZ);
-        memset_io((pcch_virt_addr + pcc_cpu_data->output_offset), 0, BUF_SZ);
-
-        dprintk("pcc_get_offset: for CPU %d: pcc_cpu_data "
-                "input_offset: 0x%x, pcc_cpu_data output_offset: 0x%x\n",
-                cpu, pcc_cpu_data->input_offset, pcc_cpu_data->output_offset);
-out_free:
-        kfree(buffer.pointer);
-        return ret;
-}
-
-static int __init pcc_cpufreq_do_osc(acpi_handle *handle)
-{
-        acpi_status status;
-        struct acpi_object_list input;
-        struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
-        union acpi_object in_params[4];
-        union acpi_object *out_obj;
-        u32 capabilities[2];
-        u32 errors;
-        u32 supported;
-        int ret = 0;
-
-        input.count = 4;
-        input.pointer = in_params;
-        in_params[0].type               = ACPI_TYPE_BUFFER;
-        in_params[0].buffer.length      = 16;
-        in_params[0].buffer.pointer     = OSC_UUID;
-        in_params[1].type               = ACPI_TYPE_INTEGER;
-        in_params[1].integer.value      = 1;
-        in_params[2].type               = ACPI_TYPE_INTEGER;
-        in_params[2].integer.value      = 2;
-        in_params[3].type               = ACPI_TYPE_BUFFER;
-        in_params[3].buffer.length      = 8;
-        in_params[3].buffer.pointer     = (u8 *)&capabilities;
-
-        capabilities[0] = OSC_QUERY_ENABLE;
-        capabilities[1] = 0x1;
-
-        status = acpi_evaluate_object(*handle, "_OSC", &input, &output);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        if (!output.length)
-                return -ENODEV;
-
-        out_obj = output.pointer;
-        if (out_obj->type != ACPI_TYPE_BUFFER) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
-        if (errors) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        supported = *((u32 *)(out_obj->buffer.pointer + 4));
-        if (!(supported & 0x1)) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        kfree(output.pointer);
-        capabilities[0] = 0x0;
-        capabilities[1] = 0x1;
-
-        status = acpi_evaluate_object(*handle, "_OSC", &input, &output);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        if (!output.length)
-                return -ENODEV;
-
-        out_obj = output.pointer;
-        if (out_obj->type != ACPI_TYPE_BUFFER) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        errors = *((u32 *)out_obj->buffer.pointer) & ~(1 << 0);
-        if (errors) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        supported = *((u32 *)(out_obj->buffer.pointer + 4));
-        if (!(supported & 0x1)) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-out_free:
-        kfree(output.pointer);
-        return ret;
-}
-
-static int __init pcc_cpufreq_probe(void)
-{
-        acpi_status status;
-        struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL};
-        struct pcc_memory_resource *mem_resource;
-        struct pcc_register_resource *reg_resource;
-        union acpi_object *out_obj, *member;
-        acpi_handle handle, osc_handle, pcch_handle;
-        int ret = 0;
-
-        status = acpi_get_handle(NULL, "\\_SB", &handle);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        status = acpi_get_handle(handle, "PCCH", &pcch_handle);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        status = acpi_get_handle(handle, "_OSC", &osc_handle);
-        if (ACPI_SUCCESS(status)) {
-                ret = pcc_cpufreq_do_osc(&osc_handle);
-                if (ret)
-                        dprintk("probe: _OSC evaluation did not succeed\n");
-                /* Firmware's use of _OSC is optional */
-                ret = 0;
-        }
-
-        status = acpi_evaluate_object(handle, "PCCH", NULL, &output);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        out_obj = output.pointer;
-        if (out_obj->type != ACPI_TYPE_PACKAGE) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        member = &out_obj->package.elements[0];
-        if (member->type != ACPI_TYPE_BUFFER) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        mem_resource = (struct pcc_memory_resource *)member->buffer.pointer;
-
-        dprintk("probe: mem_resource descriptor: 0x%x,"
-                " length: %d, space_id: %d, resource_usage: %d,"
-                " type_specific: %d, granularity: 0x%llx,"
-                " minimum: 0x%llx, maximum: 0x%llx,"
-                " translation_offset: 0x%llx, address_length: 0x%llx\n",
-                mem_resource->descriptor, mem_resource->length,
-                mem_resource->space_id, mem_resource->resource_usage,
-                mem_resource->type_specific, mem_resource->granularity,
-                mem_resource->minimum, mem_resource->maximum,
-                mem_resource->translation_offset,
-                mem_resource->address_length);
-
-        if (mem_resource->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) {
-                ret = -ENODEV;
-                goto out_free;
-        }
-
-        pcch_virt_addr = ioremap_nocache(mem_resource->minimum,
-                                        mem_resource->address_length);
-        if (pcch_virt_addr == NULL) {
-                dprintk("probe: could not map shared mem region\n");
-                goto out_free;
-        }
-        pcch_hdr = pcch_virt_addr;
-
-        dprintk("probe: PCCH header (virtual) addr: 0x%p\n", pcch_hdr);
-        dprintk("probe: PCCH header is at physical address: 0x%llx,"
-                " signature: 0x%x, length: %d bytes, major: %d, minor: %d,"
-                " supported features: 0x%x, command field: 0x%x,"
-                " status field: 0x%x, nominal latency: %d us\n",
-                mem_resource->minimum, ioread32(&pcch_hdr->signature),
-                ioread16(&pcch_hdr->length), ioread8(&pcch_hdr->major),
-                ioread8(&pcch_hdr->minor), ioread32(&pcch_hdr->features),
-                ioread16(&pcch_hdr->command), ioread16(&pcch_hdr->status),
-                ioread32(&pcch_hdr->latency));
-
-        dprintk("probe: min time between commands: %d us,"
-                " max time between commands: %d us,"
-                " nominal CPU frequency: %d MHz,"
-                " minimum CPU frequency: %d MHz,"
-                " minimum CPU frequency without throttling: %d MHz\n",
-                ioread32(&pcch_hdr->minimum_time),
-                ioread32(&pcch_hdr->maximum_time),
-                ioread32(&pcch_hdr->nominal),
-                ioread32(&pcch_hdr->throttled_frequency),
-                ioread32(&pcch_hdr->minimum_frequency));
-
-        member = &out_obj->package.elements[1];
-        if (member->type != ACPI_TYPE_BUFFER) {
-                ret = -ENODEV;
-                goto pcch_free;
-        }
-
-        reg_resource = (struct pcc_register_resource *)member->buffer.pointer;
-
-        doorbell.space_id = reg_resource->space_id;
-        doorbell.bit_width = reg_resource->bit_width;
-        doorbell.bit_offset = reg_resource->bit_offset;
-        doorbell.access_width = 64;
-        doorbell.address = reg_resource->address;
-
-        dprintk("probe: doorbell: space_id is %d, bit_width is %d, "
-                "bit_offset is %d, access_width is %d, address is 0x%llx\n",
-                doorbell.space_id, doorbell.bit_width, doorbell.bit_offset,
-                doorbell.access_width, reg_resource->address);
-
-        member = &out_obj->package.elements[2];
-        if (member->type != ACPI_TYPE_INTEGER) {
-                ret = -ENODEV;
-                goto pcch_free;
-        }
-
-        doorbell_preserve = member->integer.value;
-
-        member = &out_obj->package.elements[3];
-        if (member->type != ACPI_TYPE_INTEGER) {
-                ret = -ENODEV;
-                goto pcch_free;
-        }
-
-        doorbell_write = member->integer.value;
-
-        dprintk("probe: doorbell_preserve: 0x%llx,"
-                " doorbell_write: 0x%llx\n",
-                doorbell_preserve, doorbell_write);
-
-        pcc_cpu_info = alloc_percpu(struct pcc_cpu);
-        if (!pcc_cpu_info) {
-                ret = -ENOMEM;
-                goto pcch_free;
-        }
-
-        printk(KERN_DEBUG "pcc-cpufreq: (v%s) driver loaded with frequency"
-               " limits: %d MHz, %d MHz\n", PCC_VERSION,
-               ioread32(&pcch_hdr->minimum_frequency),
-               ioread32(&pcch_hdr->nominal));
-        kfree(output.pointer);
-        return ret;
-pcch_free:
-        pcc_clear_mapping();
-out_free:
-        kfree(output.pointer);
-        return ret;
-}
-
-static int pcc_cpufreq_cpu_init(struct cpufreq_policy *policy)
-{
-        unsigned int cpu = policy->cpu;
-        unsigned int result = 0;
-
-        if (!pcch_virt_addr) {
-                result = -1;
-                goto out;
-        }
-
-        result = pcc_get_offset(cpu);
-        if (result) {
-                dprintk("init: PCCP evaluation failed\n");
-                goto out;
-        }
-
-        policy->max = policy->cpuinfo.max_freq =
-                ioread32(&pcch_hdr->nominal) * 1000;
-        policy->min = policy->cpuinfo.min_freq =
-                ioread32(&pcch_hdr->minimum_frequency) * 1000;
-        policy->cur = pcc_get_freq(cpu);
-
-        if (!policy->cur) {
-                dprintk("init: Unable to get current CPU frequency\n");
-                result = -EINVAL;
-                goto out;
-        }
-
-        dprintk("init: policy->max is %d, policy->min is %d\n",
-                policy->max, policy->min);
-out:
-        return result;
-}
-
-static int pcc_cpufreq_cpu_exit(struct cpufreq_policy *policy)
-{
-        return 0;
-}
-
-static struct cpufreq_driver pcc_cpufreq_driver = {
-        .flags = CPUFREQ_CONST_LOOPS,
-        .get = pcc_get_freq,
-        .verify = pcc_cpufreq_verify,
-        .target = pcc_cpufreq_target,
-        .init = pcc_cpufreq_cpu_init,
-        .exit = pcc_cpufreq_cpu_exit,
-        .name = "pcc-cpufreq",
-        .owner = THIS_MODULE,
-};
-
-static int __init pcc_cpufreq_init(void)
-{
-        int ret;
-
-        if (acpi_disabled)
-                return 0;
-
-        ret = pcc_cpufreq_probe();
-        if (ret) {
-                dprintk("pcc_cpufreq_init: PCCH evaluation failed\n");
-                return ret;
-        }
-
-        ret = cpufreq_register_driver(&pcc_cpufreq_driver);
-
-        return ret;
-}
-
-static void __exit pcc_cpufreq_exit(void)
-{
-        cpufreq_unregister_driver(&pcc_cpufreq_driver);
-
-        pcc_clear_mapping();
-
-        free_percpu(pcc_cpu_info);
-}
-
-MODULE_AUTHOR("Matthew Garrett, Naga Chumbalkar");
-MODULE_VERSION(PCC_VERSION);
-MODULE_DESCRIPTION("Processor Clocking Control interface driver");
-MODULE_LICENSE("GPL");
-
-late_initcall(pcc_cpufreq_init);
-module_exit(pcc_cpufreq_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k6.c b/arch/x86/kernel/cpu/cpufreq/powernow-k6.c
deleted file mode 100644
index b3379d6a5c57..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k6.c
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
- *  This file was based upon code in Powertweak Linux (http://powertweak.sf.net)
- *  (C) 2000-2003  Dave Jones, Arjan van de Ven, Janne Pänkälä,
- *                 Dominik Brodowski.
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/ioport.h>
-#include <linux/timex.h>
-#include <linux/io.h>
-
-#include <asm/msr.h>
-
-#define POWERNOW_IOPORT 0xfff0          /* it doesn't matter where, as long
-                                           as it is unused */
-
-#define PFX "powernow-k6: "
-static unsigned int                     busfreq;   /* FSB, in 10 kHz */
-static unsigned int                     max_multiplier;
-
-
-/* Clock ratio multiplied by 10 - see table 27 in AMD#23446 */
-static struct cpufreq_frequency_table clock_ratio[] = {
-        {45,  /* 000 -> 4.5x */ 0},
-        {50,  /* 001 -> 5.0x */ 0},
-        {40,  /* 010 -> 4.0x */ 0},
-        {55,  /* 011 -> 5.5x */ 0},
-        {20,  /* 100 -> 2.0x */ 0},
-        {30,  /* 101 -> 3.0x */ 0},
-        {60,  /* 110 -> 6.0x */ 0},
-        {35,  /* 111 -> 3.5x */ 0},
-        {0, CPUFREQ_TABLE_END}
-};
-
-
-/**
- * powernow_k6_get_cpu_multiplier - returns the current FSB multiplier
- *
- *   Returns the current setting of the frequency multiplier. Core clock
- * speed is frequency of the Front-Side Bus multiplied with this value.
- */
-static int powernow_k6_get_cpu_multiplier(void)
-{
-        u64 invalue = 0;
-        u32 msrval;
-
-        msrval = POWERNOW_IOPORT + 0x1;
-        wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */
-        invalue = inl(POWERNOW_IOPORT + 0x8);
-        msrval = POWERNOW_IOPORT + 0x0;
-        wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */
-
-        return clock_ratio[(invalue >> 5)&7].index;
-}
-
-
-/**
- * powernow_k6_set_state - set the PowerNow! multiplier
- * @best_i: clock_ratio[best_i] is the target multiplier
- *
- *   Tries to change the PowerNow! multiplier
- */
-static void powernow_k6_set_state(unsigned int best_i)
-{
-        unsigned long outvalue = 0, invalue = 0;
-        unsigned long msrval;
-        struct cpufreq_freqs freqs;
-
-        if (clock_ratio[best_i].index > max_multiplier) {
-                printk(KERN_ERR PFX "invalid target frequency\n");
-                return;
-        }
-
-        freqs.old = busfreq * powernow_k6_get_cpu_multiplier();
-        freqs.new = busfreq * clock_ratio[best_i].index;
-        freqs.cpu = 0; /* powernow-k6.c is UP only driver */
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        /* we now need to transform best_i to the BVC format, see AMD#23446 */
-
-        outvalue = (1<<12) | (1<<10) | (1<<9) | (best_i<<5);
-
-        msrval = POWERNOW_IOPORT + 0x1;
-        wrmsr(MSR_K6_EPMR, msrval, 0); /* enable the PowerNow port */
-        invalue = inl(POWERNOW_IOPORT + 0x8);
-        invalue = invalue & 0xf;
-        outvalue = outvalue | invalue;
-        outl(outvalue , (POWERNOW_IOPORT + 0x8));
-        msrval = POWERNOW_IOPORT + 0x0;
-        wrmsr(MSR_K6_EPMR, msrval, 0); /* disable it again */
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-
-        return;
-}
-
-
-/**
- * powernow_k6_verify - verifies a new CPUfreq policy
- * @policy: new policy
- *
- * Policy must be within lowest and highest possible CPU Frequency,
- * and at least one possible state must be within min and max.
- */
-static int powernow_k6_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, &clock_ratio[0]);
-}
-
-
-/**
- * powernow_k6_setpolicy - sets a new CPUFreq policy
- * @policy: new policy
- * @target_freq: the target frequency
- * @relation: how that frequency relates to achieved frequency
- *  (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H)
- *
- * sets a new CPUFreq policy
- */
-static int powernow_k6_target(struct cpufreq_policy *policy,
-                               unsigned int target_freq,
-                               unsigned int relation)
-{
-        unsigned int newstate = 0;
-
-        if (cpufreq_frequency_table_target(policy, &clock_ratio[0],
-                                target_freq, relation, &newstate))
-                return -EINVAL;
-
-        powernow_k6_set_state(newstate);
-
-        return 0;
-}
-
-
-static int powernow_k6_cpu_init(struct cpufreq_policy *policy)
-{
-        unsigned int i, f;
-        int result;
-
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        /* get frequencies */
-        max_multiplier = powernow_k6_get_cpu_multiplier();
-        busfreq = cpu_khz / max_multiplier;
-
-        /* table init */
-        for (i = 0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) {
-                f = clock_ratio[i].index;
-                if (f > max_multiplier)
-                        clock_ratio[i].frequency = CPUFREQ_ENTRY_INVALID;
-                else
-                        clock_ratio[i].frequency = busfreq * f;
-        }
-
-        /* cpuinfo and default policy values */
-        policy->cpuinfo.transition_latency = 200000;
-        policy->cur = busfreq * max_multiplier;
-
-        result = cpufreq_frequency_table_cpuinfo(policy, clock_ratio);
-        if (result)
-                return result;
-
-        cpufreq_frequency_table_get_attr(clock_ratio, policy->cpu);
-
-        return 0;
-}
-
-
-static int powernow_k6_cpu_exit(struct cpufreq_policy *policy)
-{
-        unsigned int i;
-        for (i = 0; i < 8; i++) {
-                if (i == max_multiplier)
-                        powernow_k6_set_state(i);
-        }
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
-static unsigned int powernow_k6_get(unsigned int cpu)
-{
-        unsigned int ret;
-        ret = (busfreq * powernow_k6_get_cpu_multiplier());
-        return ret;
-}
-
-static struct freq_attr *powernow_k6_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver powernow_k6_driver = {
-        .verify         = powernow_k6_verify,
-        .target         = powernow_k6_target,
-        .init           = powernow_k6_cpu_init,
-        .exit           = powernow_k6_cpu_exit,
-        .get            = powernow_k6_get,
-        .name           = "powernow-k6",
-        .owner          = THIS_MODULE,
-        .attr           = powernow_k6_attr,
-};
-
-
-/**
- * powernow_k6_init - initializes the k6 PowerNow! CPUFreq driver
- *
- *   Initializes the K6 PowerNow! support. Returns -ENODEV on unsupported
- * devices, -EINVAL or -ENOMEM on problems during initiatization, and zero
- * on success.
- */
-static int __init powernow_k6_init(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-
-        if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 != 5) ||
-                ((c->x86_model != 12) && (c->x86_model != 13)))
-                return -ENODEV;
-
-        if (!request_region(POWERNOW_IOPORT, 16, "PowerNow!")) {
-                printk(KERN_INFO PFX "PowerNow IOPORT region already used.\n");
-                return -EIO;
-        }
-
-        if (cpufreq_register_driver(&powernow_k6_driver)) {
-                release_region(POWERNOW_IOPORT, 16);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-
-/**
- * powernow_k6_exit - unregisters AMD K6-2+/3+ PowerNow! support
- *
- *   Unregisters AMD K6-2+ / K6-3+ PowerNow! support.
- */
-static void __exit powernow_k6_exit(void)
-{
-        cpufreq_unregister_driver(&powernow_k6_driver);
-        release_region(POWERNOW_IOPORT, 16);
-}
-
-
-MODULE_AUTHOR("Arjan van de Ven, Dave Jones <davej@redhat.com>, "
-                "Dominik Brodowski <linux@brodo.de>");
-MODULE_DESCRIPTION("PowerNow! driver for AMD K6-2+ / K6-3+ processors.");
-MODULE_LICENSE("GPL");
-
-module_init(powernow_k6_init);
-module_exit(powernow_k6_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k7.c b/arch/x86/kernel/cpu/cpufreq/powernow-k7.c
deleted file mode 100644
index 4a45fd6e41ba..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k7.c
+++ /dev/null
@@ -1,752 +0,0 @@
-/*
- *  AMD K7 Powernow driver.
- *  (C) 2003 Dave Jones on behalf of SuSE Labs.
- *  (C) 2003-2004 Dave Jones <davej@redhat.com>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *  Based upon datasheets & sample CPUs kindly provided by AMD.
- *
- * Errata 5:
- *  CPU may fail to execute a FID/VID change in presence of interrupt.
- *  - We cli/sti on stepping A0 CPUs around the FID/VID transition.
- * Errata 15:
- *  CPU with half frequency multipliers may hang upon wakeup from disconnect.
- *  - We disable half multipliers if ACPI is used on A0 stepping CPUs.
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/dmi.h>
-#include <linux/timex.h>
-#include <linux/io.h>
-
-#include <asm/timer.h>          /* Needed for recalibrate_cpu_khz() */
-#include <asm/msr.h>
-#include <asm/system.h>
-
-#ifdef CONFIG_X86_POWERNOW_K7_ACPI
-#include <linux/acpi.h>
-#include <acpi/processor.h>
-#endif
-
-#include "powernow-k7.h"
-
-#define PFX "powernow: "
-
-
-struct psb_s {
-        u8 signature[10];
-        u8 tableversion;
-        u8 flags;
-        u16 settlingtime;
-        u8 reserved1;
-        u8 numpst;
-};
-
-struct pst_s {
-        u32 cpuid;
-        u8 fsbspeed;
-        u8 maxfid;
-        u8 startvid;
-        u8 numpstates;
-};
-
-#ifdef CONFIG_X86_POWERNOW_K7_ACPI
-union powernow_acpi_control_t {
-        struct {
-                unsigned long fid:5,
-                        vid:5,
-                        sgtc:20,
-                        res1:2;
-        } bits;
-        unsigned long val;
-};
-#endif
-
-#ifdef CONFIG_CPU_FREQ_DEBUG
-/* divide by 1000 to get VCore voltage in V. */
-static const int mobile_vid_table[32] = {
-    2000, 1950, 1900, 1850, 1800, 1750, 1700, 1650,
-    1600, 1550, 1500, 1450, 1400, 1350, 1300, 0,
-    1275, 1250, 1225, 1200, 1175, 1150, 1125, 1100,
-    1075, 1050, 1025, 1000, 975, 950, 925, 0,
-};
-#endif
-
-/* divide by 10 to get FID. */
-static const int fid_codes[32] = {
-    110, 115, 120, 125, 50, 55, 60, 65,
-    70, 75, 80, 85, 90, 95, 100, 105,
-    30, 190, 40, 200, 130, 135, 140, 210,
-    150, 225, 160, 165, 170, 180, -1, -1,
-};
-
-/* This parameter is used in order to force ACPI instead of legacy method for
- * configuration purpose.
- */
-
-static int acpi_force;
-
-static struct cpufreq_frequency_table *powernow_table;
-
-static unsigned int can_scale_bus;
-static unsigned int can_scale_vid;
-static unsigned int minimum_speed = -1;
-static unsigned int maximum_speed;
-static unsigned int number_scales;
-static unsigned int fsb;
-static unsigned int latency;
-static char have_a0;
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "powernow-k7", msg)
-
-static int check_fsb(unsigned int fsbspeed)
-{
-        int delta;
-        unsigned int f = fsb / 1000;
-
-        delta = (fsbspeed > f) ? fsbspeed - f : f - fsbspeed;
-        return delta < 5;
-}
-
-static int check_powernow(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        unsigned int maxei, eax, ebx, ecx, edx;
-
-        if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 != 6)) {
-#ifdef MODULE
-                printk(KERN_INFO PFX "This module only works with "
-                                "AMD K7 CPUs\n");
-#endif
-                return 0;
-        }
-
-        /* Get maximum capabilities */
-        maxei = cpuid_eax(0x80000000);
-        if (maxei < 0x80000007) {       /* Any powernow info ? */
-#ifdef MODULE
-                printk(KERN_INFO PFX "No powernow capabilities detected\n");
-#endif
-                return 0;
-        }
-
-        if ((c->x86_model == 6) && (c->x86_mask == 0)) {
-                printk(KERN_INFO PFX "K7 660[A0] core detected, "
-                                "enabling errata workarounds\n");
-                have_a0 = 1;
-        }
-
-        cpuid(0x80000007, &eax, &ebx, &ecx, &edx);
-
-        /* Check we can actually do something before we say anything.*/
-        if (!(edx & (1 << 1 | 1 << 2)))
-                return 0;
-
-        printk(KERN_INFO PFX "PowerNOW! Technology present. Can scale: ");
-
-        if (edx & 1 << 1) {
-                printk("frequency");
-                can_scale_bus = 1;
-        }
-
-        if ((edx & (1 << 1 | 1 << 2)) == 0x6)
-                printk(" and ");
-
-        if (edx & 1 << 2) {
-                printk("voltage");
-                can_scale_vid = 1;
-        }
-
-        printk(".\n");
-        return 1;
-}
-
-#ifdef CONFIG_X86_POWERNOW_K7_ACPI
-static void invalidate_entry(unsigned int entry)
-{
-        powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID;
-}
-#endif
-
-static int get_ranges(unsigned char *pst)
-{
-        unsigned int j;
-        unsigned int speed;
-        u8 fid, vid;
-
-        powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
-                                (number_scales + 1)), GFP_KERNEL);
-        if (!powernow_table)
-                return -ENOMEM;
-
-        for (j = 0 ; j < number_scales; j++) {
-                fid = *pst++;
-
-                powernow_table[j].frequency = (fsb * fid_codes[fid]) / 10;
-                powernow_table[j].index = fid; /* lower 8 bits */
-
-                speed = powernow_table[j].frequency;
-
-                if ((fid_codes[fid] % 10) == 5) {
-#ifdef CONFIG_X86_POWERNOW_K7_ACPI
-                        if (have_a0 == 1)
-                                invalidate_entry(j);
-#endif
-                }
-
-                if (speed < minimum_speed)
-                        minimum_speed = speed;
-                if (speed > maximum_speed)
-                        maximum_speed = speed;
-
-                vid = *pst++;
-                powernow_table[j].index |= (vid << 8); /* upper 8 bits */
-
-                dprintk("   FID: 0x%x (%d.%dx [%dMHz])  "
-                         "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
-                         fid_codes[fid] % 10, speed/1000, vid,
-                         mobile_vid_table[vid]/1000,
-                         mobile_vid_table[vid]%1000);
-        }
-        powernow_table[number_scales].frequency = CPUFREQ_TABLE_END;
-        powernow_table[number_scales].index = 0;
-
-        return 0;
-}
-
-
-static void change_FID(int fid)
-{
-        union msr_fidvidctl fidvidctl;
-
-        rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
-        if (fidvidctl.bits.FID != fid) {
-                fidvidctl.bits.SGTC = latency;
-                fidvidctl.bits.FID = fid;
-                fidvidctl.bits.VIDC = 0;
-                fidvidctl.bits.FIDC = 1;
-                wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
-        }
-}
-
-
-static void change_VID(int vid)
-{
-        union msr_fidvidctl fidvidctl;
-
-        rdmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
-        if (fidvidctl.bits.VID != vid) {
-                fidvidctl.bits.SGTC = latency;
-                fidvidctl.bits.VID = vid;
-                fidvidctl.bits.FIDC = 0;
-                fidvidctl.bits.VIDC = 1;
-                wrmsrl(MSR_K7_FID_VID_CTL, fidvidctl.val);
-        }
-}
-
-
-static void change_speed(unsigned int index)
-{
-        u8 fid, vid;
-        struct cpufreq_freqs freqs;
-        union msr_fidvidstatus fidvidstatus;
-        int cfid;
-
-        /* fid are the lower 8 bits of the index we stored into
-         * the cpufreq frequency table in powernow_decode_bios,
-         * vid are the upper 8 bits.
-         */
-
-        fid = powernow_table[index].index & 0xFF;
-        vid = (powernow_table[index].index & 0xFF00) >> 8;
-
-        freqs.cpu = 0;
-
-        rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
-        cfid = fidvidstatus.bits.CFID;
-        freqs.old = fsb * fid_codes[cfid] / 10;
-
-        freqs.new = powernow_table[index].frequency;
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        /* Now do the magic poking into the MSRs.  */
-
-        if (have_a0 == 1)       /* A0 errata 5 */
-                local_irq_disable();
-
-        if (freqs.old > freqs.new) {
-                /* Going down, so change FID first */
-                change_FID(fid);
-                change_VID(vid);
-        } else {
-                /* Going up, so change VID first */
-                change_VID(vid);
-                change_FID(fid);
-        }
-
-
-        if (have_a0 == 1)
-                local_irq_enable();
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-}
-
-
-#ifdef CONFIG_X86_POWERNOW_K7_ACPI
-
-static struct acpi_processor_performance *acpi_processor_perf;
-
-static int powernow_acpi_init(void)
-{
-        int i;
-        int retval = 0;
-        union powernow_acpi_control_t pc;
-
-        if (acpi_processor_perf != NULL && powernow_table != NULL) {
-                retval = -EINVAL;
-                goto err0;
-        }
-
-        acpi_processor_perf = kzalloc(sizeof(struct acpi_processor_performance),
-                                      GFP_KERNEL);
-        if (!acpi_processor_perf) {
-                retval = -ENOMEM;
-                goto err0;
-        }
-
-        if (!zalloc_cpumask_var(&acpi_processor_perf->shared_cpu_map,
-                                                                GFP_KERNEL)) {
-                retval = -ENOMEM;
-                goto err05;
-        }
-
-        if (acpi_processor_register_performance(acpi_processor_perf, 0)) {
-                retval = -EIO;
-                goto err1;
-        }
-
-        if (acpi_processor_perf->control_register.space_id !=
-                        ACPI_ADR_SPACE_FIXED_HARDWARE) {
-                retval = -ENODEV;
-                goto err2;
-        }
-
-        if (acpi_processor_perf->status_register.space_id !=
-                        ACPI_ADR_SPACE_FIXED_HARDWARE) {
-                retval = -ENODEV;
-                goto err2;
-        }
-
-        number_scales = acpi_processor_perf->state_count;
-
-        if (number_scales < 2) {
-                retval = -ENODEV;
-                goto err2;
-        }
-
-        powernow_table = kzalloc((sizeof(struct cpufreq_frequency_table) *
-                                (number_scales + 1)), GFP_KERNEL);
-        if (!powernow_table) {
-                retval = -ENOMEM;
-                goto err2;
-        }
-
-        pc.val = (unsigned long) acpi_processor_perf->states[0].control;
-        for (i = 0; i < number_scales; i++) {
-                u8 fid, vid;
-                struct acpi_processor_px *state =
-                        &acpi_processor_perf->states[i];
-                unsigned int speed, speed_mhz;
-
-                pc.val = (unsigned long) state->control;
-                dprintk("acpi:  P%d: %d MHz %d mW %d uS control %08x SGTC %d\n",
-                         i,
-                         (u32) state->core_frequency,
-                         (u32) state->power,
-                         (u32) state->transition_latency,
-                         (u32) state->control,
-                         pc.bits.sgtc);
-
-                vid = pc.bits.vid;
-                fid = pc.bits.fid;
-
-                powernow_table[i].frequency = fsb * fid_codes[fid] / 10;
-                powernow_table[i].index = fid; /* lower 8 bits */
-                powernow_table[i].index |= (vid << 8); /* upper 8 bits */
-
-                speed = powernow_table[i].frequency;
-                speed_mhz = speed / 1000;
-
-                /* processor_perflib will multiply the MHz value by 1000 to
-                 * get a KHz value (e.g. 1266000). However, powernow-k7 works
-                 * with true KHz values (e.g. 1266768). To ensure that all
-                 * powernow frequencies are available, we must ensure that
-                 * ACPI doesn't restrict them, so we round up the MHz value
-                 * to ensure that perflib's computed KHz value is greater than
-                 * or equal to powernow's KHz value.
-                 */
-                if (speed % 1000 > 0)
-                        speed_mhz++;
-
-                if ((fid_codes[fid] % 10) == 5) {
-                        if (have_a0 == 1)
-                                invalidate_entry(i);
-                }
-
-                dprintk("   FID: 0x%x (%d.%dx [%dMHz])  "
-                         "VID: 0x%x (%d.%03dV)\n", fid, fid_codes[fid] / 10,
-                         fid_codes[fid] % 10, speed_mhz, vid,
-                         mobile_vid_table[vid]/1000,
-                         mobile_vid_table[vid]%1000);
-
-                if (state->core_frequency != speed_mhz) {
-                        state->core_frequency = speed_mhz;
-                        dprintk("   Corrected ACPI frequency to %d\n",
-                                speed_mhz);
-                }
-
-                if (latency < pc.bits.sgtc)
-                        latency = pc.bits.sgtc;
-
-                if (speed < minimum_speed)
-                        minimum_speed = speed;
-                if (speed > maximum_speed)
-                        maximum_speed = speed;
-        }
-
-        powernow_table[i].frequency = CPUFREQ_TABLE_END;
-        powernow_table[i].index = 0;
-
-        /* notify BIOS that we exist */
-        acpi_processor_notify_smm(THIS_MODULE);
-
-        return 0;
-
-err2:
-        acpi_processor_unregister_performance(acpi_processor_perf, 0);
-err1:
-        free_cpumask_var(acpi_processor_perf->shared_cpu_map);
-err05:
-        kfree(acpi_processor_perf);
-err0:
-        printk(KERN_WARNING PFX "ACPI perflib can not be used on "
-                        "this platform\n");
-        acpi_processor_perf = NULL;
-        return retval;
-}
-#else
-static int powernow_acpi_init(void)
-{
-        printk(KERN_INFO PFX "no support for ACPI processor found."
-               "  Please recompile your kernel with ACPI processor\n");
-        return -EINVAL;
-}
-#endif
-
-static void print_pst_entry(struct pst_s *pst, unsigned int j)
-{
-        dprintk("PST:%d (@%p)\n", j, pst);
-        dprintk(" cpuid: 0x%x  fsb: %d  maxFID: 0x%x  startvid: 0x%x\n",
-                pst->cpuid, pst->fsbspeed, pst->maxfid, pst->startvid);
-}
-
-static int powernow_decode_bios(int maxfid, int startvid)
-{
-        struct psb_s *psb;
-        struct pst_s *pst;
-        unsigned int i, j;
-        unsigned char *p;
-        unsigned int etuple;
-        unsigned int ret;
-
-        etuple = cpuid_eax(0x80000001);
-
-        for (i = 0xC0000; i < 0xffff0 ; i += 16) {
-
-                p = phys_to_virt(i);
-
-                if (memcmp(p, "AMDK7PNOW!",  10) == 0) {
-                        dprintk("Found PSB header at %p\n", p);
-                        psb = (struct psb_s *) p;
-                        dprintk("Table version: 0x%x\n", psb->tableversion);
-                        if (psb->tableversion != 0x12) {
-                                printk(KERN_INFO PFX "Sorry, only v1.2 tables"
-                                                " supported right now\n");
-                                return -ENODEV;
-                        }
-
-                        dprintk("Flags: 0x%x\n", psb->flags);
-                        if ((psb->flags & 1) == 0)
-                                dprintk("Mobile voltage regulator\n");
-                        else
-                                dprintk("Desktop voltage regulator\n");
-
-                        latency = psb->settlingtime;
-                        if (latency < 100) {
-                                printk(KERN_INFO PFX "BIOS set settling time "
-                                                "to %d microseconds. "
-                                                "Should be at least 100. "
-                                                "Correcting.\n", latency);
-                                latency = 100;
-                        }
-                        dprintk("Settling Time: %d microseconds.\n",
-                                        psb->settlingtime);
-                        dprintk("Has %d PST tables. (Only dumping ones "
-                                        "relevant to this CPU).\n",
-                                        psb->numpst);
-
-                        p += sizeof(struct psb_s);
-
-                        pst = (struct pst_s *) p;
-
-                        for (j = 0; j < psb->numpst; j++) {
-                                pst = (struct pst_s *) p;
-                                number_scales = pst->numpstates;
-
-                                if ((etuple == pst->cpuid) &&
-                                    check_fsb(pst->fsbspeed) &&
-                                    (maxfid == pst->maxfid) &&
-                                    (startvid == pst->startvid)) {
-                                        print_pst_entry(pst, j);
-                                        p = (char *)pst + sizeof(struct pst_s);
-                                        ret = get_ranges(p);
-                                        return ret;
-                                } else {
-                                        unsigned int k;
-                                        p = (char *)pst + sizeof(struct pst_s);
-                                        for (k = 0; k < number_scales; k++)
-                                                p += 2;
-                                }
-                        }
-                        printk(KERN_INFO PFX "No PST tables match this cpuid "
-                                        "(0x%x)\n", etuple);
-                        printk(KERN_INFO PFX "This is indicative of a broken "
-                                        "BIOS.\n");
-
-                        return -EINVAL;
-                }
-                p++;
-        }
-
-        return -ENODEV;
-}
-
-
-static int powernow_target(struct cpufreq_policy *policy,
-                            unsigned int target_freq,
-                            unsigned int relation)
-{
-        unsigned int newstate;
-
-        if (cpufreq_frequency_table_target(policy, powernow_table, target_freq,
-                                relation, &newstate))
-                return -EINVAL;
-
-        change_speed(newstate);
-
-        return 0;
-}
-
-
-static int powernow_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, powernow_table);
-}
-
-/*
- * We use the fact that the bus frequency is somehow
- * a multiple of 100000/3 khz, then we compute sgtc according
- * to this multiple.
- * That way, we match more how AMD thinks all of that work.
- * We will then get the same kind of behaviour already tested under
- * the "well-known" other OS.
- */
-static int __cpuinit fixup_sgtc(void)
-{
-        unsigned int sgtc;
-        unsigned int m;
-
-        m = fsb / 3333;
-        if ((m % 10) >= 5)
-                m += 5;
-
-        m /= 10;
-
-        sgtc = 100 * m * latency;
-        sgtc = sgtc / 3;
-        if (sgtc > 0xfffff) {
-                printk(KERN_WARNING PFX "SGTC too large %d\n", sgtc);
-                sgtc = 0xfffff;
-        }
-        return sgtc;
-}
-
-static unsigned int powernow_get(unsigned int cpu)
-{
-        union msr_fidvidstatus fidvidstatus;
-        unsigned int cfid;
-
-        if (cpu)
-                return 0;
-        rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
-        cfid = fidvidstatus.bits.CFID;
-
-        return fsb * fid_codes[cfid] / 10;
-}
-
-
-static int __cpuinit acer_cpufreq_pst(const struct dmi_system_id *d)
-{
-        printk(KERN_WARNING PFX
-                "%s laptop with broken PST tables in BIOS detected.\n",
-                d->ident);
-        printk(KERN_WARNING PFX
-                "You need to downgrade to 3A21 (09/09/2002), or try a newer "
-                "BIOS than 3A71 (01/20/2003)\n");
-        printk(KERN_WARNING PFX
-                "cpufreq scaling has been disabled as a result of this.\n");
-        return 0;
-}
-
-/*
- * Some Athlon laptops have really fucked PST tables.
- * A BIOS update is all that can save them.
- * Mention this, and disable cpufreq.
- */
-static struct dmi_system_id __cpuinitdata powernow_dmi_table[] = {
-        {
-                .callback = acer_cpufreq_pst,
-                .ident = "Acer Aspire",
-                .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Insyde Software"),
-                        DMI_MATCH(DMI_BIOS_VERSION, "3A71"),
-                },
-        },
-        { }
-};
-
-static int __cpuinit powernow_cpu_init(struct cpufreq_policy *policy)
-{
-        union msr_fidvidstatus fidvidstatus;
-        int result;
-
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        rdmsrl(MSR_K7_FID_VID_STATUS, fidvidstatus.val);
-
-        recalibrate_cpu_khz();
-
-        fsb = (10 * cpu_khz) / fid_codes[fidvidstatus.bits.CFID];
-        if (!fsb) {
-                printk(KERN_WARNING PFX "can not determine bus frequency\n");
-                return -EINVAL;
-        }
-        dprintk("FSB: %3dMHz\n", fsb/1000);
-
-        if (dmi_check_system(powernow_dmi_table) || acpi_force) {
-                printk(KERN_INFO PFX "PSB/PST known to be broken.  "
-                                "Trying ACPI instead\n");
-                result = powernow_acpi_init();
-        } else {
-                result = powernow_decode_bios(fidvidstatus.bits.MFID,
-                                fidvidstatus.bits.SVID);
-                if (result) {
-                        printk(KERN_INFO PFX "Trying ACPI perflib\n");
-                        maximum_speed = 0;
-                        minimum_speed = -1;
-                        latency = 0;
-                        result = powernow_acpi_init();
-                        if (result) {
-                                printk(KERN_INFO PFX
-                                        "ACPI and legacy methods failed\n");
-                        }
-                } else {
-                        /* SGTC use the bus clock as timer */
-                        latency = fixup_sgtc();
-                        printk(KERN_INFO PFX "SGTC: %d\n", latency);
-                }
-        }
-
-        if (result)
-                return result;
-
-        printk(KERN_INFO PFX "Minimum speed %d MHz. Maximum speed %d MHz.\n",
-                                minimum_speed/1000, maximum_speed/1000);
-
-        policy->cpuinfo.transition_latency =
-                cpufreq_scale(2000000UL, fsb, latency);
-
-        policy->cur = powernow_get(0);
-
-        cpufreq_frequency_table_get_attr(powernow_table, policy->cpu);
-
-        return cpufreq_frequency_table_cpuinfo(policy, powernow_table);
-}
-
-static int powernow_cpu_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-
-#ifdef CONFIG_X86_POWERNOW_K7_ACPI
-        if (acpi_processor_perf) {
-                acpi_processor_unregister_performance(acpi_processor_perf, 0);
-                free_cpumask_var(acpi_processor_perf->shared_cpu_map);
-                kfree(acpi_processor_perf);
-        }
-#endif
-
-        kfree(powernow_table);
-        return 0;
-}
-
-static struct freq_attr *powernow_table_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver powernow_driver = {
-        .verify         = powernow_verify,
-        .target         = powernow_target,
-        .get            = powernow_get,
-#ifdef CONFIG_X86_POWERNOW_K7_ACPI
-        .bios_limit     = acpi_processor_get_bios_limit,
-#endif
-        .init           = powernow_cpu_init,
-        .exit           = powernow_cpu_exit,
-        .name           = "powernow-k7",
-        .owner          = THIS_MODULE,
-        .attr           = powernow_table_attr,
-};
-
-static int __init powernow_init(void)
-{
-        if (check_powernow() == 0)
-                return -ENODEV;
-        return cpufreq_register_driver(&powernow_driver);
-}
-
-
-static void __exit powernow_exit(void)
-{
-        cpufreq_unregister_driver(&powernow_driver);
-}
-
-module_param(acpi_force,  int, 0444);
-MODULE_PARM_DESC(acpi_force, "Force ACPI to be used.");
-
-MODULE_AUTHOR("Dave Jones <davej@redhat.com>");
-MODULE_DESCRIPTION("Powernow driver for AMD K7 processors.");
-MODULE_LICENSE("GPL");
-
-late_initcall(powernow_init);
-module_exit(powernow_exit);
-
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k7.h b/arch/x86/kernel/cpu/cpufreq/powernow-k7.h
deleted file mode 100644
index 35fb4eaf6e1c..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k7.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- *  (C) 2003 Dave Jones.
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- *  AMD-specific information
- *
- */
-
-union msr_fidvidctl {
-        struct {
-                unsigned FID:5,                 // 4:0
-                reserved1:3,    // 7:5
-                VID:5,                  // 12:8
-                reserved2:3,    // 15:13
-                FIDC:1,                 // 16
-                VIDC:1,                 // 17
-                reserved3:2,    // 19:18
-                FIDCHGRATIO:1,  // 20
-                reserved4:11,   // 31-21
-                SGTC:20,                // 32:51
-                reserved5:12;   // 63:52
-        } bits;
-        unsigned long long val;
-};
-
-union msr_fidvidstatus {
-        struct {
-                unsigned CFID:5,                        // 4:0
-                reserved1:3,    // 7:5
-                SFID:5,                 // 12:8
-                reserved2:3,    // 15:13
-                MFID:5,                 // 20:16
-                reserved3:11,   // 31:21
-                CVID:5,                 // 36:32
-                reserved4:3,    // 39:37
-                SVID:5,                 // 44:40
-                reserved5:3,    // 47:45
-                MVID:5,                 // 52:48
-                reserved6:11;   // 63:53
-        } bits;
-        unsigned long long val;
-};
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c b/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
deleted file mode 100644
index 2368e38327b3..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.c
+++ /dev/null
@@ -1,1607 +0,0 @@
-/*
- *   (c) 2003-2010 Advanced Micro Devices, Inc.
- *  Your use of this code is subject to the terms and conditions of the
- *  GNU general public license version 2. See "COPYING" or
- *  http://www.gnu.org/licenses/gpl.html
- *
- *  Support : mark.langsdorf@amd.com
- *
- *  Based on the powernow-k7.c module written by Dave Jones.
- *  (C) 2003 Dave Jones on behalf of SuSE Labs
- *  (C) 2004 Dominik Brodowski <linux@brodo.de>
- *  (C) 2004 Pavel Machek <pavel@ucw.cz>
- *  Licensed under the terms of the GNU GPL License version 2.
- *  Based upon datasheets & sample CPUs kindly provided by AMD.
- *
- *  Valuable input gratefully received from Dave Jones, Pavel Machek,
- *  Dominik Brodowski, Jacob Shin, and others.
- *  Originally developed by Paul Devriendt.
- *  Processor information obtained from Chapter 9 (Power and Thermal Management)
- *  of the "BIOS and Kernel Developer's Guide for the AMD Athlon 64 and AMD
- *  Opteron Processors" available for download from www.amd.com
- *
- *  Tables for specific CPUs can be inferred from
- *     http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/30430.pdf
- */
-
-#include <linux/kernel.h>
-#include <linux/smp.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/cpumask.h>
-#include <linux/sched.h>        /* for current / set_cpus_allowed() */
-#include <linux/io.h>
-#include <linux/delay.h>
-
-#include <asm/msr.h>
-
-#include <linux/acpi.h>
-#include <linux/mutex.h>
-#include <acpi/processor.h>
-
-#define PFX "powernow-k8: "
-#define VERSION "version 2.20.00"
-#include "powernow-k8.h"
-#include "mperf.h"
-
-/* serialize freq changes  */
-static DEFINE_MUTEX(fidvid_mutex);
-
-static DEFINE_PER_CPU(struct powernow_k8_data *, powernow_data);
-
-static int cpu_family = CPU_OPTERON;
-
-/* core performance boost */
-static bool cpb_capable, cpb_enabled;
-static struct msr __percpu *msrs;
-
-static struct cpufreq_driver cpufreq_amd64_driver;
-
-#ifndef CONFIG_SMP
-static inline const struct cpumask *cpu_core_mask(int cpu)
-{
-        return cpumask_of(0);
-}
-#endif
-
-/* Return a frequency in MHz, given an input fid */
-static u32 find_freq_from_fid(u32 fid)
-{
-        return 800 + (fid * 100);
-}
-
-/* Return a frequency in KHz, given an input fid */
-static u32 find_khz_freq_from_fid(u32 fid)
-{
-        return 1000 * find_freq_from_fid(fid);
-}
-
-static u32 find_khz_freq_from_pstate(struct cpufreq_frequency_table *data,
-                u32 pstate)
-{
-        return data[pstate].frequency;
-}
-
-/* Return the vco fid for an input fid
- *
- * Each "low" fid has corresponding "high" fid, and you can get to "low" fids
- * only from corresponding high fids. This returns "high" fid corresponding to
- * "low" one.
- */
-static u32 convert_fid_to_vco_fid(u32 fid)
-{
-        if (fid < HI_FID_TABLE_BOTTOM)
-                return 8 + (2 * fid);
-        else
-                return fid;
-}
-
-/*
- * Return 1 if the pending bit is set. Unless we just instructed the processor
- * to transition to a new state, seeing this bit set is really bad news.
- */
-static int pending_bit_stuck(void)
-{
-        u32 lo, hi;
-
-        if (cpu_family == CPU_HW_PSTATE)
-                return 0;
-
-        rdmsr(MSR_FIDVID_STATUS, lo, hi);
-        return lo & MSR_S_LO_CHANGE_PENDING ? 1 : 0;
-}
-
-/*
- * Update the global current fid / vid values from the status msr.
- * Returns 1 on error.
- */
-static int query_current_values_with_pending_wait(struct powernow_k8_data *data)
-{
-        u32 lo, hi;
-        u32 i = 0;
-
-        if (cpu_family == CPU_HW_PSTATE) {
-                rdmsr(MSR_PSTATE_STATUS, lo, hi);
-                i = lo & HW_PSTATE_MASK;
-                data->currpstate = i;
-
-                /*
-                 * a workaround for family 11h erratum 311 might cause
-                 * an "out-of-range Pstate if the core is in Pstate-0
-                 */
-                if ((boot_cpu_data.x86 == 0x11) && (i >= data->numps))
-                        data->currpstate = HW_PSTATE_0;
-
-                return 0;
-        }
-        do {
-                if (i++ > 10000) {
-                        dprintk("detected change pending stuck\n");
-                        return 1;
-                }
-                rdmsr(MSR_FIDVID_STATUS, lo, hi);
-        } while (lo & MSR_S_LO_CHANGE_PENDING);
-
-        data->currvid = hi & MSR_S_HI_CURRENT_VID;
-        data->currfid = lo & MSR_S_LO_CURRENT_FID;
-
-        return 0;
-}
-
-/* the isochronous relief time */
-static void count_off_irt(struct powernow_k8_data *data)
-{
-        udelay((1 << data->irt) * 10);
-        return;
-}
-
-/* the voltage stabilization time */
-static void count_off_vst(struct powernow_k8_data *data)
-{
-        udelay(data->vstable * VST_UNITS_20US);
-        return;
-}
-
-/* need to init the control msr to a safe value (for each cpu) */
-static void fidvid_msr_init(void)
-{
-        u32 lo, hi;
-        u8 fid, vid;
-
-        rdmsr(MSR_FIDVID_STATUS, lo, hi);
-        vid = hi & MSR_S_HI_CURRENT_VID;
-        fid = lo & MSR_S_LO_CURRENT_FID;
-        lo = fid | (vid << MSR_C_LO_VID_SHIFT);
-        hi = MSR_C_HI_STP_GNT_BENIGN;
-        dprintk("cpu%d, init lo 0x%x, hi 0x%x\n", smp_processor_id(), lo, hi);
-        wrmsr(MSR_FIDVID_CTL, lo, hi);
-}
-
-/* write the new fid value along with the other control fields to the msr */
-static int write_new_fid(struct powernow_k8_data *data, u32 fid)
-{
-        u32 lo;
-        u32 savevid = data->currvid;
-        u32 i = 0;
-
-        if ((fid & INVALID_FID_MASK) || (data->currvid & INVALID_VID_MASK)) {
-                printk(KERN_ERR PFX "internal error - overflow on fid write\n");
-                return 1;
-        }
-
-        lo = fid;
-        lo |= (data->currvid << MSR_C_LO_VID_SHIFT);
-        lo |= MSR_C_LO_INIT_FID_VID;
-
-        dprintk("writing fid 0x%x, lo 0x%x, hi 0x%x\n",
-                fid, lo, data->plllock * PLL_LOCK_CONVERSION);
-
-        do {
-                wrmsr(MSR_FIDVID_CTL, lo, data->plllock * PLL_LOCK_CONVERSION);
-                if (i++ > 100) {
-                        printk(KERN_ERR PFX
-                                "Hardware error - pending bit very stuck - "
-                                "no further pstate changes possible\n");
-                        return 1;
-                }
-        } while (query_current_values_with_pending_wait(data));
-
-        count_off_irt(data);
-
-        if (savevid != data->currvid) {
-                printk(KERN_ERR PFX
-                        "vid change on fid trans, old 0x%x, new 0x%x\n",
-                        savevid, data->currvid);
-                return 1;
-        }
-
-        if (fid != data->currfid) {
-                printk(KERN_ERR PFX
-                        "fid trans failed, fid 0x%x, curr 0x%x\n", fid,
-                        data->currfid);
-                return 1;
-        }
-
-        return 0;
-}
-
-/* Write a new vid to the hardware */
-static int write_new_vid(struct powernow_k8_data *data, u32 vid)
-{
-        u32 lo;
-        u32 savefid = data->currfid;
-        int i = 0;
-
-        if ((data->currfid & INVALID_FID_MASK) || (vid & INVALID_VID_MASK)) {
-                printk(KERN_ERR PFX "internal error - overflow on vid write\n");
-                return 1;
-        }
-
-        lo = data->currfid;
-        lo |= (vid << MSR_C_LO_VID_SHIFT);
-        lo |= MSR_C_LO_INIT_FID_VID;
-
-        dprintk("writing vid 0x%x, lo 0x%x, hi 0x%x\n",
-                vid, lo, STOP_GRANT_5NS);
-
-        do {
-                wrmsr(MSR_FIDVID_CTL, lo, STOP_GRANT_5NS);
-                if (i++ > 100) {
-                        printk(KERN_ERR PFX "internal error - pending bit "
-                                        "very stuck - no further pstate "
-                                        "changes possible\n");
-                        return 1;
-                }
-        } while (query_current_values_with_pending_wait(data));
-
-        if (savefid != data->currfid) {
-                printk(KERN_ERR PFX "fid changed on vid trans, old "
-                        "0x%x new 0x%x\n",
-                       savefid, data->currfid);
-                return 1;
-        }
-
-        if (vid != data->currvid) {
-                printk(KERN_ERR PFX "vid trans failed, vid 0x%x, "
-                                "curr 0x%x\n",
-                                vid, data->currvid);
-                return 1;
-        }
-
-        return 0;
-}
-
-/*
- * Reduce the vid by the max of step or reqvid.
- * Decreasing vid codes represent increasing voltages:
- * vid of 0 is 1.550V, vid of 0x1e is 0.800V, vid of VID_OFF is off.
- */
-static int decrease_vid_code_by_step(struct powernow_k8_data *data,
-                u32 reqvid, u32 step)
-{
-        if ((data->currvid - reqvid) > step)
-                reqvid = data->currvid - step;
-
-        if (write_new_vid(data, reqvid))
-                return 1;
-
-        count_off_vst(data);
-
-        return 0;
-}
-
-/* Change hardware pstate by single MSR write */
-static int transition_pstate(struct powernow_k8_data *data, u32 pstate)
-{
-        wrmsr(MSR_PSTATE_CTRL, pstate, 0);
-        data->currpstate = pstate;
-        return 0;
-}
-
-/* Change Opteron/Athlon64 fid and vid, by the 3 phases. */
-static int transition_fid_vid(struct powernow_k8_data *data,
-                u32 reqfid, u32 reqvid)
-{
-        if (core_voltage_pre_transition(data, reqvid, reqfid))
-                return 1;
-
-        if (core_frequency_transition(data, reqfid))
-                return 1;
-
-        if (core_voltage_post_transition(data, reqvid))
-                return 1;
-
-        if (query_current_values_with_pending_wait(data))
-                return 1;
-
-        if ((reqfid != data->currfid) || (reqvid != data->currvid)) {
-                printk(KERN_ERR PFX "failed (cpu%d): req 0x%x 0x%x, "
-                                "curr 0x%x 0x%x\n",
-                                smp_processor_id(),
-                                reqfid, reqvid, data->currfid, data->currvid);
-                return 1;
-        }
-
-        dprintk("transitioned (cpu%d): new fid 0x%x, vid 0x%x\n",
-                smp_processor_id(), data->currfid, data->currvid);
-
-        return 0;
-}
-
-/* Phase 1 - core voltage transition ... setup voltage */
-static int core_voltage_pre_transition(struct powernow_k8_data *data,
-                u32 reqvid, u32 reqfid)
-{
-        u32 rvosteps = data->rvo;
-        u32 savefid = data->currfid;
-        u32 maxvid, lo, rvomult = 1;
-
-        dprintk("ph1 (cpu%d): start, currfid 0x%x, currvid 0x%x, "
-                "reqvid 0x%x, rvo 0x%x\n",
-                smp_processor_id(),
-                data->currfid, data->currvid, reqvid, data->rvo);
-
-        if ((savefid < LO_FID_TABLE_TOP) && (reqfid < LO_FID_TABLE_TOP))
-                rvomult = 2;
-        rvosteps *= rvomult;
-        rdmsr(MSR_FIDVID_STATUS, lo, maxvid);
-        maxvid = 0x1f & (maxvid >> 16);
-        dprintk("ph1 maxvid=0x%x\n", maxvid);
-        if (reqvid < maxvid) /* lower numbers are higher voltages */
-                reqvid = maxvid;
-
-        while (data->currvid > reqvid) {
-                dprintk("ph1: curr 0x%x, req vid 0x%x\n",
-                        data->currvid, reqvid);
-                if (decrease_vid_code_by_step(data, reqvid, data->vidmvs))
-                        return 1;
-        }
-
-        while ((rvosteps > 0) &&
-                        ((rvomult * data->rvo + data->currvid) > reqvid)) {
-                if (data->currvid == maxvid) {
-                        rvosteps = 0;
-                } else {
-                        dprintk("ph1: changing vid for rvo, req 0x%x\n",
-                                data->currvid - 1);
-                        if (decrease_vid_code_by_step(data, data->currvid-1, 1))
-                                return 1;
-                        rvosteps--;
-                }
-        }
-
-        if (query_current_values_with_pending_wait(data))
-                return 1;
-
-        if (savefid != data->currfid) {
-                printk(KERN_ERR PFX "ph1 err, currfid changed 0x%x\n",
-                                data->currfid);
-                return 1;
-        }
-
-        dprintk("ph1 complete, currfid 0x%x, currvid 0x%x\n",
-                data->currfid, data->currvid);
-
-        return 0;
-}
-
-/* Phase 2 - core frequency transition */
-static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid)
-{
-        u32 vcoreqfid, vcocurrfid, vcofiddiff;
-        u32 fid_interval, savevid = data->currvid;
-
-        if (data->currfid == reqfid) {
-                printk(KERN_ERR PFX "ph2 null fid transition 0x%x\n",
-                                data->currfid);
-                return 0;
-        }
-
-        dprintk("ph2 (cpu%d): starting, currfid 0x%x, currvid 0x%x, "
-                "reqfid 0x%x\n",
-                smp_processor_id(),
-                data->currfid, data->currvid, reqfid);
-
-        vcoreqfid = convert_fid_to_vco_fid(reqfid);
-        vcocurrfid = convert_fid_to_vco_fid(data->currfid);
-        vcofiddiff = vcocurrfid > vcoreqfid ? vcocurrfid - vcoreqfid
-            : vcoreqfid - vcocurrfid;
-
-        if ((reqfid <= LO_FID_TABLE_TOP) && (data->currfid <= LO_FID_TABLE_TOP))
-                vcofiddiff = 0;
-
-        while (vcofiddiff > 2) {
-                (data->currfid & 1) ? (fid_interval = 1) : (fid_interval = 2);
-
-                if (reqfid > data->currfid) {
-                        if (data->currfid > LO_FID_TABLE_TOP) {
-                                if (write_new_fid(data,
-                                                data->currfid + fid_interval))
-                                        return 1;
-                        } else {
-                                if (write_new_fid
-                                    (data,
-                                     2 + convert_fid_to_vco_fid(data->currfid)))
-                                        return 1;
-                        }
-                } else {
-                        if (write_new_fid(data, data->currfid - fid_interval))
-                                return 1;
-                }
-
-                vcocurrfid = convert_fid_to_vco_fid(data->currfid);
-                vcofiddiff = vcocurrfid > vcoreqfid ? vcocurrfid - vcoreqfid
-                    : vcoreqfid - vcocurrfid;
-        }
-
-        if (write_new_fid(data, reqfid))
-                return 1;
-
-        if (query_current_values_with_pending_wait(data))
-                return 1;
-
-        if (data->currfid != reqfid) {
-                printk(KERN_ERR PFX
-                        "ph2: mismatch, failed fid transition, "
-                        "curr 0x%x, req 0x%x\n",
-                        data->currfid, reqfid);
-                return 1;
-        }
-
-        if (savevid != data->currvid) {
-                printk(KERN_ERR PFX "ph2: vid changed, save 0x%x, curr 0x%x\n",
-                        savevid, data->currvid);
-                return 1;
-        }
-
-        dprintk("ph2 complete, currfid 0x%x, currvid 0x%x\n",
-                data->currfid, data->currvid);
-
-        return 0;
-}
-
-/* Phase 3 - core voltage transition flow ... jump to the final vid. */
-static int core_voltage_post_transition(struct powernow_k8_data *data,
-                u32 reqvid)
-{
-        u32 savefid = data->currfid;
-        u32 savereqvid = reqvid;
-
-        dprintk("ph3 (cpu%d): starting, currfid 0x%x, currvid 0x%x\n",
-                smp_processor_id(),
-                data->currfid, data->currvid);
-
-        if (reqvid != data->currvid) {
-                if (write_new_vid(data, reqvid))
-                        return 1;
-
-                if (savefid != data->currfid) {
-                        printk(KERN_ERR PFX
-                               "ph3: bad fid change, save 0x%x, curr 0x%x\n",
-                               savefid, data->currfid);
-                        return 1;
-                }
-
-                if (data->currvid != reqvid) {
-                        printk(KERN_ERR PFX
-                               "ph3: failed vid transition\n, "
-                               "req 0x%x, curr 0x%x",
-                               reqvid, data->currvid);
-                        return 1;
-                }
-        }
-
-        if (query_current_values_with_pending_wait(data))
-                return 1;
-
-        if (savereqvid != data->currvid) {
-                dprintk("ph3 failed, currvid 0x%x\n", data->currvid);
-                return 1;
-        }
-
-        if (savefid != data->currfid) {
-                dprintk("ph3 failed, currfid changed 0x%x\n",
-                        data->currfid);
-                return 1;
-        }
-
-        dprintk("ph3 complete, currfid 0x%x, currvid 0x%x\n",
-                data->currfid, data->currvid);
-
-        return 0;
-}
-
-static void check_supported_cpu(void *_rc)
-{
-        u32 eax, ebx, ecx, edx;
-        int *rc = _rc;
-
-        *rc = -ENODEV;
-
-        if (__this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_AMD)
-                return;
-
-        eax = cpuid_eax(CPUID_PROCESSOR_SIGNATURE);
-        if (((eax & CPUID_XFAM) != CPUID_XFAM_K8) &&
-            ((eax & CPUID_XFAM) < CPUID_XFAM_10H))
-                return;
-
-        if ((eax & CPUID_XFAM) == CPUID_XFAM_K8) {
-                if (((eax & CPUID_USE_XFAM_XMOD) != CPUID_USE_XFAM_XMOD) ||
-                    ((eax & CPUID_XMOD) > CPUID_XMOD_REV_MASK)) {
-                        printk(KERN_INFO PFX
-                                "Processor cpuid %x not supported\n", eax);
-                        return;
-                }
-
-                eax = cpuid_eax(CPUID_GET_MAX_CAPABILITIES);
-                if (eax < CPUID_FREQ_VOLT_CAPABILITIES) {
-                        printk(KERN_INFO PFX
-                               "No frequency change capabilities detected\n");
-                        return;
-                }
-
-                cpuid(CPUID_FREQ_VOLT_CAPABILITIES, &eax, &ebx, &ecx, &edx);
-                if ((edx & P_STATE_TRANSITION_CAPABLE)
-                        != P_STATE_TRANSITION_CAPABLE) {
-                        printk(KERN_INFO PFX
-                                "Power state transitions not supported\n");
-                        return;
-                }
-        } else { /* must be a HW Pstate capable processor */
-                cpuid(CPUID_FREQ_VOLT_CAPABILITIES, &eax, &ebx, &ecx, &edx);
-                if ((edx & USE_HW_PSTATE) == USE_HW_PSTATE)
-                        cpu_family = CPU_HW_PSTATE;
-                else
-                        return;
-        }
-
-        *rc = 0;
-}
-
-static int check_pst_table(struct powernow_k8_data *data, struct pst_s *pst,
-                u8 maxvid)
-{
-        unsigned int j;
-        u8 lastfid = 0xff;
-
-        for (j = 0; j < data->numps; j++) {
-                if (pst[j].vid > LEAST_VID) {
-                        printk(KERN_ERR FW_BUG PFX "vid %d invalid : 0x%x\n",
-                               j, pst[j].vid);
-                        return -EINVAL;
-                }
-                if (pst[j].vid < data->rvo) {
-                        /* vid + rvo >= 0 */
-                        printk(KERN_ERR FW_BUG PFX "0 vid exceeded with pstate"
-                               " %d\n", j);
-                        return -ENODEV;
-                }
-                if (pst[j].vid < maxvid + data->rvo) {
-                        /* vid + rvo >= maxvid */
-                        printk(KERN_ERR FW_BUG PFX "maxvid exceeded with pstate"
-                               " %d\n", j);
-                        return -ENODEV;
-                }
-                if (pst[j].fid > MAX_FID) {
-                        printk(KERN_ERR FW_BUG PFX "maxfid exceeded with pstate"
-                               " %d\n", j);
-                        return -ENODEV;
-                }
-                if (j && (pst[j].fid < HI_FID_TABLE_BOTTOM)) {
-                        /* Only first fid is allowed to be in "low" range */
-                        printk(KERN_ERR FW_BUG PFX "two low fids - %d : "
-                               "0x%x\n", j, pst[j].fid);
-                        return -EINVAL;
-                }
-                if (pst[j].fid < lastfid)
-                        lastfid = pst[j].fid;
-        }
-        if (lastfid & 1) {
-                printk(KERN_ERR FW_BUG PFX "lastfid invalid\n");
-                return -EINVAL;
-        }
-        if (lastfid > LO_FID_TABLE_TOP)
-                printk(KERN_INFO FW_BUG PFX
-                        "first fid not from lo freq table\n");
-
-        return 0;
-}
-
-static void invalidate_entry(struct cpufreq_frequency_table *powernow_table,
-                unsigned int entry)
-{
-        powernow_table[entry].frequency = CPUFREQ_ENTRY_INVALID;
-}
-
-static void print_basics(struct powernow_k8_data *data)
-{
-        int j;
-        for (j = 0; j < data->numps; j++) {
-                if (data->powernow_table[j].frequency !=
-                                CPUFREQ_ENTRY_INVALID) {
-                        if (cpu_family == CPU_HW_PSTATE) {
-                                printk(KERN_INFO PFX
-                                        "   %d : pstate %d (%d MHz)\n", j,
-                                        data->powernow_table[j].index,
-                                        data->powernow_table[j].frequency/1000);
-                        } else {
-                                printk(KERN_INFO PFX
-                                        "fid 0x%x (%d MHz), vid 0x%x\n",
-                                        data->powernow_table[j].index & 0xff,
-                                        data->powernow_table[j].frequency/1000,
-                                        data->powernow_table[j].index >> 8);
-                        }
-                }
-        }
-        if (data->batps)
-                printk(KERN_INFO PFX "Only %d pstates on battery\n",
-                                data->batps);
-}
-
-static u32 freq_from_fid_did(u32 fid, u32 did)
-{
-        u32 mhz = 0;
-
-        if (boot_cpu_data.x86 == 0x10)
-                mhz = (100 * (fid + 0x10)) >> did;
-        else if (boot_cpu_data.x86 == 0x11)
-                mhz = (100 * (fid + 8)) >> did;
-        else
-                BUG();
-
-        return mhz * 1000;
-}
-
-static int fill_powernow_table(struct powernow_k8_data *data,
-                struct pst_s *pst, u8 maxvid)
-{
-        struct cpufreq_frequency_table *powernow_table;
-        unsigned int j;
-
-        if (data->batps) {
-                /* use ACPI support to get full speed on mains power */
-                printk(KERN_WARNING PFX
-                        "Only %d pstates usable (use ACPI driver for full "
-                        "range\n", data->batps);
-                data->numps = data->batps;
-        }
-
-        for (j = 1; j < data->numps; j++) {
-                if (pst[j-1].fid >= pst[j].fid) {
-                        printk(KERN_ERR PFX "PST out of sequence\n");
-                        return -EINVAL;
-                }
-        }
-
-        if (data->numps < 2) {
-                printk(KERN_ERR PFX "no p states to transition\n");
-                return -ENODEV;
-        }
-
-        if (check_pst_table(data, pst, maxvid))
-                return -EINVAL;
-
-        powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table)
-                * (data->numps + 1)), GFP_KERNEL);
-        if (!powernow_table) {
-                printk(KERN_ERR PFX "powernow_table memory alloc failure\n");
-                return -ENOMEM;
-        }
-
-        for (j = 0; j < data->numps; j++) {
-                int freq;
-                powernow_table[j].index = pst[j].fid; /* lower 8 bits */
-                powernow_table[j].index |= (pst[j].vid << 8); /* upper 8 bits */
-                freq = find_khz_freq_from_fid(pst[j].fid);
-                powernow_table[j].frequency = freq;
-        }
-        powernow_table[data->numps].frequency = CPUFREQ_TABLE_END;
-        powernow_table[data->numps].index = 0;
-
-        if (query_current_values_with_pending_wait(data)) {
-                kfree(powernow_table);
-                return -EIO;
-        }
-
-        dprintk("cfid 0x%x, cvid 0x%x\n", data->currfid, data->currvid);
-        data->powernow_table = powernow_table;
-        if (cpumask_first(cpu_core_mask(data->cpu)) == data->cpu)
-                print_basics(data);
-
-        for (j = 0; j < data->numps; j++)
-                if ((pst[j].fid == data->currfid) &&
-                    (pst[j].vid == data->currvid))
-                        return 0;
-
-        dprintk("currfid/vid do not match PST, ignoring\n");
-        return 0;
-}
-
-/* Find and validate the PSB/PST table in BIOS. */
-static int find_psb_table(struct powernow_k8_data *data)
-{
-        struct psb_s *psb;
-        unsigned int i;
-        u32 mvs;
-        u8 maxvid;
-        u32 cpst = 0;
-        u32 thiscpuid;
-
-        for (i = 0xc0000; i < 0xffff0; i += 0x10) {
-                /* Scan BIOS looking for the signature. */
-                /* It can not be at ffff0 - it is too big. */
-
-                psb = phys_to_virt(i);
-                if (memcmp(psb, PSB_ID_STRING, PSB_ID_STRING_LEN) != 0)
-                        continue;
-
-                dprintk("found PSB header at 0x%p\n", psb);
-
-                dprintk("table vers: 0x%x\n", psb->tableversion);
-                if (psb->tableversion != PSB_VERSION_1_4) {
-                        printk(KERN_ERR FW_BUG PFX "PSB table is not v1.4\n");
-                        return -ENODEV;
-                }
-
-                dprintk("flags: 0x%x\n", psb->flags1);
-                if (psb->flags1) {
-                        printk(KERN_ERR FW_BUG PFX "unknown flags\n");
-                        return -ENODEV;
-                }
-
-                data->vstable = psb->vstable;
-                dprintk("voltage stabilization time: %d(*20us)\n",
-                                data->vstable);
-
-                dprintk("flags2: 0x%x\n", psb->flags2);
-                data->rvo = psb->flags2 & 3;
-                data->irt = ((psb->flags2) >> 2) & 3;
-                mvs = ((psb->flags2) >> 4) & 3;
-                data->vidmvs = 1 << mvs;
-                data->batps = ((psb->flags2) >> 6) & 3;
-
-                dprintk("ramp voltage offset: %d\n", data->rvo);
-                dprintk("isochronous relief time: %d\n", data->irt);
-                dprintk("maximum voltage step: %d - 0x%x\n", mvs, data->vidmvs);
-
-                dprintk("numpst: 0x%x\n", psb->num_tables);
-                cpst = psb->num_tables;
-                if ((psb->cpuid == 0x00000fc0) ||
-                    (psb->cpuid == 0x00000fe0)) {
-                        thiscpuid = cpuid_eax(CPUID_PROCESSOR_SIGNATURE);
-                        if ((thiscpuid == 0x00000fc0) ||
-                            (thiscpuid == 0x00000fe0))
-                                cpst = 1;
-                }
-                if (cpst != 1) {
-                        printk(KERN_ERR FW_BUG PFX "numpst must be 1\n");
-                        return -ENODEV;
-                }
-
-                data->plllock = psb->plllocktime;
-                dprintk("plllocktime: 0x%x (units 1us)\n", psb->plllocktime);
-                dprintk("maxfid: 0x%x\n", psb->maxfid);
-                dprintk("maxvid: 0x%x\n", psb->maxvid);
-                maxvid = psb->maxvid;
-
-                data->numps = psb->numps;
-                dprintk("numpstates: 0x%x\n", data->numps);
-                return fill_powernow_table(data,
-                                (struct pst_s *)(psb+1), maxvid);
-        }
-        /*
-         * If you see this message, complain to BIOS manufacturer. If
-         * he tells you "we do not support Linux" or some similar
-         * nonsense, remember that Windows 2000 uses the same legacy
-         * mechanism that the old Linux PSB driver uses. Tell them it
-         * is broken with Windows 2000.
-         *
-         * The reference to the AMD documentation is chapter 9 in the
-         * BIOS and Kernel Developer's Guide, which is available on
-         * www.amd.com
-         */
-        printk(KERN_ERR FW_BUG PFX "No PSB or ACPI _PSS objects\n");
-        printk(KERN_ERR PFX "Make sure that your BIOS is up to date"
-                " and Cool'N'Quiet support is enabled in BIOS setup\n");
-        return -ENODEV;
-}
-
-static void powernow_k8_acpi_pst_values(struct powernow_k8_data *data,
-                unsigned int index)
-{
-        u64 control;
-
-        if (!data->acpi_data.state_count || (cpu_family == CPU_HW_PSTATE))
-                return;
-
-        control = data->acpi_data.states[index].control;
-        data->irt = (control >> IRT_SHIFT) & IRT_MASK;
-        data->rvo = (control >> RVO_SHIFT) & RVO_MASK;
-        data->exttype = (control >> EXT_TYPE_SHIFT) & EXT_TYPE_MASK;
-        data->plllock = (control >> PLL_L_SHIFT) & PLL_L_MASK;
-        data->vidmvs = 1 << ((control >> MVS_SHIFT) & MVS_MASK);
-        data->vstable = (control >> VST_SHIFT) & VST_MASK;
-}
-
-static int powernow_k8_cpu_init_acpi(struct powernow_k8_data *data)
-{
-        struct cpufreq_frequency_table *powernow_table;
-        int ret_val = -ENODEV;
-        u64 control, status;
-
-        if (acpi_processor_register_performance(&data->acpi_data, data->cpu)) {
-                dprintk("register performance failed: bad ACPI data\n");
-                return -EIO;
-        }
-
-        /* verify the data contained in the ACPI structures */
-        if (data->acpi_data.state_count <= 1) {
-                dprintk("No ACPI P-States\n");
-                goto err_out;
-        }
-
-        control = data->acpi_data.control_register.space_id;
-        status = data->acpi_data.status_register.space_id;
-
-        if ((control != ACPI_ADR_SPACE_FIXED_HARDWARE) ||
-            (status != ACPI_ADR_SPACE_FIXED_HARDWARE)) {
-                dprintk("Invalid control/status registers (%x - %x)\n",
-                        control, status);
-                goto err_out;
-        }
-
-        /* fill in data->powernow_table */
-        powernow_table = kmalloc((sizeof(struct cpufreq_frequency_table)
-                * (data->acpi_data.state_count + 1)), GFP_KERNEL);
-        if (!powernow_table) {
-                dprintk("powernow_table memory alloc failure\n");
-                goto err_out;
-        }
-
-        /* fill in data */
-        data->numps = data->acpi_data.state_count;
-        powernow_k8_acpi_pst_values(data, 0);
-
-        if (cpu_family == CPU_HW_PSTATE)
-                ret_val = fill_powernow_table_pstate(data, powernow_table);
-        else
-                ret_val = fill_powernow_table_fidvid(data, powernow_table);
-        if (ret_val)
-                goto err_out_mem;
-
-        powernow_table[data->acpi_data.state_count].frequency =
-                CPUFREQ_TABLE_END;
-        powernow_table[data->acpi_data.state_count].index = 0;
-        data->powernow_table = powernow_table;
-
-        if (cpumask_first(cpu_core_mask(data->cpu)) == data->cpu)
-                print_basics(data);
-
-        /* notify BIOS that we exist */
-        acpi_processor_notify_smm(THIS_MODULE);
-
-        if (!zalloc_cpumask_var(&data->acpi_data.shared_cpu_map, GFP_KERNEL)) {
-                printk(KERN_ERR PFX
-                                "unable to alloc powernow_k8_data cpumask\n");
-                ret_val = -ENOMEM;
-                goto err_out_mem;
-        }
-
-        return 0;
-
-err_out_mem:
-        kfree(powernow_table);
-
-err_out:
-        acpi_processor_unregister_performance(&data->acpi_data, data->cpu);
-
-        /* data->acpi_data.state_count informs us at ->exit()
-         * whether ACPI was used */
-        data->acpi_data.state_count = 0;
-
-        return ret_val;
-}
-
-static int fill_powernow_table_pstate(struct powernow_k8_data *data,
-                struct cpufreq_frequency_table *powernow_table)
-{
-        int i;
-        u32 hi = 0, lo = 0;
-        rdmsr(MSR_PSTATE_CUR_LIMIT, lo, hi);
-        data->max_hw_pstate = (lo & HW_PSTATE_MAX_MASK) >> HW_PSTATE_MAX_SHIFT;
-
-        for (i = 0; i < data->acpi_data.state_count; i++) {
-                u32 index;
-
-                index = data->acpi_data.states[i].control & HW_PSTATE_MASK;
-                if (index > data->max_hw_pstate) {
-                        printk(KERN_ERR PFX "invalid pstate %d - "
-                                        "bad value %d.\n", i, index);
-                        printk(KERN_ERR PFX "Please report to BIOS "
-                                        "manufacturer\n");
-                        invalidate_entry(powernow_table, i);
-                        continue;
-                }
-                rdmsr(MSR_PSTATE_DEF_BASE + index, lo, hi);
-                if (!(hi & HW_PSTATE_VALID_MASK)) {
-                        dprintk("invalid pstate %d, ignoring\n", index);
-                        invalidate_entry(powernow_table, i);
-                        continue;
-                }
-
-                powernow_table[i].index = index;
-
-                /* Frequency may be rounded for these */
-                if ((boot_cpu_data.x86 == 0x10 && boot_cpu_data.x86_model < 10)
-                                 || boot_cpu_data.x86 == 0x11) {
-                        powernow_table[i].frequency =
-                                freq_from_fid_did(lo & 0x3f, (lo >> 6) & 7);
-                } else
-                        powernow_table[i].frequency =
-                                data->acpi_data.states[i].core_frequency * 1000;
-        }
-        return 0;
-}
-
-static int fill_powernow_table_fidvid(struct powernow_k8_data *data,
-                struct cpufreq_frequency_table *powernow_table)
-{
-        int i;
-
-        for (i = 0; i < data->acpi_data.state_count; i++) {
-                u32 fid;
-                u32 vid;
-                u32 freq, index;
-                u64 status, control;
-
-                if (data->exttype) {
-                        status =  data->acpi_data.states[i].status;
-                        fid = status & EXT_FID_MASK;
-                        vid = (status >> VID_SHIFT) & EXT_VID_MASK;
-                } else {
-                        control =  data->acpi_data.states[i].control;
-                        fid = control & FID_MASK;
-                        vid = (control >> VID_SHIFT) & VID_MASK;
-                }
-
-                dprintk("   %d : fid 0x%x, vid 0x%x\n", i, fid, vid);
-
-                index = fid | (vid<<8);
-                powernow_table[i].index = index;
-
-                freq = find_khz_freq_from_fid(fid);
-                powernow_table[i].frequency = freq;
-
-                /* verify frequency is OK */
-                if ((freq > (MAX_FREQ * 1000)) || (freq < (MIN_FREQ * 1000))) {
-                        dprintk("invalid freq %u kHz, ignoring\n", freq);
-                        invalidate_entry(powernow_table, i);
-                        continue;
-                }
-
-                /* verify voltage is OK -
-                 * BIOSs are using "off" to indicate invalid */
-                if (vid == VID_OFF) {
-                        dprintk("invalid vid %u, ignoring\n", vid);
-                        invalidate_entry(powernow_table, i);
-                        continue;
-                }
-
-                if (freq != (data->acpi_data.states[i].core_frequency * 1000)) {
-                        printk(KERN_INFO PFX "invalid freq entries "
-                                "%u kHz vs. %u kHz\n", freq,
-                                (unsigned int)
-                                (data->acpi_data.states[i].core_frequency
-                                 * 1000));
-                        invalidate_entry(powernow_table, i);
-                        continue;
-                }
-        }
-        return 0;
-}
-
-static void powernow_k8_cpu_exit_acpi(struct powernow_k8_data *data)
-{
-        if (data->acpi_data.state_count)
-                acpi_processor_unregister_performance(&data->acpi_data,
-                                data->cpu);
-        free_cpumask_var(data->acpi_data.shared_cpu_map);
-}
-
-static int get_transition_latency(struct powernow_k8_data *data)
-{
-        int max_latency = 0;
-        int i;
-        for (i = 0; i < data->acpi_data.state_count; i++) {
-                int cur_latency = data->acpi_data.states[i].transition_latency
-                        + data->acpi_data.states[i].bus_master_latency;
-                if (cur_latency > max_latency)
-                        max_latency = cur_latency;
-        }
-        if (max_latency == 0) {
-                /*
-                 * Fam 11h and later may return 0 as transition latency. This
-                 * is intended and means "very fast". While cpufreq core and
-                 * governors currently can handle that gracefully, better set it
-                 * to 1 to avoid problems in the future.
-                 */
-                if (boot_cpu_data.x86 < 0x11)
-                        printk(KERN_ERR FW_WARN PFX "Invalid zero transition "
-                                "latency\n");
-                max_latency = 1;
-        }
-        /* value in usecs, needs to be in nanoseconds */
-        return 1000 * max_latency;
-}
-
-/* Take a frequency, and issue the fid/vid transition command */
-static int transition_frequency_fidvid(struct powernow_k8_data *data,
-                unsigned int index)
-{
-        u32 fid = 0;
-        u32 vid = 0;
-        int res, i;
-        struct cpufreq_freqs freqs;
-
-        dprintk("cpu %d transition to index %u\n", smp_processor_id(), index);
-
-        /* fid/vid correctness check for k8 */
-        /* fid are the lower 8 bits of the index we stored into
-         * the cpufreq frequency table in find_psb_table, vid
-         * are the upper 8 bits.
-         */
-        fid = data->powernow_table[index].index & 0xFF;
-        vid = (data->powernow_table[index].index & 0xFF00) >> 8;
-
-        dprintk("table matched fid 0x%x, giving vid 0x%x\n", fid, vid);
-
-        if (query_current_values_with_pending_wait(data))
-                return 1;
-
-        if ((data->currvid == vid) && (data->currfid == fid)) {
-                dprintk("target matches current values (fid 0x%x, vid 0x%x)\n",
-                        fid, vid);
-                return 0;
-        }
-
-        dprintk("cpu %d, changing to fid 0x%x, vid 0x%x\n",
-                smp_processor_id(), fid, vid);
-        freqs.old = find_khz_freq_from_fid(data->currfid);
-        freqs.new = find_khz_freq_from_fid(fid);
-
-        for_each_cpu(i, data->available_cores) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        }
-
-        res = transition_fid_vid(data, fid, vid);
-        freqs.new = find_khz_freq_from_fid(data->currfid);
-
-        for_each_cpu(i, data->available_cores) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        }
-        return res;
-}
-
-/* Take a frequency, and issue the hardware pstate transition command */
-static int transition_frequency_pstate(struct powernow_k8_data *data,
-                unsigned int index)
-{
-        u32 pstate = 0;
-        int res, i;
-        struct cpufreq_freqs freqs;
-
-        dprintk("cpu %d transition to index %u\n", smp_processor_id(), index);
-
-        /* get MSR index for hardware pstate transition */
-        pstate = index & HW_PSTATE_MASK;
-        if (pstate > data->max_hw_pstate)
-                return 0;
-        freqs.old = find_khz_freq_from_pstate(data->powernow_table,
-                        data->currpstate);
-        freqs.new = find_khz_freq_from_pstate(data->powernow_table, pstate);
-
-        for_each_cpu(i, data->available_cores) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        }
-
-        res = transition_pstate(data, pstate);
-        freqs.new = find_khz_freq_from_pstate(data->powernow_table, pstate);
-
-        for_each_cpu(i, data->available_cores) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        }
-        return res;
-}
-
-/* Driver entry point to switch to the target frequency */
-static int powernowk8_target(struct cpufreq_policy *pol,
-                unsigned targfreq, unsigned relation)
-{
-        cpumask_var_t oldmask;
-        struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
-        u32 checkfid;
-        u32 checkvid;
-        unsigned int newstate;
-        int ret = -EIO;
-
-        if (!data)
-                return -EINVAL;
-
-        checkfid = data->currfid;
-        checkvid = data->currvid;
-
-        /* only run on specific CPU from here on. */
-        /* This is poor form: use a workqueue or smp_call_function_single */
-        if (!alloc_cpumask_var(&oldmask, GFP_KERNEL))
-                return -ENOMEM;
-
-        cpumask_copy(oldmask, tsk_cpus_allowed(current));
-        set_cpus_allowed_ptr(current, cpumask_of(pol->cpu));
-
-        if (smp_processor_id() != pol->cpu) {
-                printk(KERN_ERR PFX "limiting to cpu %u failed\n", pol->cpu);
-                goto err_out;
-        }
-
-        if (pending_bit_stuck()) {
-                printk(KERN_ERR PFX "failing targ, change pending bit set\n");
-                goto err_out;
-        }
-
-        dprintk("targ: cpu %d, %d kHz, min %d, max %d, relation %d\n",
-                pol->cpu, targfreq, pol->min, pol->max, relation);
-
-        if (query_current_values_with_pending_wait(data))
-                goto err_out;
-
-        if (cpu_family != CPU_HW_PSTATE) {
-                dprintk("targ: curr fid 0x%x, vid 0x%x\n",
-                data->currfid, data->currvid);
-
-                if ((checkvid != data->currvid) ||
-                    (checkfid != data->currfid)) {
-                        printk(KERN_INFO PFX
-                                "error - out of sync, fix 0x%x 0x%x, "
-                                "vid 0x%x 0x%x\n",
-                                checkfid, data->currfid,
-                                checkvid, data->currvid);
-                }
-        }
-
-        if (cpufreq_frequency_table_target(pol, data->powernow_table,
-                                targfreq, relation, &newstate))
-                goto err_out;
-
-        mutex_lock(&fidvid_mutex);
-
-        powernow_k8_acpi_pst_values(data, newstate);
-
-        if (cpu_family == CPU_HW_PSTATE)
-                ret = transition_frequency_pstate(data, newstate);
-        else
-                ret = transition_frequency_fidvid(data, newstate);
-        if (ret) {
-                printk(KERN_ERR PFX "transition frequency failed\n");
-                ret = 1;
-                mutex_unlock(&fidvid_mutex);
-                goto err_out;
-        }
-        mutex_unlock(&fidvid_mutex);
-
-        if (cpu_family == CPU_HW_PSTATE)
-                pol->cur = find_khz_freq_from_pstate(data->powernow_table,
-                                newstate);
-        else
-                pol->cur = find_khz_freq_from_fid(data->currfid);
-        ret = 0;
-
-err_out:
-        set_cpus_allowed_ptr(current, oldmask);
-        free_cpumask_var(oldmask);
-        return ret;
-}
-
-/* Driver entry point to verify the policy and range of frequencies */
-static int powernowk8_verify(struct cpufreq_policy *pol)
-{
-        struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
-
-        if (!data)
-                return -EINVAL;
-
-        return cpufreq_frequency_table_verify(pol, data->powernow_table);
-}
-
-struct init_on_cpu {
-        struct powernow_k8_data *data;
-        int rc;
-};
-
-static void __cpuinit powernowk8_cpu_init_on_cpu(void *_init_on_cpu)
-{
-        struct init_on_cpu *init_on_cpu = _init_on_cpu;
-
-        if (pending_bit_stuck()) {
-                printk(KERN_ERR PFX "failing init, change pending bit set\n");
-                init_on_cpu->rc = -ENODEV;
-                return;
-        }
-
-        if (query_current_values_with_pending_wait(init_on_cpu->data)) {
-                init_on_cpu->rc = -ENODEV;
-                return;
-        }
-
-        if (cpu_family == CPU_OPTERON)
-                fidvid_msr_init();
-
-        init_on_cpu->rc = 0;
-}
-
-/* per CPU init entry point to the driver */
-static int __cpuinit powernowk8_cpu_init(struct cpufreq_policy *pol)
-{
-        static const char ACPI_PSS_BIOS_BUG_MSG[] =
-                KERN_ERR FW_BUG PFX "No compatible ACPI _PSS objects found.\n"
-                FW_BUG PFX "Try again with latest BIOS.\n";
-        struct powernow_k8_data *data;
-        struct init_on_cpu init_on_cpu;
-        int rc;
-        struct cpuinfo_x86 *c = &cpu_data(pol->cpu);
-
-        if (!cpu_online(pol->cpu))
-                return -ENODEV;
-
-        smp_call_function_single(pol->cpu, check_supported_cpu, &rc, 1);
-        if (rc)
-                return -ENODEV;
-
-        data = kzalloc(sizeof(struct powernow_k8_data), GFP_KERNEL);
-        if (!data) {
-                printk(KERN_ERR PFX "unable to alloc powernow_k8_data");
-                return -ENOMEM;
-        }
-
-        data->cpu = pol->cpu;
-        data->currpstate = HW_PSTATE_INVALID;
-
-        if (powernow_k8_cpu_init_acpi(data)) {
-                /*
-                 * Use the PSB BIOS structure. This is only available on
-                 * an UP version, and is deprecated by AMD.
-                 */
-                if (num_online_cpus() != 1) {
-                        printk_once(ACPI_PSS_BIOS_BUG_MSG);
-                        goto err_out;
-                }
-                if (pol->cpu != 0) {
-                        printk(KERN_ERR FW_BUG PFX "No ACPI _PSS objects for "
-                               "CPU other than CPU0. Complain to your BIOS "
-                               "vendor.\n");
-                        goto err_out;
-                }
-                rc = find_psb_table(data);
-                if (rc)
-                        goto err_out;
-
-                /* Take a crude guess here.
-                 * That guess was in microseconds, so multiply with 1000 */
-                pol->cpuinfo.transition_latency = (
-                         ((data->rvo + 8) * data->vstable * VST_UNITS_20US) +
-                         ((1 << data->irt) * 30)) * 1000;
-        } else /* ACPI _PSS objects available */
-                pol->cpuinfo.transition_latency = get_transition_latency(data);
-
-        /* only run on specific CPU from here on */
-        init_on_cpu.data = data;
-        smp_call_function_single(data->cpu, powernowk8_cpu_init_on_cpu,
-                                 &init_on_cpu, 1);
-        rc = init_on_cpu.rc;
-        if (rc != 0)
-                goto err_out_exit_acpi;
-
-        if (cpu_family == CPU_HW_PSTATE)
-                cpumask_copy(pol->cpus, cpumask_of(pol->cpu));
-        else
-                cpumask_copy(pol->cpus, cpu_core_mask(pol->cpu));
-        data->available_cores = pol->cpus;
-
-        if (cpu_family == CPU_HW_PSTATE)
-                pol->cur = find_khz_freq_from_pstate(data->powernow_table,
-                                data->currpstate);
-        else
-                pol->cur = find_khz_freq_from_fid(data->currfid);
-        dprintk("policy current frequency %d kHz\n", pol->cur);
-
-        /* min/max the cpu is capable of */
-        if (cpufreq_frequency_table_cpuinfo(pol, data->powernow_table)) {
-                printk(KERN_ERR FW_BUG PFX "invalid powernow_table\n");
-                powernow_k8_cpu_exit_acpi(data);
-                kfree(data->powernow_table);
-                kfree(data);
-                return -EINVAL;
-        }
-
-        /* Check for APERF/MPERF support in hardware */
-        if (cpu_has(c, X86_FEATURE_APERFMPERF))
-                cpufreq_amd64_driver.getavg = cpufreq_get_measured_perf;
-
-        cpufreq_frequency_table_get_attr(data->powernow_table, pol->cpu);
-
-        if (cpu_family == CPU_HW_PSTATE)
-                dprintk("cpu_init done, current pstate 0x%x\n",
-                                data->currpstate);
-        else
-                dprintk("cpu_init done, current fid 0x%x, vid 0x%x\n",
-                        data->currfid, data->currvid);
-
-        per_cpu(powernow_data, pol->cpu) = data;
-
-        return 0;
-
-err_out_exit_acpi:
-        powernow_k8_cpu_exit_acpi(data);
-
-err_out:
-        kfree(data);
-        return -ENODEV;
-}
-
-static int __devexit powernowk8_cpu_exit(struct cpufreq_policy *pol)
-{
-        struct powernow_k8_data *data = per_cpu(powernow_data, pol->cpu);
-
-        if (!data)
-                return -EINVAL;
-
-        powernow_k8_cpu_exit_acpi(data);
-
-        cpufreq_frequency_table_put_attr(pol->cpu);
-
-        kfree(data->powernow_table);
-        kfree(data);
-        per_cpu(powernow_data, pol->cpu) = NULL;
-
-        return 0;
-}
-
-static void query_values_on_cpu(void *_err)
-{
-        int *err = _err;
-        struct powernow_k8_data *data = __this_cpu_read(powernow_data);
-
-        *err = query_current_values_with_pending_wait(data);
-}
-
-static unsigned int powernowk8_get(unsigned int cpu)
-{
-        struct powernow_k8_data *data = per_cpu(powernow_data, cpu);
-        unsigned int khz = 0;
-        int err;
-
-        if (!data)
-                return 0;
-
-        smp_call_function_single(cpu, query_values_on_cpu, &err, true);
-        if (err)
-                goto out;
-
-        if (cpu_family == CPU_HW_PSTATE)
-                khz = find_khz_freq_from_pstate(data->powernow_table,
-                                                data->currpstate);
-        else
-                khz = find_khz_freq_from_fid(data->currfid);
-
-
-out:
-        return khz;
-}
-
-static void _cpb_toggle_msrs(bool t)
-{
-        int cpu;
-
-        get_online_cpus();
-
-        rdmsr_on_cpus(cpu_online_mask, MSR_K7_HWCR, msrs);
-
-        for_each_cpu(cpu, cpu_online_mask) {
-                struct msr *reg = per_cpu_ptr(msrs, cpu);
-                if (t)
-                        reg->l &= ~BIT(25);
-                else
-                        reg->l |= BIT(25);
-        }
-        wrmsr_on_cpus(cpu_online_mask, MSR_K7_HWCR, msrs);
-
-        put_online_cpus();
-}
-
-/*
- * Switch on/off core performance boosting.
- *
- * 0=disable
- * 1=enable.
- */
-static void cpb_toggle(bool t)
-{
-        if (!cpb_capable)
-                return;
-
-        if (t && !cpb_enabled) {
-                cpb_enabled = true;
-                _cpb_toggle_msrs(t);
-                printk(KERN_INFO PFX "Core Boosting enabled.\n");
-        } else if (!t && cpb_enabled) {
-                cpb_enabled = false;
-                _cpb_toggle_msrs(t);
-                printk(KERN_INFO PFX "Core Boosting disabled.\n");
-        }
-}
-
-static ssize_t store_cpb(struct cpufreq_policy *policy, const char *buf,
-                                 size_t count)
-{
-        int ret = -EINVAL;
-        unsigned long val = 0;
-
-        ret = strict_strtoul(buf, 10, &val);
-        if (!ret && (val == 0 || val == 1) && cpb_capable)
-                cpb_toggle(val);
-        else
-                return -EINVAL;
-
-        return count;
-}
-
-static ssize_t show_cpb(struct cpufreq_policy *policy, char *buf)
-{
-        return sprintf(buf, "%u\n", cpb_enabled);
-}
-
-#define define_one_rw(_name) \
-static struct freq_attr _name = \
-__ATTR(_name, 0644, show_##_name, store_##_name)
-
-define_one_rw(cpb);
-
-static struct freq_attr *powernow_k8_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        &cpb,
-        NULL,
-};
-
-static struct cpufreq_driver cpufreq_amd64_driver = {
-        .verify         = powernowk8_verify,
-        .target         = powernowk8_target,
-        .bios_limit     = acpi_processor_get_bios_limit,
-        .init           = powernowk8_cpu_init,
-        .exit           = __devexit_p(powernowk8_cpu_exit),
-        .get            = powernowk8_get,
-        .name           = "powernow-k8",
-        .owner          = THIS_MODULE,
-        .attr           = powernow_k8_attr,
-};
-
-/*
- * Clear the boost-disable flag on the CPU_DOWN path so that this cpu
- * cannot block the remaining ones from boosting. On the CPU_UP path we
- * simply keep the boost-disable flag in sync with the current global
- * state.
- */
-static int cpb_notify(struct notifier_block *nb, unsigned long action,
-                      void *hcpu)
-{
-        unsigned cpu = (long)hcpu;
-        u32 lo, hi;
-
-        switch (action) {
-        case CPU_UP_PREPARE:
-        case CPU_UP_PREPARE_FROZEN:
-
-                if (!cpb_enabled) {
-                        rdmsr_on_cpu(cpu, MSR_K7_HWCR, &lo, &hi);
-                        lo |= BIT(25);
-                        wrmsr_on_cpu(cpu, MSR_K7_HWCR, lo, hi);
-                }
-                break;
-
-        case CPU_DOWN_PREPARE:
-        case CPU_DOWN_PREPARE_FROZEN:
-                rdmsr_on_cpu(cpu, MSR_K7_HWCR, &lo, &hi);
-                lo &= ~BIT(25);
-                wrmsr_on_cpu(cpu, MSR_K7_HWCR, lo, hi);
-                break;
-
-        default:
-                break;
-        }
-
-        return NOTIFY_OK;
-}
-
-static struct notifier_block cpb_nb = {
-        .notifier_call          = cpb_notify,
-};
-
-/* driver entry point for init */
-static int __cpuinit powernowk8_init(void)
-{
-        unsigned int i, supported_cpus = 0, cpu;
-        int rv;
-
-        for_each_online_cpu(i) {
-                int rc;
-                smp_call_function_single(i, check_supported_cpu, &rc, 1);
-                if (rc == 0)
-                        supported_cpus++;
-        }
-
-        if (supported_cpus != num_online_cpus())
-                return -ENODEV;
-
-        printk(KERN_INFO PFX "Found %d %s (%d cpu cores) (" VERSION ")\n",
-                num_online_nodes(), boot_cpu_data.x86_model_id, supported_cpus);
-
-        if (boot_cpu_has(X86_FEATURE_CPB)) {
-
-                cpb_capable = true;
-
-                msrs = msrs_alloc();
-                if (!msrs) {
-                        printk(KERN_ERR "%s: Error allocating msrs!\n", __func__);
-                        return -ENOMEM;
-                }
-
-                register_cpu_notifier(&cpb_nb);
-
-                rdmsr_on_cpus(cpu_online_mask, MSR_K7_HWCR, msrs);
-
-                for_each_cpu(cpu, cpu_online_mask) {
-                        struct msr *reg = per_cpu_ptr(msrs, cpu);
-                        cpb_enabled |= !(!!(reg->l & BIT(25)));
-                }
-
-                printk(KERN_INFO PFX "Core Performance Boosting: %s.\n",
-                        (cpb_enabled ? "on" : "off"));
-        }
-
-        rv = cpufreq_register_driver(&cpufreq_amd64_driver);
-        if (rv < 0 && boot_cpu_has(X86_FEATURE_CPB)) {
-                unregister_cpu_notifier(&cpb_nb);
-                msrs_free(msrs);
-                msrs = NULL;
-        }
-        return rv;
-}
-
-/* driver entry point for term */
-static void __exit powernowk8_exit(void)
-{
-        dprintk("exit\n");
-
-        if (boot_cpu_has(X86_FEATURE_CPB)) {
-                msrs_free(msrs);
-                msrs = NULL;
-
-                unregister_cpu_notifier(&cpb_nb);
-        }
-
-        cpufreq_unregister_driver(&cpufreq_amd64_driver);
-}
-
-MODULE_AUTHOR("Paul Devriendt <paul.devriendt@amd.com> and "
-                "Mark Langsdorf <mark.langsdorf@amd.com>");
-MODULE_DESCRIPTION("AMD Athlon 64 and Opteron processor frequency driver.");
-MODULE_LICENSE("GPL");
-
-late_initcall(powernowk8_init);
-module_exit(powernowk8_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/powernow-k8.h b/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
deleted file mode 100644
index df3529b1c02d..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/powernow-k8.h
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
- *  (c) 2003-2006 Advanced Micro Devices, Inc.
- *  Your use of this code is subject to the terms and conditions of the
- *  GNU general public license version 2. See "COPYING" or
- *  http://www.gnu.org/licenses/gpl.html
- */
-
-enum pstate {
-        HW_PSTATE_INVALID = 0xff,
-        HW_PSTATE_0 = 0,
-        HW_PSTATE_1 = 1,
-        HW_PSTATE_2 = 2,
-        HW_PSTATE_3 = 3,
-        HW_PSTATE_4 = 4,
-        HW_PSTATE_5 = 5,
-        HW_PSTATE_6 = 6,
-        HW_PSTATE_7 = 7,
-};
-
-struct powernow_k8_data {
-        unsigned int cpu;
-
-        u32 numps;  /* number of p-states */
-        u32 batps;  /* number of p-states supported on battery */
-        u32 max_hw_pstate; /* maximum legal hardware pstate */
-
-        /* these values are constant when the PSB is used to determine
-         * vid/fid pairings, but are modified during the ->target() call
-         * when ACPI is used */
-        u32 rvo;     /* ramp voltage offset */
-        u32 irt;     /* isochronous relief time */
-        u32 vidmvs;  /* usable value calculated from mvs */
-        u32 vstable; /* voltage stabilization time, units 20 us */
-        u32 plllock; /* pll lock time, units 1 us */
-        u32 exttype; /* extended interface = 1 */
-
-        /* keep track of the current fid / vid or pstate */
-        u32 currvid;
-        u32 currfid;
-        enum pstate currpstate;
-
-        /* the powernow_table includes all frequency and vid/fid pairings:
-         * fid are the lower 8 bits of the index, vid are the upper 8 bits.
-         * frequency is in kHz */
-        struct cpufreq_frequency_table  *powernow_table;
-
-        /* the acpi table needs to be kept. it's only available if ACPI was
-         * used to determine valid frequency/vid/fid states */
-        struct acpi_processor_performance acpi_data;
-
-        /* we need to keep track of associated cores, but let cpufreq
-         * handle hotplug events - so just point at cpufreq pol->cpus
-         * structure */
-        struct cpumask *available_cores;
-};
-
-/* processor's cpuid instruction support */
-#define CPUID_PROCESSOR_SIGNATURE       1       /* function 1 */
-#define CPUID_XFAM                      0x0ff00000      /* extended family */
-#define CPUID_XFAM_K8                   0
-#define CPUID_XMOD                      0x000f0000      /* extended model */
-#define CPUID_XMOD_REV_MASK             0x000c0000
-#define CPUID_XFAM_10H                  0x00100000      /* family 0x10 */
-#define CPUID_USE_XFAM_XMOD             0x00000f00
-#define CPUID_GET_MAX_CAPABILITIES      0x80000000
-#define CPUID_FREQ_VOLT_CAPABILITIES    0x80000007
-#define P_STATE_TRANSITION_CAPABLE      6
-
-/* Model Specific Registers for p-state transitions. MSRs are 64-bit. For     */
-/* writes (wrmsr - opcode 0f 30), the register number is placed in ecx, and   */
-/* the value to write is placed in edx:eax. For reads (rdmsr - opcode 0f 32), */
-/* the register number is placed in ecx, and the data is returned in edx:eax. */
-
-#define MSR_FIDVID_CTL      0xc0010041
-#define MSR_FIDVID_STATUS   0xc0010042
-
-/* Field definitions within the FID VID Low Control MSR : */
-#define MSR_C_LO_INIT_FID_VID     0x00010000
-#define MSR_C_LO_NEW_VID          0x00003f00
-#define MSR_C_LO_NEW_FID          0x0000003f
-#define MSR_C_LO_VID_SHIFT        8
-
-/* Field definitions within the FID VID High Control MSR : */
-#define MSR_C_HI_STP_GNT_TO       0x000fffff
-
-/* Field definitions within the FID VID Low Status MSR : */
-#define MSR_S_LO_CHANGE_PENDING   0x80000000   /* cleared when completed */
-#define MSR_S_LO_MAX_RAMP_VID     0x3f000000
-#define MSR_S_LO_MAX_FID          0x003f0000
-#define MSR_S_LO_START_FID        0x00003f00
-#define MSR_S_LO_CURRENT_FID      0x0000003f
-
-/* Field definitions within the FID VID High Status MSR : */
-#define MSR_S_HI_MIN_WORKING_VID  0x3f000000
-#define MSR_S_HI_MAX_WORKING_VID  0x003f0000
-#define MSR_S_HI_START_VID        0x00003f00
-#define MSR_S_HI_CURRENT_VID      0x0000003f
-#define MSR_C_HI_STP_GNT_BENIGN   0x00000001
-
-
-/* Hardware Pstate _PSS and MSR definitions */
-#define USE_HW_PSTATE           0x00000080
-#define HW_PSTATE_MASK          0x00000007
-#define HW_PSTATE_VALID_MASK    0x80000000
-#define HW_PSTATE_MAX_MASK      0x000000f0
-#define HW_PSTATE_MAX_SHIFT     4
-#define MSR_PSTATE_DEF_BASE     0xc0010064 /* base of Pstate MSRs */
-#define MSR_PSTATE_STATUS       0xc0010063 /* Pstate Status MSR */
-#define MSR_PSTATE_CTRL         0xc0010062 /* Pstate control MSR */
-#define MSR_PSTATE_CUR_LIMIT    0xc0010061 /* pstate current limit MSR */
-
-/* define the two driver architectures */
-#define CPU_OPTERON 0
-#define CPU_HW_PSTATE 1
-
-
-/*
- * There are restrictions frequencies have to follow:
- * - only 1 entry in the low fid table ( <=1.4GHz )
- * - lowest entry in the high fid table must be >= 2 * the entry in the
- *   low fid table
- * - lowest entry in the high fid table must be a <= 200MHz + 2 * the entry
- *   in the low fid table
- * - the parts can only step at <= 200 MHz intervals, odd fid values are
- *   supported in revision G and later revisions.
- * - lowest frequency must be >= interprocessor hypertransport link speed
- *   (only applies to MP systems obviously)
- */
-
-/* fids (frequency identifiers) are arranged in 2 tables - lo and hi */
-#define LO_FID_TABLE_TOP     7  /* fid values marking the boundary    */
-#define HI_FID_TABLE_BOTTOM  8  /* between the low and high tables    */
-
-#define LO_VCOFREQ_TABLE_TOP    1400    /* corresponding vco frequency values */
-#define HI_VCOFREQ_TABLE_BOTTOM 1600
-
-#define MIN_FREQ_RESOLUTION  200 /* fids jump by 2 matching freq jumps by 200 */
-
-#define MAX_FID 0x2a    /* Spec only gives FID values as far as 5 GHz */
-#define LEAST_VID 0x3e  /* Lowest (numerically highest) useful vid value */
-
-#define MIN_FREQ 800    /* Min and max freqs, per spec */
-#define MAX_FREQ 5000
-
-#define INVALID_FID_MASK 0xffffffc0  /* not a valid fid if these bits are set */
-#define INVALID_VID_MASK 0xffffffc0  /* not a valid vid if these bits are set */
-
-#define VID_OFF 0x3f
-
-#define STOP_GRANT_5NS 1 /* min poss memory access latency for voltage change */
-
-#define PLL_LOCK_CONVERSION (1000/5) /* ms to ns, then divide by clock period */
-
-#define MAXIMUM_VID_STEPS 1  /* Current cpus only allow a single step of 25mV */
-#define VST_UNITS_20US 20   /* Voltage Stabilization Time is in units of 20us */
-
-/*
- * Most values of interest are encoded in a single field of the _PSS
- * entries: the "control" value.
- */
-
-#define IRT_SHIFT      30
-#define RVO_SHIFT      28
-#define EXT_TYPE_SHIFT 27
-#define PLL_L_SHIFT    20
-#define MVS_SHIFT      18
-#define VST_SHIFT      11
-#define VID_SHIFT       6
-#define IRT_MASK        3
-#define RVO_MASK        3
-#define EXT_TYPE_MASK   1
-#define PLL_L_MASK   0x7f
-#define MVS_MASK        3
-#define VST_MASK     0x7f
-#define VID_MASK     0x1f
-#define FID_MASK     0x1f
-#define EXT_VID_MASK 0x3f
-#define EXT_FID_MASK 0x3f
-
-
-/*
- * Version 1.4 of the PSB table. This table is constructed by BIOS and is
- * to tell the OS's power management driver which VIDs and FIDs are
- * supported by this particular processor.
- * If the data in the PSB / PST is wrong, then this driver will program the
- * wrong values into hardware, which is very likely to lead to a crash.
- */
-
-#define PSB_ID_STRING      "AMDK7PNOW!"
-#define PSB_ID_STRING_LEN  10
-
-#define PSB_VERSION_1_4  0x14
-
-struct psb_s {
-        u8 signature[10];
-        u8 tableversion;
-        u8 flags1;
-        u16 vstable;
-        u8 flags2;
-        u8 num_tables;
-        u32 cpuid;
-        u8 plllocktime;
-        u8 maxfid;
-        u8 maxvid;
-        u8 numps;
-};
-
-/* Pairs of fid/vid values are appended to the version 1.4 PSB table. */
-struct pst_s {
-        u8 fid;
-        u8 vid;
-};
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "powernow-k8", msg)
-
-static int core_voltage_pre_transition(struct powernow_k8_data *data,
-        u32 reqvid, u32 regfid);
-static int core_voltage_post_transition(struct powernow_k8_data *data, u32 reqvid);
-static int core_frequency_transition(struct powernow_k8_data *data, u32 reqfid);
-
-static void powernow_k8_acpi_pst_values(struct powernow_k8_data *data, unsigned int index);
-
-static int fill_powernow_table_pstate(struct powernow_k8_data *data, struct cpufreq_frequency_table *powernow_table);
-static int fill_powernow_table_fidvid(struct powernow_k8_data *data, struct cpufreq_frequency_table *powernow_table);
diff --git a/arch/x86/kernel/cpu/cpufreq/sc520_freq.c b/arch/x86/kernel/cpu/cpufreq/sc520_freq.c
deleted file mode 100644
index 435a996a613a..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/sc520_freq.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- *      sc520_freq.c: cpufreq driver for the AMD Elan sc520
- *
- *      Copyright (C) 2005 Sean Young <sean@mess.org>
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- *
- *      Based on elanfreq.c
- *
- *      2005-03-30: - initial revision
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-
-#include <linux/delay.h>
-#include <linux/cpufreq.h>
-#include <linux/timex.h>
-#include <linux/io.h>
-
-#include <asm/msr.h>
-
-#define MMCR_BASE       0xfffef000      /* The default base address */
-#define OFFS_CPUCTL     0x2   /* CPU Control Register */
-
-static __u8 __iomem *cpuctl;
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "sc520_freq", msg)
-#define PFX "sc520_freq: "
-
-static struct cpufreq_frequency_table sc520_freq_table[] = {
-        {0x01,  100000},
-        {0x02,  133000},
-        {0,     CPUFREQ_TABLE_END},
-};
-
-static unsigned int sc520_freq_get_cpu_frequency(unsigned int cpu)
-{
-        u8 clockspeed_reg = *cpuctl;
-
-        switch (clockspeed_reg & 0x03) {
-        default:
-                printk(KERN_ERR PFX "error: cpuctl register has unexpected "
-                                "value %02x\n", clockspeed_reg);
-        case 0x01:
-                return 100000;
-        case 0x02:
-                return 133000;
-        }
-}
-
-static void sc520_freq_set_cpu_state(unsigned int state)
-{
-
-        struct cpufreq_freqs    freqs;
-        u8 clockspeed_reg;
-
-        freqs.old = sc520_freq_get_cpu_frequency(0);
-        freqs.new = sc520_freq_table[state].frequency;
-        freqs.cpu = 0; /* AMD Elan is UP */
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-
-        dprintk("attempting to set frequency to %i kHz\n",
-                        sc520_freq_table[state].frequency);
-
-        local_irq_disable();
-
-        clockspeed_reg = *cpuctl & ~0x03;
-        *cpuctl = clockspeed_reg | sc520_freq_table[state].index;
-
-        local_irq_enable();
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-};
-
-static int sc520_freq_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, &sc520_freq_table[0]);
-}
-
-static int sc520_freq_target(struct cpufreq_policy *policy,
-                            unsigned int target_freq,
-                            unsigned int relation)
-{
-        unsigned int newstate = 0;
-
-        if (cpufreq_frequency_table_target(policy, sc520_freq_table,
-                                target_freq, relation, &newstate))
-                return -EINVAL;
-
-        sc520_freq_set_cpu_state(newstate);
-
-        return 0;
-}
-
-
-/*
- *      Module init and exit code
- */
-
-static int sc520_freq_cpu_init(struct cpufreq_policy *policy)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        int result;
-
-        /* capability check */
-        if (c->x86_vendor != X86_VENDOR_AMD ||
-            c->x86 != 4 || c->x86_model != 9)
-                return -ENODEV;
-
-        /* cpuinfo and default policy values */
-        policy->cpuinfo.transition_latency = 1000000; /* 1ms */
-        policy->cur = sc520_freq_get_cpu_frequency(0);
-
-        result = cpufreq_frequency_table_cpuinfo(policy, sc520_freq_table);
-        if (result)
-                return result;
-
-        cpufreq_frequency_table_get_attr(sc520_freq_table, policy->cpu);
-
-        return 0;
-}
-
-
-static int sc520_freq_cpu_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
-
-static struct freq_attr *sc520_freq_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-
-static struct cpufreq_driver sc520_freq_driver = {
-        .get    = sc520_freq_get_cpu_frequency,
-        .verify = sc520_freq_verify,
-        .target = sc520_freq_target,
-        .init   = sc520_freq_cpu_init,
-        .exit   = sc520_freq_cpu_exit,
-        .name   = "sc520_freq",
-        .owner  = THIS_MODULE,
-        .attr   = sc520_freq_attr,
-};
-
-
-static int __init sc520_freq_init(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        int err;
-
-        /* Test if we have the right hardware */
-        if (c->x86_vendor != X86_VENDOR_AMD ||
-            c->x86 != 4 || c->x86_model != 9) {
-                dprintk("no Elan SC520 processor found!\n");
-                return -ENODEV;
-        }
-        cpuctl = ioremap((unsigned long)(MMCR_BASE + OFFS_CPUCTL), 1);
-        if (!cpuctl) {
-                printk(KERN_ERR "sc520_freq: error: failed to remap memory\n");
-                return -ENOMEM;
-        }
-
-        err = cpufreq_register_driver(&sc520_freq_driver);
-        if (err)
-                iounmap(cpuctl);
-
-        return err;
-}
-
-
-static void __exit sc520_freq_exit(void)
-{
-        cpufreq_unregister_driver(&sc520_freq_driver);
-        iounmap(cpuctl);
-}
-
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Sean Young <sean@mess.org>");
-MODULE_DESCRIPTION("cpufreq driver for AMD's Elan sc520 CPU");
-
-module_init(sc520_freq_init);
-module_exit(sc520_freq_exit);
-
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
deleted file mode 100644
index 9b1ff37de46a..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-centrino.c
+++ /dev/null
@@ -1,636 +0,0 @@
-/*
- * cpufreq driver for Enhanced SpeedStep, as found in Intel's Pentium
- * M (part of the Centrino chipset).
- *
- * Since the original Pentium M, most new Intel CPUs support Enhanced
- * SpeedStep.
- *
- * Despite the "SpeedStep" in the name, this is almost entirely unlike
- * traditional SpeedStep.
- *
- * Modelled on speedstep.c
- *
- * Copyright (C) 2003 Jeremy Fitzhardinge <jeremy@goop.org>
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/sched.h>        /* current */
-#include <linux/delay.h>
-#include <linux/compiler.h>
-#include <linux/gfp.h>
-
-#include <asm/msr.h>
-#include <asm/processor.h>
-#include <asm/cpufeature.h>
-
-#define PFX             "speedstep-centrino: "
-#define MAINTAINER      "cpufreq@vger.kernel.org"
-
-#define dprintk(msg...) \
-        cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "speedstep-centrino", msg)
-
-#define INTEL_MSR_RANGE (0xffff)
-
-struct cpu_id
-{
-        __u8    x86;            /* CPU family */
-        __u8    x86_model;      /* model */
-        __u8    x86_mask;       /* stepping */
-};
-
-enum {
-        CPU_BANIAS,
-        CPU_DOTHAN_A1,
-        CPU_DOTHAN_A2,
-        CPU_DOTHAN_B0,
-        CPU_MP4HT_D0,
-        CPU_MP4HT_E0,
-};
-
-static const struct cpu_id cpu_ids[] = {
-        [CPU_BANIAS]    = { 6,  9, 5 },
-        [CPU_DOTHAN_A1] = { 6, 13, 1 },
-        [CPU_DOTHAN_A2] = { 6, 13, 2 },
-        [CPU_DOTHAN_B0] = { 6, 13, 6 },
-        [CPU_MP4HT_D0]  = {15,  3, 4 },
-        [CPU_MP4HT_E0]  = {15,  4, 1 },
-};
-#define N_IDS   ARRAY_SIZE(cpu_ids)
-
-struct cpu_model
-{
-        const struct cpu_id *cpu_id;
-        const char      *model_name;
-        unsigned        max_freq; /* max clock in kHz */
-
-        struct cpufreq_frequency_table *op_points; /* clock/voltage pairs */
-};
-static int centrino_verify_cpu_id(const struct cpuinfo_x86 *c,
-                                  const struct cpu_id *x);
-
-/* Operating points for current CPU */
-static DEFINE_PER_CPU(struct cpu_model *, centrino_model);
-static DEFINE_PER_CPU(const struct cpu_id *, centrino_cpu);
-
-static struct cpufreq_driver centrino_driver;
-
-#ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_TABLE
-
-/* Computes the correct form for IA32_PERF_CTL MSR for a particular
-   frequency/voltage operating point; frequency in MHz, volts in mV.
-   This is stored as "index" in the structure. */
-#define OP(mhz, mv)                                                     \
-        {                                                               \
-                .frequency = (mhz) * 1000,                              \
-                .index = (((mhz)/100) << 8) | ((mv - 700) / 16)         \
-        }
-
-/*
- * These voltage tables were derived from the Intel Pentium M
- * datasheet, document 25261202.pdf, Table 5.  I have verified they
- * are consistent with my IBM ThinkPad X31, which has a 1.3GHz Pentium
- * M.
- */
-
-/* Ultra Low Voltage Intel Pentium M processor 900MHz (Banias) */
-static struct cpufreq_frequency_table banias_900[] =
-{
-        OP(600,  844),
-        OP(800,  988),
-        OP(900, 1004),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-/* Ultra Low Voltage Intel Pentium M processor 1000MHz (Banias) */
-static struct cpufreq_frequency_table banias_1000[] =
-{
-        OP(600,   844),
-        OP(800,   972),
-        OP(900,   988),
-        OP(1000, 1004),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-/* Low Voltage Intel Pentium M processor 1.10GHz (Banias) */
-static struct cpufreq_frequency_table banias_1100[] =
-{
-        OP( 600,  956),
-        OP( 800, 1020),
-        OP( 900, 1100),
-        OP(1000, 1164),
-        OP(1100, 1180),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-
-/* Low Voltage Intel Pentium M processor 1.20GHz (Banias) */
-static struct cpufreq_frequency_table banias_1200[] =
-{
-        OP( 600,  956),
-        OP( 800, 1004),
-        OP( 900, 1020),
-        OP(1000, 1100),
-        OP(1100, 1164),
-        OP(1200, 1180),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-/* Intel Pentium M processor 1.30GHz (Banias) */
-static struct cpufreq_frequency_table banias_1300[] =
-{
-        OP( 600,  956),
-        OP( 800, 1260),
-        OP(1000, 1292),
-        OP(1200, 1356),
-        OP(1300, 1388),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-/* Intel Pentium M processor 1.40GHz (Banias) */
-static struct cpufreq_frequency_table banias_1400[] =
-{
-        OP( 600,  956),
-        OP( 800, 1180),
-        OP(1000, 1308),
-        OP(1200, 1436),
-        OP(1400, 1484),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-/* Intel Pentium M processor 1.50GHz (Banias) */
-static struct cpufreq_frequency_table banias_1500[] =
-{
-        OP( 600,  956),
-        OP( 800, 1116),
-        OP(1000, 1228),
-        OP(1200, 1356),
-        OP(1400, 1452),
-        OP(1500, 1484),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-/* Intel Pentium M processor 1.60GHz (Banias) */
-static struct cpufreq_frequency_table banias_1600[] =
-{
-        OP( 600,  956),
-        OP( 800, 1036),
-        OP(1000, 1164),
-        OP(1200, 1276),
-        OP(1400, 1420),
-        OP(1600, 1484),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-
-/* Intel Pentium M processor 1.70GHz (Banias) */
-static struct cpufreq_frequency_table banias_1700[] =
-{
-        OP( 600,  956),
-        OP( 800, 1004),
-        OP(1000, 1116),
-        OP(1200, 1228),
-        OP(1400, 1308),
-        OP(1700, 1484),
-        { .frequency = CPUFREQ_TABLE_END }
-};
-#undef OP
-
-#define _BANIAS(cpuid, max, name)       \
-{       .cpu_id         = cpuid,        \
-        .model_name     = "Intel(R) Pentium(R) M processor " name "MHz", \
-        .max_freq       = (max)*1000,   \
-        .op_points      = banias_##max, \
-}
-#define BANIAS(max)     _BANIAS(&cpu_ids[CPU_BANIAS], max, #max)
-
-/* CPU models, their operating frequency range, and freq/voltage
-   operating points */
-static struct cpu_model models[] =
-{
-        _BANIAS(&cpu_ids[CPU_BANIAS], 900, " 900"),
-        BANIAS(1000),
-        BANIAS(1100),
-        BANIAS(1200),
-        BANIAS(1300),
-        BANIAS(1400),
-        BANIAS(1500),
-        BANIAS(1600),
-        BANIAS(1700),
-
-        /* NULL model_name is a wildcard */
-        { &cpu_ids[CPU_DOTHAN_A1], NULL, 0, NULL },
-        { &cpu_ids[CPU_DOTHAN_A2], NULL, 0, NULL },
-        { &cpu_ids[CPU_DOTHAN_B0], NULL, 0, NULL },
-        { &cpu_ids[CPU_MP4HT_D0], NULL, 0, NULL },
-        { &cpu_ids[CPU_MP4HT_E0], NULL, 0, NULL },
-
-        { NULL, }
-};
-#undef _BANIAS
-#undef BANIAS
-
-static int centrino_cpu_init_table(struct cpufreq_policy *policy)
-{
-        struct cpuinfo_x86 *cpu = &cpu_data(policy->cpu);
-        struct cpu_model *model;
-
-        for(model = models; model->cpu_id != NULL; model++)
-                if (centrino_verify_cpu_id(cpu, model->cpu_id) &&
-                    (model->model_name == NULL ||
-                     strcmp(cpu->x86_model_id, model->model_name) == 0))
-                        break;
-
-        if (model->cpu_id == NULL) {
-                /* No match at all */
-                dprintk("no support for CPU model \"%s\": "
-                       "send /proc/cpuinfo to " MAINTAINER "\n",
-                       cpu->x86_model_id);
-                return -ENOENT;
-        }
-
-        if (model->op_points == NULL) {
-                /* Matched a non-match */
-                dprintk("no table support for CPU model \"%s\"\n",
-                       cpu->x86_model_id);
-                dprintk("try using the acpi-cpufreq driver\n");
-                return -ENOENT;
-        }
-
-        per_cpu(centrino_model, policy->cpu) = model;
-
-        dprintk("found \"%s\": max frequency: %dkHz\n",
-               model->model_name, model->max_freq);
-
-        return 0;
-}
-
-#else
-static inline int centrino_cpu_init_table(struct cpufreq_policy *policy)
-{
-        return -ENODEV;
-}
-#endif /* CONFIG_X86_SPEEDSTEP_CENTRINO_TABLE */
-
-static int centrino_verify_cpu_id(const struct cpuinfo_x86 *c,
-                                  const struct cpu_id *x)
-{
-        if ((c->x86 == x->x86) &&
-            (c->x86_model == x->x86_model) &&
-            (c->x86_mask == x->x86_mask))
-                return 1;
-        return 0;
-}
-
-/* To be called only after centrino_model is initialized */
-static unsigned extract_clock(unsigned msr, unsigned int cpu, int failsafe)
-{
-        int i;
-
-        /*
-         * Extract clock in kHz from PERF_CTL value
-         * for centrino, as some DSDTs are buggy.
-         * Ideally, this can be done using the acpi_data structure.
-         */
-        if ((per_cpu(centrino_cpu, cpu) == &cpu_ids[CPU_BANIAS]) ||
-            (per_cpu(centrino_cpu, cpu) == &cpu_ids[CPU_DOTHAN_A1]) ||
-            (per_cpu(centrino_cpu, cpu) == &cpu_ids[CPU_DOTHAN_B0])) {
-                msr = (msr >> 8) & 0xff;
-                return msr * 100000;
-        }
-
-        if ((!per_cpu(centrino_model, cpu)) ||
-            (!per_cpu(centrino_model, cpu)->op_points))
-                return 0;
-
-        msr &= 0xffff;
-        for (i = 0;
-                per_cpu(centrino_model, cpu)->op_points[i].frequency
-                                                        != CPUFREQ_TABLE_END;
-             i++) {
-                if (msr == per_cpu(centrino_model, cpu)->op_points[i].index)
-                        return per_cpu(centrino_model, cpu)->
-                                                        op_points[i].frequency;
-        }
-        if (failsafe)
-                return per_cpu(centrino_model, cpu)->op_points[i-1].frequency;
-        else
-                return 0;
-}
-
-/* Return the current CPU frequency in kHz */
-static unsigned int get_cur_freq(unsigned int cpu)
-{
-        unsigned l, h;
-        unsigned clock_freq;
-
-        rdmsr_on_cpu(cpu, MSR_IA32_PERF_STATUS, &l, &h);
-        clock_freq = extract_clock(l, cpu, 0);
-
-        if (unlikely(clock_freq == 0)) {
-                /*
-                 * On some CPUs, we can see transient MSR values (which are
-                 * not present in _PSS), while CPU is doing some automatic
-                 * P-state transition (like TM2). Get the last freq set 
-                 * in PERF_CTL.
-                 */
-                rdmsr_on_cpu(cpu, MSR_IA32_PERF_CTL, &l, &h);
-                clock_freq = extract_clock(l, cpu, 1);
-        }
-        return clock_freq;
-}
-
-
-static int centrino_cpu_init(struct cpufreq_policy *policy)
-{
-        struct cpuinfo_x86 *cpu = &cpu_data(policy->cpu);
-        unsigned freq;
-        unsigned l, h;
-        int ret;
-        int i;
-
-        /* Only Intel makes Enhanced Speedstep-capable CPUs */
-        if (cpu->x86_vendor != X86_VENDOR_INTEL ||
-            !cpu_has(cpu, X86_FEATURE_EST))
-                return -ENODEV;
-
-        if (cpu_has(cpu, X86_FEATURE_CONSTANT_TSC))
-                centrino_driver.flags |= CPUFREQ_CONST_LOOPS;
-
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        for (i = 0; i < N_IDS; i++)
-                if (centrino_verify_cpu_id(cpu, &cpu_ids[i]))
-                        break;
-
-        if (i != N_IDS)
-                per_cpu(centrino_cpu, policy->cpu) = &cpu_ids[i];
-
-        if (!per_cpu(centrino_cpu, policy->cpu)) {
-                dprintk("found unsupported CPU with "
-                "Enhanced SpeedStep: send /proc/cpuinfo to "
-                MAINTAINER "\n");
-                return -ENODEV;
-        }
-
-        if (centrino_cpu_init_table(policy)) {
-                return -ENODEV;
-        }
-
-        /* Check to see if Enhanced SpeedStep is enabled, and try to
-           enable it if not. */
-        rdmsr(MSR_IA32_MISC_ENABLE, l, h);
-
-        if (!(l & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
-                l |= MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP;
-                dprintk("trying to enable Enhanced SpeedStep (%x)\n", l);
-                wrmsr(MSR_IA32_MISC_ENABLE, l, h);
-
-                /* check to see if it stuck */
-                rdmsr(MSR_IA32_MISC_ENABLE, l, h);
-                if (!(l & MSR_IA32_MISC_ENABLE_ENHANCED_SPEEDSTEP)) {
-                        printk(KERN_INFO PFX
-                                "couldn't enable Enhanced SpeedStep\n");
-                        return -ENODEV;
-                }
-        }
-
-        freq = get_cur_freq(policy->cpu);
-        policy->cpuinfo.transition_latency = 10000;
-                                                /* 10uS transition latency */
-        policy->cur = freq;
-
-        dprintk("centrino_cpu_init: cur=%dkHz\n", policy->cur);
-
-        ret = cpufreq_frequency_table_cpuinfo(policy,
-                per_cpu(centrino_model, policy->cpu)->op_points);
-        if (ret)
-                return (ret);
-
-        cpufreq_frequency_table_get_attr(
-                per_cpu(centrino_model, policy->cpu)->op_points, policy->cpu);
-
-        return 0;
-}
-
-static int centrino_cpu_exit(struct cpufreq_policy *policy)
-{
-        unsigned int cpu = policy->cpu;
-
-        if (!per_cpu(centrino_model, cpu))
-                return -ENODEV;
-
-        cpufreq_frequency_table_put_attr(cpu);
-
-        per_cpu(centrino_model, cpu) = NULL;
-
-        return 0;
-}
-
-/**
- * centrino_verify - verifies a new CPUFreq policy
- * @policy: new policy
- *
- * Limit must be within this model's frequency range at least one
- * border included.
- */
-static int centrino_verify (struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy,
-                        per_cpu(centrino_model, policy->cpu)->op_points);
-}
-
-/**
- * centrino_setpolicy - set a new CPUFreq policy
- * @policy: new policy
- * @target_freq: the target frequency
- * @relation: how that frequency relates to achieved frequency
- *      (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H)
- *
- * Sets a new CPUFreq policy.
- */
-static int centrino_target (struct cpufreq_policy *policy,
-                            unsigned int target_freq,
-                            unsigned int relation)
-{
-        unsigned int    newstate = 0;
-        unsigned int    msr, oldmsr = 0, h = 0, cpu = policy->cpu;
-        struct cpufreq_freqs    freqs;
-        int                     retval = 0;
-        unsigned int            j, k, first_cpu, tmp;
-        cpumask_var_t covered_cpus;
-
-        if (unlikely(!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL)))
-                return -ENOMEM;
-
-        if (unlikely(per_cpu(centrino_model, cpu) == NULL)) {
-                retval = -ENODEV;
-                goto out;
-        }
-
-        if (unlikely(cpufreq_frequency_table_target(policy,
-                        per_cpu(centrino_model, cpu)->op_points,
-                        target_freq,
-                        relation,
-                        &newstate))) {
-                retval = -EINVAL;
-                goto out;
-        }
-
-        first_cpu = 1;
-        for_each_cpu(j, policy->cpus) {
-                int good_cpu;
-
-                /* cpufreq holds the hotplug lock, so we are safe here */
-                if (!cpu_online(j))
-                        continue;
-
-                /*
-                 * Support for SMP systems.
-                 * Make sure we are running on CPU that wants to change freq
-                 */
-                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
-                        good_cpu = cpumask_any_and(policy->cpus,
-                                                   cpu_online_mask);
-                else
-                        good_cpu = j;
-
-                if (good_cpu >= nr_cpu_ids) {
-                        dprintk("couldn't limit to CPUs in this domain\n");
-                        retval = -EAGAIN;
-                        if (first_cpu) {
-                                /* We haven't started the transition yet. */
-                                goto out;
-                        }
-                        break;
-                }
-
-                msr = per_cpu(centrino_model, cpu)->op_points[newstate].index;
-
-                if (first_cpu) {
-                        rdmsr_on_cpu(good_cpu, MSR_IA32_PERF_CTL, &oldmsr, &h);
-                        if (msr == (oldmsr & 0xffff)) {
-                                dprintk("no change needed - msr was and needs "
-                                        "to be %x\n", oldmsr);
-                                retval = 0;
-                                goto out;
-                        }
-
-                        freqs.old = extract_clock(oldmsr, cpu, 0);
-                        freqs.new = extract_clock(msr, cpu, 0);
-
-                        dprintk("target=%dkHz old=%d new=%d msr=%04x\n",
-                                target_freq, freqs.old, freqs.new, msr);
-
-                        for_each_cpu(k, policy->cpus) {
-                                if (!cpu_online(k))
-                                        continue;
-                                freqs.cpu = k;
-                                cpufreq_notify_transition(&freqs,
-                                        CPUFREQ_PRECHANGE);
-                        }
-
-                        first_cpu = 0;
-                        /* all but 16 LSB are reserved, treat them with care */
-                        oldmsr &= ~0xffff;
-                        msr &= 0xffff;
-                        oldmsr |= msr;
-                }
-
-                wrmsr_on_cpu(good_cpu, MSR_IA32_PERF_CTL, oldmsr, h);
-                if (policy->shared_type == CPUFREQ_SHARED_TYPE_ANY)
-                        break;
-
-                cpumask_set_cpu(j, covered_cpus);
-        }
-
-        for_each_cpu(k, policy->cpus) {
-                if (!cpu_online(k))
-                        continue;
-                freqs.cpu = k;
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        }
-
-        if (unlikely(retval)) {
-                /*
-                 * We have failed halfway through the frequency change.
-                 * We have sent callbacks to policy->cpus and
-                 * MSRs have already been written on coverd_cpus.
-                 * Best effort undo..
-                 */
-
-                for_each_cpu(j, covered_cpus)
-                        wrmsr_on_cpu(j, MSR_IA32_PERF_CTL, oldmsr, h);
-
-                tmp = freqs.new;
-                freqs.new = freqs.old;
-                freqs.old = tmp;
-                for_each_cpu(j, policy->cpus) {
-                        if (!cpu_online(j))
-                                continue;
-                        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-                        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-                }
-        }
-        retval = 0;
-
-out:
-        free_cpumask_var(covered_cpus);
-        return retval;
-}
-
-static struct freq_attr* centrino_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver centrino_driver = {
-        .name           = "centrino", /* should be speedstep-centrino,
-                                         but there's a 16 char limit */
-        .init           = centrino_cpu_init,
-        .exit           = centrino_cpu_exit,
-        .verify         = centrino_verify,
-        .target         = centrino_target,
-        .get            = get_cur_freq,
-        .attr           = centrino_attr,
-        .owner          = THIS_MODULE,
-};
-
-
-/**
- * centrino_init - initializes the Enhanced SpeedStep CPUFreq driver
- *
- * Initializes the Enhanced SpeedStep support. Returns -ENODEV on
- * unsupported devices, -ENOENT if there's no voltage table for this
- * particular CPU model, -EINVAL on problems during initiatization,
- * and zero on success.
- *
- * This is quite picky.  Not only does the CPU have to advertise the
- * "est" flag in the cpuid capability flags, we look for a specific
- * CPU model and stepping, and we need to have the exact model name in
- * our voltage tables.  That is, be paranoid about not releasing
- * someone's valuable magic smoke.
- */
-static int __init centrino_init(void)
-{
-        struct cpuinfo_x86 *cpu = &cpu_data(0);
-
-        if (!cpu_has(cpu, X86_FEATURE_EST))
-                return -ENODEV;
-
-        return cpufreq_register_driver(&centrino_driver);
-}
-
-static void __exit centrino_exit(void)
-{
-        cpufreq_unregister_driver(&centrino_driver);
-}
-
-MODULE_AUTHOR ("Jeremy Fitzhardinge <jeremy@goop.org>");
-MODULE_DESCRIPTION ("Enhanced SpeedStep driver for Intel Pentium M processors.");
-MODULE_LICENSE ("GPL");
-
-late_initcall(centrino_init);
-module_exit(centrino_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c b/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
deleted file mode 100644
index 561758e95180..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-ich.c
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * (C) 2001  Dave Jones, Arjan van de ven.
- * (C) 2002 - 2003  Dominik Brodowski <linux@brodo.de>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *  Based upon reverse engineered information, and on Intel documentation
- *  for chipsets ICH2-M and ICH3-M.
- *
- *  Many thanks to Ducrot Bruno for finding and fixing the last
- *  "missing link" for ICH2-M/ICH3-M support, and to Thomas Winkler
- *  for extensive testing.
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-
-/*********************************************************************
- *                        SPEEDSTEP - DEFINITIONS                    *
- *********************************************************************/
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/pci.h>
-#include <linux/sched.h>
-
-#include "speedstep-lib.h"
-
-
-/* speedstep_chipset:
- *   It is necessary to know which chipset is used. As accesses to
- * this device occur at various places in this module, we need a
- * static struct pci_dev * pointing to that device.
- */
-static struct pci_dev *speedstep_chipset_dev;
-
-
-/* speedstep_processor
- */
-static enum speedstep_processor speedstep_processor;
-
-static u32 pmbase;
-
-/*
- *   There are only two frequency states for each processor. Values
- * are in kHz for the time being.
- */
-static struct cpufreq_frequency_table speedstep_freqs[] = {
-        {SPEEDSTEP_HIGH,        0},
-        {SPEEDSTEP_LOW,         0},
-        {0,                     CPUFREQ_TABLE_END},
-};
-
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "speedstep-ich", msg)
-
-
-/**
- * speedstep_find_register - read the PMBASE address
- *
- * Returns: -ENODEV if no register could be found
- */
-static int speedstep_find_register(void)
-{
-        if (!speedstep_chipset_dev)
-                return -ENODEV;
-
-        /* get PMBASE */
-        pci_read_config_dword(speedstep_chipset_dev, 0x40, &pmbase);
-        if (!(pmbase & 0x01)) {
-                printk(KERN_ERR "speedstep-ich: could not find speedstep register\n");
-                return -ENODEV;
-        }
-
-        pmbase &= 0xFFFFFFFE;
-        if (!pmbase) {
-                printk(KERN_ERR "speedstep-ich: could not find speedstep register\n");
-                return -ENODEV;
-        }
-
-        dprintk("pmbase is 0x%x\n", pmbase);
-        return 0;
-}
-
-/**
- * speedstep_set_state - set the SpeedStep state
- * @state: new processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH)
- *
- *   Tries to change the SpeedStep state.  Can be called from
- *   smp_call_function_single.
- */
-static void speedstep_set_state(unsigned int state)
-{
-        u8 pm2_blk;
-        u8 value;
-        unsigned long flags;
-
-        if (state > 0x1)
-                return;
-
-        /* Disable IRQs */
-        local_irq_save(flags);
-
-        /* read state */
-        value = inb(pmbase + 0x50);
-
-        dprintk("read at pmbase 0x%x + 0x50 returned 0x%x\n", pmbase, value);
-
-        /* write new state */
-        value &= 0xFE;
-        value |= state;
-
-        dprintk("writing 0x%x to pmbase 0x%x + 0x50\n", value, pmbase);
-
-        /* Disable bus master arbitration */
-        pm2_blk = inb(pmbase + 0x20);
-        pm2_blk |= 0x01;
-        outb(pm2_blk, (pmbase + 0x20));
-
-        /* Actual transition */
-        outb(value, (pmbase + 0x50));
-
-        /* Restore bus master arbitration */
-        pm2_blk &= 0xfe;
-        outb(pm2_blk, (pmbase + 0x20));
-
-        /* check if transition was successful */
-        value = inb(pmbase + 0x50);
-
-        /* Enable IRQs */
-        local_irq_restore(flags);
-
-        dprintk("read at pmbase 0x%x + 0x50 returned 0x%x\n", pmbase, value);
-
-        if (state == (value & 0x1))
-                dprintk("change to %u MHz succeeded\n",
-                        speedstep_get_frequency(speedstep_processor) / 1000);
-        else
-                printk(KERN_ERR "cpufreq: change failed - I/O error\n");
-
-        return;
-}
-
-/* Wrapper for smp_call_function_single. */
-static void _speedstep_set_state(void *_state)
-{
-        speedstep_set_state(*(unsigned int *)_state);
-}
-
-/**
- * speedstep_activate - activate SpeedStep control in the chipset
- *
- *   Tries to activate the SpeedStep status and control registers.
- * Returns -EINVAL on an unsupported chipset, and zero on success.
- */
-static int speedstep_activate(void)
-{
-        u16 value = 0;
-
-        if (!speedstep_chipset_dev)
-                return -EINVAL;
-
-        pci_read_config_word(speedstep_chipset_dev, 0x00A0, &value);
-        if (!(value & 0x08)) {
-                value |= 0x08;
-                dprintk("activating SpeedStep (TM) registers\n");
-                pci_write_config_word(speedstep_chipset_dev, 0x00A0, value);
-        }
-
-        return 0;
-}
-
-
-/**
- * speedstep_detect_chipset - detect the Southbridge which contains SpeedStep logic
- *
- *   Detects ICH2-M, ICH3-M and ICH4-M so far. The pci_dev points to
- * the LPC bridge / PM module which contains all power-management
- * functions. Returns the SPEEDSTEP_CHIPSET_-number for the detected
- * chipset, or zero on failure.
- */
-static unsigned int speedstep_detect_chipset(void)
-{
-        speedstep_chipset_dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
-                              PCI_DEVICE_ID_INTEL_82801DB_12,
-                              PCI_ANY_ID, PCI_ANY_ID,
-                              NULL);
-        if (speedstep_chipset_dev)
-                return 4; /* 4-M */
-
-        speedstep_chipset_dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
-                              PCI_DEVICE_ID_INTEL_82801CA_12,
-                              PCI_ANY_ID, PCI_ANY_ID,
-                              NULL);
-        if (speedstep_chipset_dev)
-                return 3; /* 3-M */
-
-
-        speedstep_chipset_dev = pci_get_subsys(PCI_VENDOR_ID_INTEL,
-                              PCI_DEVICE_ID_INTEL_82801BA_10,
-                              PCI_ANY_ID, PCI_ANY_ID,
-                              NULL);
-        if (speedstep_chipset_dev) {
-                /* speedstep.c causes lockups on Dell Inspirons 8000 and
-                 * 8100 which use a pretty old revision of the 82815
-                 * host brige. Abort on these systems.
-                 */
-                static struct pci_dev *hostbridge;
-
-                hostbridge  = pci_get_subsys(PCI_VENDOR_ID_INTEL,
-                              PCI_DEVICE_ID_INTEL_82815_MC,
-                              PCI_ANY_ID, PCI_ANY_ID,
-                              NULL);
-
-                if (!hostbridge)
-                        return 2; /* 2-M */
-
-                if (hostbridge->revision < 5) {
-                        dprintk("hostbridge does not support speedstep\n");
-                        speedstep_chipset_dev = NULL;
-                        pci_dev_put(hostbridge);
-                        return 0;
-                }
-
-                pci_dev_put(hostbridge);
-                return 2; /* 2-M */
-        }
-
-        return 0;
-}
-
-static void get_freq_data(void *_speed)
-{
-        unsigned int *speed = _speed;
-
-        *speed = speedstep_get_frequency(speedstep_processor);
-}
-
-static unsigned int speedstep_get(unsigned int cpu)
-{
-        unsigned int speed;
-
-        /* You're supposed to ensure CPU is online. */
-        if (smp_call_function_single(cpu, get_freq_data, &speed, 1) != 0)
-                BUG();
-
-        dprintk("detected %u kHz as current frequency\n", speed);
-        return speed;
-}
-
-/**
- * speedstep_target - set a new CPUFreq policy
- * @policy: new policy
- * @target_freq: the target frequency
- * @relation: how that frequency relates to achieved frequency
- *      (CPUFREQ_RELATION_L or CPUFREQ_RELATION_H)
- *
- * Sets a new CPUFreq policy.
- */
-static int speedstep_target(struct cpufreq_policy *policy,
-                             unsigned int target_freq,
-                             unsigned int relation)
-{
-        unsigned int newstate = 0, policy_cpu;
-        struct cpufreq_freqs freqs;
-        int i;
-
-        if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0],
-                                target_freq, relation, &newstate))
-                return -EINVAL;
-
-        policy_cpu = cpumask_any_and(policy->cpus, cpu_online_mask);
-        freqs.old = speedstep_get(policy_cpu);
-        freqs.new = speedstep_freqs[newstate].frequency;
-        freqs.cpu = policy->cpu;
-
-        dprintk("transiting from %u to %u kHz\n", freqs.old, freqs.new);
-
-        /* no transition necessary */
-        if (freqs.old == freqs.new)
-                return 0;
-
-        for_each_cpu(i, policy->cpus) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        }
-
-        smp_call_function_single(policy_cpu, _speedstep_set_state, &newstate,
-                                 true);
-
-        for_each_cpu(i, policy->cpus) {
-                freqs.cpu = i;
-                cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        }
-
-        return 0;
-}
-
-
-/**
- * speedstep_verify - verifies a new CPUFreq policy
- * @policy: new policy
- *
- * Limit must be within speedstep_low_freq and speedstep_high_freq, with
- * at least one border included.
- */
-static int speedstep_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, &speedstep_freqs[0]);
-}
-
-struct get_freqs {
-        struct cpufreq_policy *policy;
-        int ret;
-};
-
-static void get_freqs_on_cpu(void *_get_freqs)
-{
-        struct get_freqs *get_freqs = _get_freqs;
-
-        get_freqs->ret =
-                speedstep_get_freqs(speedstep_processor,
-                            &speedstep_freqs[SPEEDSTEP_LOW].frequency,
-                            &speedstep_freqs[SPEEDSTEP_HIGH].frequency,
-                            &get_freqs->policy->cpuinfo.transition_latency,
-                            &speedstep_set_state);
-}
-
-static int speedstep_cpu_init(struct cpufreq_policy *policy)
-{
-        int result;
-        unsigned int policy_cpu, speed;
-        struct get_freqs gf;
-
-        /* only run on CPU to be set, or on its sibling */
-#ifdef CONFIG_SMP
-        cpumask_copy(policy->cpus, cpu_sibling_mask(policy->cpu));
-#endif
-        policy_cpu = cpumask_any_and(policy->cpus, cpu_online_mask);
-
-        /* detect low and high frequency and transition latency */
-        gf.policy = policy;
-        smp_call_function_single(policy_cpu, get_freqs_on_cpu, &gf, 1);
-        if (gf.ret)
-                return gf.ret;
-
-        /* get current speed setting */
-        speed = speedstep_get(policy_cpu);
-        if (!speed)
-                return -EIO;
-
-        dprintk("currently at %s speed setting - %i MHz\n",
-                (speed == speedstep_freqs[SPEEDSTEP_LOW].frequency)
-                ? "low" : "high",
-                (speed / 1000));
-
-        /* cpuinfo and default policy values */
-        policy->cur = speed;
-
-        result = cpufreq_frequency_table_cpuinfo(policy, speedstep_freqs);
-        if (result)
-                return result;
-
-        cpufreq_frequency_table_get_attr(speedstep_freqs, policy->cpu);
-
-        return 0;
-}
-
-
-static int speedstep_cpu_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
-static struct freq_attr *speedstep_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-
-static struct cpufreq_driver speedstep_driver = {
-        .name   = "speedstep-ich",
-        .verify = speedstep_verify,
-        .target = speedstep_target,
-        .init   = speedstep_cpu_init,
-        .exit   = speedstep_cpu_exit,
-        .get    = speedstep_get,
-        .owner  = THIS_MODULE,
-        .attr   = speedstep_attr,
-};
-
-
-/**
- * speedstep_init - initializes the SpeedStep CPUFreq driver
- *
- *   Initializes the SpeedStep support. Returns -ENODEV on unsupported
- * devices, -EINVAL on problems during initiatization, and zero on
- * success.
- */
-static int __init speedstep_init(void)
-{
-        /* detect processor */
-        speedstep_processor = speedstep_detect_processor();
-        if (!speedstep_processor) {
-                dprintk("Intel(R) SpeedStep(TM) capable processor "
-                                "not found\n");
-                return -ENODEV;
-        }
-
-        /* detect chipset */
-        if (!speedstep_detect_chipset()) {
-                dprintk("Intel(R) SpeedStep(TM) for this chipset not "
-                                "(yet) available.\n");
-                return -ENODEV;
-        }
-
-        /* activate speedstep support */
-        if (speedstep_activate()) {
-                pci_dev_put(speedstep_chipset_dev);
-                return -EINVAL;
-        }
-
-        if (speedstep_find_register())
-                return -ENODEV;
-
-        return cpufreq_register_driver(&speedstep_driver);
-}
-
-
-/**
- * speedstep_exit - unregisters SpeedStep support
- *
- *   Unregisters SpeedStep support.
- */
-static void __exit speedstep_exit(void)
-{
-        pci_dev_put(speedstep_chipset_dev);
-        cpufreq_unregister_driver(&speedstep_driver);
-}
-
-
-MODULE_AUTHOR("Dave Jones <davej@redhat.com>, "
-                "Dominik Brodowski <linux@brodo.de>");
-MODULE_DESCRIPTION("Speedstep driver for Intel mobile processors on chipsets "
-                "with ICH-M southbridges.");
-MODULE_LICENSE("GPL");
-
-module_init(speedstep_init);
-module_exit(speedstep_exit);
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-lib.c b/arch/x86/kernel/cpu/cpufreq/speedstep-lib.c
deleted file mode 100644
index a94ec6be69fa..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-lib.c
+++ /dev/null
@@ -1,481 +0,0 @@
-/*
- * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- *  Library for common functions for Intel SpeedStep v.1 and v.2 support
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-
-#include <asm/msr.h>
-#include <asm/tsc.h>
-#include "speedstep-lib.h"
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "speedstep-lib", msg)
-
-#define PFX "speedstep-lib: "
-
-#ifdef CONFIG_X86_SPEEDSTEP_RELAXED_CAP_CHECK
-static int relaxed_check;
-#else
-#define relaxed_check 0
-#endif
-
-/*********************************************************************
- *                   GET PROCESSOR CORE SPEED IN KHZ                 *
- *********************************************************************/
-
-static unsigned int pentium3_get_frequency(enum speedstep_processor processor)
-{
-        /* See table 14 of p3_ds.pdf and table 22 of 29834003.pdf */
-        struct {
-                unsigned int ratio;     /* Frequency Multiplier (x10) */
-                u8 bitmap;              /* power on configuration bits
-                                        [27, 25:22] (in MSR 0x2a) */
-        } msr_decode_mult[] = {
-                { 30, 0x01 },
-                { 35, 0x05 },
-                { 40, 0x02 },
-                { 45, 0x06 },
-                { 50, 0x00 },
-                { 55, 0x04 },
-                { 60, 0x0b },
-                { 65, 0x0f },
-                { 70, 0x09 },
-                { 75, 0x0d },
-                { 80, 0x0a },
-                { 85, 0x26 },
-                { 90, 0x20 },
-                { 100, 0x2b },
-                { 0, 0xff }     /* error or unknown value */
-        };
-
-        /* PIII(-M) FSB settings: see table b1-b of 24547206.pdf */
-        struct {
-                unsigned int value;     /* Front Side Bus speed in MHz */
-                u8 bitmap;              /* power on configuration bits [18: 19]
-                                        (in MSR 0x2a) */
-        } msr_decode_fsb[] = {
-                {  66, 0x0 },
-                { 100, 0x2 },
-                { 133, 0x1 },
-                {   0, 0xff}
-        };
-
-        u32 msr_lo, msr_tmp;
-        int i = 0, j = 0;
-
-        /* read MSR 0x2a - we only need the low 32 bits */
-        rdmsr(MSR_IA32_EBL_CR_POWERON, msr_lo, msr_tmp);
-        dprintk("P3 - MSR_IA32_EBL_CR_POWERON: 0x%x 0x%x\n", msr_lo, msr_tmp);
-        msr_tmp = msr_lo;
-
-        /* decode the FSB */
-        msr_tmp &= 0x00c0000;
-        msr_tmp >>= 18;
-        while (msr_tmp != msr_decode_fsb[i].bitmap) {
-                if (msr_decode_fsb[i].bitmap == 0xff)
-                        return 0;
-                i++;
-        }
-
-        /* decode the multiplier */
-        if (processor == SPEEDSTEP_CPU_PIII_C_EARLY) {
-                dprintk("workaround for early PIIIs\n");
-                msr_lo &= 0x03c00000;
-        } else
-                msr_lo &= 0x0bc00000;
-        msr_lo >>= 22;
-        while (msr_lo != msr_decode_mult[j].bitmap) {
-                if (msr_decode_mult[j].bitmap == 0xff)
-                        return 0;
-                j++;
-        }
-
-        dprintk("speed is %u\n",
-                (msr_decode_mult[j].ratio * msr_decode_fsb[i].value * 100));
-
-        return msr_decode_mult[j].ratio * msr_decode_fsb[i].value * 100;
-}
-
-
-static unsigned int pentiumM_get_frequency(void)
-{
-        u32 msr_lo, msr_tmp;
-
-        rdmsr(MSR_IA32_EBL_CR_POWERON, msr_lo, msr_tmp);
-        dprintk("PM - MSR_IA32_EBL_CR_POWERON: 0x%x 0x%x\n", msr_lo, msr_tmp);
-
-        /* see table B-2 of 24547212.pdf */
-        if (msr_lo & 0x00040000) {
-                printk(KERN_DEBUG PFX "PM - invalid FSB: 0x%x 0x%x\n",
-                                msr_lo, msr_tmp);
-                return 0;
-        }
-
-        msr_tmp = (msr_lo >> 22) & 0x1f;
-        dprintk("bits 22-26 are 0x%x, speed is %u\n",
-                        msr_tmp, (msr_tmp * 100 * 1000));
-
-        return msr_tmp * 100 * 1000;
-}
-
-static unsigned int pentium_core_get_frequency(void)
-{
-        u32 fsb = 0;
-        u32 msr_lo, msr_tmp;
-        int ret;
-
-        rdmsr(MSR_FSB_FREQ, msr_lo, msr_tmp);
-        /* see table B-2 of 25366920.pdf */
-        switch (msr_lo & 0x07) {
-        case 5:
-                fsb = 100000;
-                break;
-        case 1:
-                fsb = 133333;
-                break;
-        case 3:
-                fsb = 166667;
-                break;
-        case 2:
-                fsb = 200000;
-                break;
-        case 0:
-                fsb = 266667;
-                break;
-        case 4:
-                fsb = 333333;
-                break;
-        default:
-                printk(KERN_ERR "PCORE - MSR_FSB_FREQ undefined value");
-        }
-
-        rdmsr(MSR_IA32_EBL_CR_POWERON, msr_lo, msr_tmp);
-        dprintk("PCORE - MSR_IA32_EBL_CR_POWERON: 0x%x 0x%x\n",
-                        msr_lo, msr_tmp);
-
-        msr_tmp = (msr_lo >> 22) & 0x1f;
-        dprintk("bits 22-26 are 0x%x, speed is %u\n",
-                        msr_tmp, (msr_tmp * fsb));
-
-        ret = (msr_tmp * fsb);
-        return ret;
-}
-
-
-static unsigned int pentium4_get_frequency(void)
-{
-        struct cpuinfo_x86 *c = &boot_cpu_data;
-        u32 msr_lo, msr_hi, mult;
-        unsigned int fsb = 0;
-        unsigned int ret;
-        u8 fsb_code;
-
-        /* Pentium 4 Model 0 and 1 do not have the Core Clock Frequency
-         * to System Bus Frequency Ratio Field in the Processor Frequency
-         * Configuration Register of the MSR. Therefore the current
-         * frequency cannot be calculated and has to be measured.
-         */
-        if (c->x86_model < 2)
-                return cpu_khz;
-
-        rdmsr(0x2c, msr_lo, msr_hi);
-
-        dprintk("P4 - MSR_EBC_FREQUENCY_ID: 0x%x 0x%x\n", msr_lo, msr_hi);
-
-        /* decode the FSB: see IA-32 Intel (C) Architecture Software
-         * Developer's Manual, Volume 3: System Prgramming Guide,
-         * revision #12 in Table B-1: MSRs in the Pentium 4 and
-         * Intel Xeon Processors, on page B-4 and B-5.
-         */
-        fsb_code = (msr_lo >> 16) & 0x7;
-        switch (fsb_code) {
-        case 0:
-                fsb = 100 * 1000;
-                break;
-        case 1:
-                fsb = 13333 * 10;
-                break;
-        case 2:
-                fsb = 200 * 1000;
-                break;
-        }
-
-        if (!fsb)
-                printk(KERN_DEBUG PFX "couldn't detect FSB speed. "
-                                "Please send an e-mail to <linux@brodo.de>\n");
-
-        /* Multiplier. */
-        mult = msr_lo >> 24;
-
-        dprintk("P4 - FSB %u kHz; Multiplier %u; Speed %u kHz\n",
-                        fsb, mult, (fsb * mult));
-
-        ret = (fsb * mult);
-        return ret;
-}
-
-
-/* Warning: may get called from smp_call_function_single. */
-unsigned int speedstep_get_frequency(enum speedstep_processor processor)
-{
-        switch (processor) {
-        case SPEEDSTEP_CPU_PCORE:
-                return pentium_core_get_frequency();
-        case SPEEDSTEP_CPU_PM:
-                return pentiumM_get_frequency();
-        case SPEEDSTEP_CPU_P4D:
-        case SPEEDSTEP_CPU_P4M:
-                return pentium4_get_frequency();
-        case SPEEDSTEP_CPU_PIII_T:
-        case SPEEDSTEP_CPU_PIII_C:
-        case SPEEDSTEP_CPU_PIII_C_EARLY:
-                return pentium3_get_frequency(processor);
-        default:
-                return 0;
-        };
-        return 0;
-}
-EXPORT_SYMBOL_GPL(speedstep_get_frequency);
-
-
-/*********************************************************************
- *                 DETECT SPEEDSTEP-CAPABLE PROCESSOR                *
- *********************************************************************/
-
-unsigned int speedstep_detect_processor(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        u32 ebx, msr_lo, msr_hi;
-
-        dprintk("x86: %x, model: %x\n", c->x86, c->x86_model);
-
-        if ((c->x86_vendor != X86_VENDOR_INTEL) ||
-            ((c->x86 != 6) && (c->x86 != 0xF)))
-                return 0;
-
-        if (c->x86 == 0xF) {
-                /* Intel Mobile Pentium 4-M
-                 * or Intel Mobile Pentium 4 with 533 MHz FSB */
-                if (c->x86_model != 2)
-                        return 0;
-
-                ebx = cpuid_ebx(0x00000001);
-                ebx &= 0x000000FF;
-
-                dprintk("ebx value is %x, x86_mask is %x\n", ebx, c->x86_mask);
-
-                switch (c->x86_mask) {
-                case 4:
-                        /*
-                         * B-stepping [M-P4-M]
-                         * sample has ebx = 0x0f, production has 0x0e.
-                         */
-                        if ((ebx == 0x0e) || (ebx == 0x0f))
-                                return SPEEDSTEP_CPU_P4M;
-                        break;
-                case 7:
-                        /*
-                         * C-stepping [M-P4-M]
-                         * needs to have ebx=0x0e, else it's a celeron:
-                         * cf. 25130917.pdf / page 7, footnote 5 even
-                         * though 25072120.pdf / page 7 doesn't say
-                         * samples are only of B-stepping...
-                         */
-                        if (ebx == 0x0e)
-                                return SPEEDSTEP_CPU_P4M;
-                        break;
-                case 9:
-                        /*
-                         * D-stepping [M-P4-M or M-P4/533]
-                         *
-                         * this is totally strange: CPUID 0x0F29 is
-                         * used by M-P4-M, M-P4/533 and(!) Celeron CPUs.
-                         * The latter need to be sorted out as they don't
-                         * support speedstep.
-                         * Celerons with CPUID 0x0F29 may have either
-                         * ebx=0x8 or 0xf -- 25130917.pdf doesn't say anything
-                         * specific.
-                         * M-P4-Ms may have either ebx=0xe or 0xf [see above]
-                         * M-P4/533 have either ebx=0xe or 0xf. [25317607.pdf]
-                         * also, M-P4M HTs have ebx=0x8, too
-                         * For now, they are distinguished by the model_id
-                         * string
-                         */
-                        if ((ebx == 0x0e) ||
-                                (strstr(c->x86_model_id,
-                                    "Mobile Intel(R) Pentium(R) 4") != NULL))
-                                return SPEEDSTEP_CPU_P4M;
-                        break;
-                default:
-                        break;
-                }
-                return 0;
-        }
-
-        switch (c->x86_model) {
-        case 0x0B: /* Intel PIII [Tualatin] */
-                /* cpuid_ebx(1) is 0x04 for desktop PIII,
-                 * 0x06 for mobile PIII-M */
-                ebx = cpuid_ebx(0x00000001);
-                dprintk("ebx is %x\n", ebx);
-
-                ebx &= 0x000000FF;
-
-                if (ebx != 0x06)
-                        return 0;
-
-                /* So far all PIII-M processors support SpeedStep. See
-                 * Intel's 24540640.pdf of June 2003
-                 */
-                return SPEEDSTEP_CPU_PIII_T;
-
-        case 0x08: /* Intel PIII [Coppermine] */
-
-                /* all mobile PIII Coppermines have FSB 100 MHz
-                 * ==> sort out a few desktop PIIIs. */
-                rdmsr(MSR_IA32_EBL_CR_POWERON, msr_lo, msr_hi);
-                dprintk("Coppermine: MSR_IA32_EBL_CR_POWERON is 0x%x, 0x%x\n",
-                                msr_lo, msr_hi);
-                msr_lo &= 0x00c0000;
-                if (msr_lo != 0x0080000)
-                        return 0;
-
-                /*
-                 * If the processor is a mobile version,
-                 * platform ID has bit 50 set
-                 * it has SpeedStep technology if either
-                 * bit 56 or 57 is set
-                 */
-                rdmsr(MSR_IA32_PLATFORM_ID, msr_lo, msr_hi);
-                dprintk("Coppermine: MSR_IA32_PLATFORM ID is 0x%x, 0x%x\n",
-                                msr_lo, msr_hi);
-                if ((msr_hi & (1<<18)) &&
-                    (relaxed_check ? 1 : (msr_hi & (3<<24)))) {
-                        if (c->x86_mask == 0x01) {
-                                dprintk("early PIII version\n");
-                                return SPEEDSTEP_CPU_PIII_C_EARLY;
-                        } else
-                                return SPEEDSTEP_CPU_PIII_C;
-                }
-
-        default:
-                return 0;
-        }
-}
-EXPORT_SYMBOL_GPL(speedstep_detect_processor);
-
-
-/*********************************************************************
- *                     DETECT SPEEDSTEP SPEEDS                       *
- *********************************************************************/
-
-unsigned int speedstep_get_freqs(enum speedstep_processor processor,
-                                  unsigned int *low_speed,
-                                  unsigned int *high_speed,
-                                  unsigned int *transition_latency,
-                                  void (*set_state) (unsigned int state))
-{
-        unsigned int prev_speed;
-        unsigned int ret = 0;
-        unsigned long flags;
-        struct timeval tv1, tv2;
-
-        if ((!processor) || (!low_speed) || (!high_speed) || (!set_state))
-                return -EINVAL;
-
-        dprintk("trying to determine both speeds\n");
-
-        /* get current speed */
-        prev_speed = speedstep_get_frequency(processor);
-        if (!prev_speed)
-                return -EIO;
-
-        dprintk("previous speed is %u\n", prev_speed);
-
-        local_irq_save(flags);
-
-        /* switch to low state */
-        set_state(SPEEDSTEP_LOW);
-        *low_speed = speedstep_get_frequency(processor);
-        if (!*low_speed) {
-                ret = -EIO;
-                goto out;
-        }
-
-        dprintk("low speed is %u\n", *low_speed);
-
-        /* start latency measurement */
-        if (transition_latency)
-                do_gettimeofday(&tv1);
-
-        /* switch to high state */
-        set_state(SPEEDSTEP_HIGH);
-
-        /* end latency measurement */
-        if (transition_latency)
-                do_gettimeofday(&tv2);
-
-        *high_speed = speedstep_get_frequency(processor);
-        if (!*high_speed) {
-                ret = -EIO;
-                goto out;
-        }
-
-        dprintk("high speed is %u\n", *high_speed);
-
-        if (*low_speed == *high_speed) {
-                ret = -ENODEV;
-                goto out;
-        }
-
-        /* switch to previous state, if necessary */
-        if (*high_speed != prev_speed)
-                set_state(SPEEDSTEP_LOW);
-
-        if (transition_latency) {
-                *transition_latency = (tv2.tv_sec - tv1.tv_sec) * USEC_PER_SEC +
-                        tv2.tv_usec - tv1.tv_usec;
-                dprintk("transition latency is %u uSec\n", *transition_latency);
-
-                /* convert uSec to nSec and add 20% for safety reasons */
-                *transition_latency *= 1200;
-
-                /* check if the latency measurement is too high or too low
-                 * and set it to a safe value (500uSec) in that case
-                 */
-                if (*transition_latency > 10000000 ||
-                    *transition_latency < 50000) {
-                        printk(KERN_WARNING PFX "frequency transition "
-                                        "measured seems out of range (%u "
-                                        "nSec), falling back to a safe one of"
-                                        "%u nSec.\n",
-                                        *transition_latency, 500000);
-                        *transition_latency = 500000;
-                }
-        }
-
-out:
-        local_irq_restore(flags);
-        return ret;
-}
-EXPORT_SYMBOL_GPL(speedstep_get_freqs);
-
-#ifdef CONFIG_X86_SPEEDSTEP_RELAXED_CAP_CHECK
-module_param(relaxed_check, int, 0444);
-MODULE_PARM_DESC(relaxed_check,
-                "Don't do all checks for speedstep capability.");
-#endif
-
-MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
-MODULE_DESCRIPTION("Library for Intel SpeedStep 1 or 2 cpufreq drivers.");
-MODULE_LICENSE("GPL");
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-lib.h b/arch/x86/kernel/cpu/cpufreq/speedstep-lib.h
deleted file mode 100644
index 70d9cea1219d..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-lib.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- *  Library for common functions for Intel SpeedStep v.1 and v.2 support
- *
- *  BIG FAT DISCLAIMER: Work in progress code. Possibly *dangerous*
- */
-
-
-
-/* processors */
-enum speedstep_processor {
-        SPEEDSTEP_CPU_PIII_C_EARLY = 0x00000001,  /* Coppermine core */
-        SPEEDSTEP_CPU_PIII_C       = 0x00000002,  /* Coppermine core */
-        SPEEDSTEP_CPU_PIII_T       = 0x00000003,  /* Tualatin core */
-        SPEEDSTEP_CPU_P4M          = 0x00000004,  /* P4-M  */
-/* the following processors are not speedstep-capable and are not auto-detected
- * in speedstep_detect_processor(). However, their speed can be detected using
- * the speedstep_get_frequency() call. */
-        SPEEDSTEP_CPU_PM           = 0xFFFFFF03,  /* Pentium M  */
-        SPEEDSTEP_CPU_P4D          = 0xFFFFFF04,  /* desktop P4  */
-        SPEEDSTEP_CPU_PCORE        = 0xFFFFFF05,  /* Core */
-};
-
-/* speedstep states -- only two of them */
-
-#define SPEEDSTEP_HIGH  0x00000000
-#define SPEEDSTEP_LOW   0x00000001
-
-
-/* detect a speedstep-capable processor */
-extern enum speedstep_processor speedstep_detect_processor(void);
-
-/* detect the current speed (in khz) of the processor */
-extern unsigned int speedstep_get_frequency(enum speedstep_processor processor);
-
-
-/* detect the low and high speeds of the processor. The callback
- * set_state"'s first argument is either SPEEDSTEP_HIGH or
- * SPEEDSTEP_LOW; the second argument is zero so that no
- * cpufreq_notify_transition calls are initiated.
- */
-extern unsigned int speedstep_get_freqs(enum speedstep_processor processor,
-        unsigned int *low_speed,
-        unsigned int *high_speed,
-        unsigned int *transition_latency,
-        void (*set_state) (unsigned int state));
diff --git a/arch/x86/kernel/cpu/cpufreq/speedstep-smi.c b/arch/x86/kernel/cpu/cpufreq/speedstep-smi.c
deleted file mode 100644
index 91bc25b67bc1..000000000000
--- a/arch/x86/kernel/cpu/cpufreq/speedstep-smi.c
+++ /dev/null
@@ -1,467 +0,0 @@
-/*
- * Intel SpeedStep SMI driver.
- *
- * (C) 2003  Hiroshi Miura <miura@da-cha.org>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- *
- */
-
-
-/*********************************************************************
- *                        SPEEDSTEP - DEFINITIONS                    *
- *********************************************************************/
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/init.h>
-#include <linux/cpufreq.h>
-#include <linux/delay.h>
-#include <linux/io.h>
-#include <asm/ist.h>
-
-#include "speedstep-lib.h"
-
-/* speedstep system management interface port/command.
- *
- * These parameters are got from IST-SMI BIOS call.
- * If user gives it, these are used.
- *
- */
-static int smi_port;
-static int smi_cmd;
-static unsigned int smi_sig;
-
-/* info about the processor */
-static enum speedstep_processor speedstep_processor;
-
-/*
- * There are only two frequency states for each processor. Values
- * are in kHz for the time being.
- */
-static struct cpufreq_frequency_table speedstep_freqs[] = {
-        {SPEEDSTEP_HIGH,        0},
-        {SPEEDSTEP_LOW,         0},
-        {0,                     CPUFREQ_TABLE_END},
-};
-
-#define GET_SPEEDSTEP_OWNER 0
-#define GET_SPEEDSTEP_STATE 1
-#define SET_SPEEDSTEP_STATE 2
-#define GET_SPEEDSTEP_FREQS 4
-
-/* how often shall the SMI call be tried if it failed, e.g. because
- * of DMA activity going on? */
-#define SMI_TRIES 5
-
-#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, \
-                "speedstep-smi", msg)
-
-/**
- * speedstep_smi_ownership
- */
-static int speedstep_smi_ownership(void)
-{
-        u32 command, result, magic, dummy;
-        u32 function = GET_SPEEDSTEP_OWNER;
-        unsigned char magic_data[] = "Copyright (c) 1999 Intel Corporation";
-
-        command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff);
-        magic = virt_to_phys(magic_data);
-
-        dprintk("trying to obtain ownership with command %x at port %x\n",
-                        command, smi_port);
-
-        __asm__ __volatile__(
-                "push %%ebp\n"
-                "out %%al, (%%dx)\n"
-                "pop %%ebp\n"
-                : "=D" (result),
-                  "=a" (dummy), "=b" (dummy), "=c" (dummy), "=d" (dummy),
-                  "=S" (dummy)
-                : "a" (command), "b" (function), "c" (0), "d" (smi_port),
-                  "D" (0), "S" (magic)
-                : "memory"
-        );
-
-        dprintk("result is %x\n", result);
-
-        return result;
-}
-
-/**
- * speedstep_smi_get_freqs - get SpeedStep preferred & current freq.
- * @low: the low frequency value is placed here
- * @high: the high frequency value is placed here
- *
- * Only available on later SpeedStep-enabled systems, returns false results or
- * even hangs [cf. bugme.osdl.org # 1422] on earlier systems. Empirical testing
- * shows that the latter occurs if !(ist_info.event & 0xFFFF).
- */
-static int speedstep_smi_get_freqs(unsigned int *low, unsigned int *high)
-{
-        u32 command, result = 0, edi, high_mhz, low_mhz, dummy;
-        u32 state = 0;
-        u32 function = GET_SPEEDSTEP_FREQS;
-
-        if (!(ist_info.event & 0xFFFF)) {
-                dprintk("bug #1422 -- can't read freqs from BIOS\n");
-                return -ENODEV;
-        }
-
-        command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff);
-
-        dprintk("trying to determine frequencies with command %x at port %x\n",
-                        command, smi_port);
-
-        __asm__ __volatile__(
-                "push %%ebp\n"
-                "out %%al, (%%dx)\n"
-                "pop %%ebp"
-                : "=a" (result),
-                  "=b" (high_mhz),
-                  "=c" (low_mhz),
-                  "=d" (state), "=D" (edi), "=S" (dummy)
-                : "a" (command),
-                  "b" (function),
-                  "c" (state),
-                  "d" (smi_port), "S" (0), "D" (0)
-        );
-
-        dprintk("result %x, low_freq %u, high_freq %u\n",
-                        result, low_mhz, high_mhz);
-
-        /* abort if results are obviously incorrect... */
-        if ((high_mhz + low_mhz) < 600)
-                return -EINVAL;
-
-        *high = high_mhz * 1000;
-        *low  = low_mhz  * 1000;
-
-        return result;
-}
-
-/**
- * speedstep_get_state - set the SpeedStep state
- * @state: processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH)
- *
- */
-static int speedstep_get_state(void)
-{
-        u32 function = GET_SPEEDSTEP_STATE;
-        u32 result, state, edi, command, dummy;
-
-        command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff);
-
-        dprintk("trying to determine current setting with command %x "
-                "at port %x\n", command, smi_port);
-
-        __asm__ __volatile__(
-                "push %%ebp\n"
-                "out %%al, (%%dx)\n"
-                "pop %%ebp\n"
-                : "=a" (result),
-                  "=b" (state), "=D" (edi),
-                  "=c" (dummy), "=d" (dummy), "=S" (dummy)
-                : "a" (command), "b" (function), "c" (0),
-                  "d" (smi_port), "S" (0), "D" (0)
-        );
-
-        dprintk("state is %x, result is %x\n", state, result);
-
-        return state & 1;
-}
-
-
-/**
- * speedstep_set_state - set the SpeedStep state
- * @state: new processor frequency state (SPEEDSTEP_LOW or SPEEDSTEP_HIGH)
- *
- */
-static void speedstep_set_state(unsigned int state)
-{
-        unsigned int result = 0, command, new_state, dummy;
-        unsigned long flags;
-        unsigned int function = SET_SPEEDSTEP_STATE;
-        unsigned int retry = 0;
-
-        if (state > 0x1)
-                return;
-
-        /* Disable IRQs */
-        local_irq_save(flags);
-
-        command = (smi_sig & 0xffffff00) | (smi_cmd & 0xff);
-
-        dprintk("trying to set frequency to state %u "
-                "with command %x at port %x\n",
-                state, command, smi_port);
-
-        do {
-                if (retry) {
-                        dprintk("retry %u, previous result %u, waiting...\n",
-                                        retry, result);
-                        mdelay(retry * 50);
-                }
-                retry++;
-                __asm__ __volatile__(
-                        "push %%ebp\n"
-                        "out %%al, (%%dx)\n"
-                        "pop %%ebp"
-                        : "=b" (new_state), "=D" (result),
-                          "=c" (dummy), "=a" (dummy),
-                          "=d" (dummy), "=S" (dummy)
-                        : "a" (command), "b" (function), "c" (state),
-                          "d" (smi_port), "S" (0), "D" (0)
-                        );
-        } while ((new_state != state) && (retry <= SMI_TRIES));
-
-        /* enable IRQs */
-        local_irq_restore(flags);
-
-        if (new_state == state)
-                dprintk("change to %u MHz succeeded after %u tries "
-                        "with result %u\n",
-                        (speedstep_freqs[new_state].frequency / 1000),
-                        retry, result);
-        else
-                printk(KERN_ERR "cpufreq: change to state %u "
-                        "failed with new_state %u and result %u\n",
-                        state, new_state, result);
-
-        return;
-}
-
-
-/**
- * speedstep_target - set a new CPUFreq policy
- * @policy: new policy
- * @target_freq: new freq
- * @relation:
- *
- * Sets a new CPUFreq policy/freq.
- */
-static int speedstep_target(struct cpufreq_policy *policy,
-                        unsigned int target_freq, unsigned int relation)
-{
-        unsigned int newstate = 0;
-        struct cpufreq_freqs freqs;
-
-        if (cpufreq_frequency_table_target(policy, &speedstep_freqs[0],
-                                target_freq, relation, &newstate))
-                return -EINVAL;
-
-        freqs.old = speedstep_freqs[speedstep_get_state()].frequency;
-        freqs.new = speedstep_freqs[newstate].frequency;
-        freqs.cpu = 0; /* speedstep.c is UP only driver */
-
-        if (freqs.old == freqs.new)
-                return 0;
-
-        cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
-        speedstep_set_state(newstate);
-        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-
-        return 0;
-}
-
-
-/**
- * speedstep_verify - verifies a new CPUFreq policy
- * @policy: new policy
- *
- * Limit must be within speedstep_low_freq and speedstep_high_freq, with
- * at least one border included.
- */
-static int speedstep_verify(struct cpufreq_policy *policy)
-{
-        return cpufreq_frequency_table_verify(policy, &speedstep_freqs[0]);
-}
-
-
-static int speedstep_cpu_init(struct cpufreq_policy *policy)
-{
-        int result;
-        unsigned int speed, state;
-        unsigned int *low, *high;
-
-        /* capability check */
-        if (policy->cpu != 0)
-                return -ENODEV;
-
-        result = speedstep_smi_ownership();
-        if (result) {
-                dprintk("fails in acquiring ownership of a SMI interface.\n");
-                return -EINVAL;
-        }
-
-        /* detect low and high frequency */
-        low = &speedstep_freqs[SPEEDSTEP_LOW].frequency;
-        high = &speedstep_freqs[SPEEDSTEP_HIGH].frequency;
-
-        result = speedstep_smi_get_freqs(low, high);
-        if (result) {
-                /* fall back to speedstep_lib.c dection mechanism:
-                 * try both states out */
-                dprintk("could not detect low and high frequencies "
-                                "by SMI call.\n");
-                result = speedstep_get_freqs(speedstep_processor,
-                                low, high,
-                                NULL,
-                                &speedstep_set_state);
-
-                if (result) {
-                        dprintk("could not detect two different speeds"
-                                        " -- aborting.\n");
-                        return result;
-                } else
-                        dprintk("workaround worked.\n");
-        }
-
-        /* get current speed setting */
-        state = speedstep_get_state();
-        speed = speedstep_freqs[state].frequency;
-
-        dprintk("currently at %s speed setting - %i MHz\n",
-                (speed == speedstep_freqs[SPEEDSTEP_LOW].frequency)
-                ? "low" : "high",
-                (speed / 1000));
-
-        /* cpuinfo and default policy values */
-        policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
-        policy->cur = speed;
-
-        result = cpufreq_frequency_table_cpuinfo(policy, speedstep_freqs);
-        if (result)
-                return result;
-
-        cpufreq_frequency_table_get_attr(speedstep_freqs, policy->cpu);
-
-        return 0;
-}
-
-static int speedstep_cpu_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
-static unsigned int speedstep_get(unsigned int cpu)
-{
-        if (cpu)
-                return -ENODEV;
-        return speedstep_get_frequency(speedstep_processor);
-}
-
-
-static int speedstep_resume(struct cpufreq_policy *policy)
-{
-        int result = speedstep_smi_ownership();
-
-        if (result)
-                dprintk("fails in re-acquiring ownership of a SMI interface.\n");
-
-        return result;
-}
-
-static struct freq_attr *speedstep_attr[] = {
-        &cpufreq_freq_attr_scaling_available_freqs,
-        NULL,
-};
-
-static struct cpufreq_driver speedstep_driver = {
-        .name           = "speedstep-smi",
-        .verify         = speedstep_verify,
-        .target         = speedstep_target,
-        .init           = speedstep_cpu_init,
-        .exit           = speedstep_cpu_exit,
-        .get            = speedstep_get,
-        .resume         = speedstep_resume,
-        .owner          = THIS_MODULE,
-        .attr           = speedstep_attr,
-};
-
-/**
- * speedstep_init - initializes the SpeedStep CPUFreq driver
- *
- *   Initializes the SpeedStep support. Returns -ENODEV on unsupported
- * BIOS, -EINVAL on problems during initiatization, and zero on
- * success.
- */
-static int __init speedstep_init(void)
-{
-        speedstep_processor = speedstep_detect_processor();
-
-        switch (speedstep_processor) {
-        case SPEEDSTEP_CPU_PIII_T:
-        case SPEEDSTEP_CPU_PIII_C:
-        case SPEEDSTEP_CPU_PIII_C_EARLY:
-                break;
-        default:
-                speedstep_processor = 0;
-        }
-
-        if (!speedstep_processor) {
-                dprintk("No supported Intel CPU detected.\n");
-                return -ENODEV;
-        }
-
-        dprintk("signature:0x%.8lx, command:0x%.8lx, "
-                "event:0x%.8lx, perf_level:0x%.8lx.\n",
-                ist_info.signature, ist_info.command,
-                ist_info.event, ist_info.perf_level);
-
-        /* Error if no IST-SMI BIOS or no PARM
-                 sig= 'ISGE' aka 'Intel Speedstep Gate E' */
-        if ((ist_info.signature !=  0x47534943) && (
-            (smi_port == 0) || (smi_cmd == 0)))
-                return -ENODEV;
-
-        if (smi_sig == 1)
-                smi_sig = 0x47534943;
-        else
-                smi_sig = ist_info.signature;
-
-        /* setup smi_port from MODLULE_PARM or BIOS */
-        if ((smi_port > 0xff) || (smi_port < 0))
-                return -EINVAL;
-        else if (smi_port == 0)
-                smi_port = ist_info.command & 0xff;
-
-        if ((smi_cmd > 0xff) || (smi_cmd < 0))
-                return -EINVAL;
-        else if (smi_cmd == 0)
-                smi_cmd = (ist_info.command >> 16) & 0xff;
-
-        return cpufreq_register_driver(&speedstep_driver);
-}
-
-
-/**
- * speedstep_exit - unregisters SpeedStep support
- *
- *   Unregisters SpeedStep support.
- */
-static void __exit speedstep_exit(void)
-{
-        cpufreq_unregister_driver(&speedstep_driver);
-}
-
-module_param(smi_port, int, 0444);
-module_param(smi_cmd,  int, 0444);
-module_param(smi_sig, uint, 0444);
-
-MODULE_PARM_DESC(smi_port, "Override the BIOS-given IST port with this value "
-                "-- Intel's default setting is 0xb2");
-MODULE_PARM_DESC(smi_cmd, "Override the BIOS-given IST command with this value "
-                "-- Intel's default setting is 0x82");
-MODULE_PARM_DESC(smi_sig, "Set to 1 to fake the IST signature when using the "
-                "SMI interface.");
-
-MODULE_AUTHOR("Hiroshi Miura");
-MODULE_DESCRIPTION("Speedstep driver for IST applet SMI interface.");
-MODULE_LICENSE("GPL");
-
-module_init(speedstep_init);
-module_exit(speedstep_exit);
diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c
index df86bc8c859d..1edf5ba4fb2b 100644
--- a/arch/x86/kernel/cpu/intel.c
+++ b/arch/x86/kernel/cpu/intel.c
@@ -29,10 +29,10 @@
 
 static void __cpuinit early_init_intel(struct cpuinfo_x86 *c)
 {
+        u64 misc_enable;
+
         /* Unmask CPUID levels if masked: */
         if (c->x86 > 6 || (c->x86 == 6 && c->x86_model >= 0xd)) {
-                u64 misc_enable;
-
                 rdmsrl(MSR_IA32_MISC_ENABLE, misc_enable);
 
                 if (misc_enable & MSR_IA32_MISC_ENABLE_LIMIT_CPUID) {
@@ -118,8 +118,6 @@ static void __cpuinit early_init_intel(struct cpuinfo_x86 *c)
          * (model 2) with the same problem.
          */
         if (c->x86 == 15) {
-                u64 misc_enable;
-
                 rdmsrl(MSR_IA32_MISC_ENABLE, misc_enable);
 
                 if (misc_enable & MSR_IA32_MISC_ENABLE_FAST_STRING) {
@@ -130,6 +128,19 @@ static void __cpuinit early_init_intel(struct cpuinfo_x86 *c)
                 }
         }
 #endif
+
+        /*
+         * If fast string is not enabled in IA32_MISC_ENABLE for any reason,
+         * clear the fast string and enhanced fast string CPU capabilities.
+         */
+        if (c->x86 > 6 || (c->x86 == 6 && c->x86_model >= 0xd)) {
+                rdmsrl(MSR_IA32_MISC_ENABLE, misc_enable);
+                if (!(misc_enable & MSR_IA32_MISC_ENABLE_FAST_STRING)) {
+                        printk(KERN_INFO "Disabled fast string operations\n");
+                        setup_clear_cpu_cap(X86_FEATURE_REP_GOOD);
+                        setup_clear_cpu_cap(X86_FEATURE_ERMS);
+                }
+        }
 }
 
 #ifdef CONFIG_X86_32
@@ -400,12 +411,10 @@ static void __cpuinit init_intel(struct cpuinfo_x86 *c)
 
                 switch (c->x86_model) {
                 case 5:
-                        if (c->x86_mask == 0) {
-                                if (l2 == 0)
-                                        p = "Celeron (Covington)";
-                                else if (l2 == 256)
-                                        p = "Mobile Pentium II (Dixon)";
-                        }
+                        if (l2 == 0)
+                                p = "Celeron (Covington)";
+                        else if (l2 == 256)
+                                p = "Mobile Pentium II (Dixon)";
                         break;
 
                 case 6:
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c
index 1ce1af2899df..c105c533ed94 100644
--- a/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ b/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -327,7 +327,6 @@ static void __cpuinit amd_calc_l3_indices(struct amd_l3_cache *l3)
         l3->subcaches[2] = sc2 = !(val & BIT(8))  + !(val & BIT(9));
         l3->subcaches[3] = sc3 = !(val & BIT(12)) + !(val & BIT(13));
 
-        l3->indices = (max(max(max(sc0, sc1), sc2), sc3) << 10) - 1;
         l3->indices = (max(max3(sc0, sc1, sc2), sc3) << 10) - 1;
 }
 
@@ -454,27 +453,16 @@ int amd_set_l3_disable_slot(struct amd_l3_cache *l3, int cpu, unsigned slot,
 {
         int ret = 0;
 
-#define SUBCACHE_MASK   (3UL << 20)
-#define SUBCACHE_INDEX  0xfff
-
-        /*
-         * check whether this slot is already used or
-         * the index is already disabled
-         */
+        /*  check if @slot is already used or the index is already disabled */
         ret = amd_get_l3_disable_slot(l3, slot);
         if (ret >= 0)
                 return -EINVAL;
 
-        /*
-         * check whether the other slot has disabled the
-         * same index already
-         */
-        if (index == amd_get_l3_disable_slot(l3, !slot))
+        if (index > l3->indices)
                 return -EINVAL;
 
-        /* do not allow writes outside of allowed bits */
-        if ((index & ~(SUBCACHE_MASK | SUBCACHE_INDEX)) ||
-            ((index & SUBCACHE_INDEX) > l3->indices))
+        /* check whether the other slot has disabled the same index already */
+        if (index == amd_get_l3_disable_slot(l3, !slot))
                 return -EINVAL;
 
         amd_l3_disable_index(l3, cpu, slot, index);
diff --git a/arch/x86/kernel/cpu/mcheck/mce.c b/arch/x86/kernel/cpu/mcheck/mce.c
index 3385ea26f684..ff1ae9b6464d 100644
--- a/arch/x86/kernel/cpu/mcheck/mce.c
+++ b/arch/x86/kernel/cpu/mcheck/mce.c
@@ -105,20 +105,6 @@ static int			cpu_missing;
 ATOMIC_NOTIFIER_HEAD(x86_mce_decoder_chain);
 EXPORT_SYMBOL_GPL(x86_mce_decoder_chain);
 
-static int default_decode_mce(struct notifier_block *nb, unsigned long val,
-                               void *data)
-{
-        pr_emerg(HW_ERR "No human readable MCE decoding support on this CPU type.\n");
-        pr_emerg(HW_ERR "Run the message through 'mcelog --ascii' to decode.\n");
-
-        return NOTIFY_STOP;
-}
-
-static struct notifier_block mce_dec_nb = {
-        .notifier_call = default_decode_mce,
-        .priority      = -1,
-};
-
 /* MCA banks polled by the period polling timer for corrected events */
 DEFINE_PER_CPU(mce_banks_t, mce_poll_banks) = {
         [0 ... BITS_TO_LONGS(MAX_NR_BANKS)-1] = ~0UL
@@ -212,6 +198,8 @@ void mce_log(struct mce *mce)
 
 static void print_mce(struct mce *m)
 {
+        int ret = 0;
+
         pr_emerg(HW_ERR "CPU %d: Machine Check Exception: %Lx Bank %d: %016Lx\n",
                m->extcpu, m->mcgstatus, m->bank, m->status);
 
@@ -239,7 +227,11 @@ static void print_mce(struct mce *m)
          * Print out human-readable details about the MCE error,
          * (if the CPU has an implementation for that)
          */
-        atomic_notifier_call_chain(&x86_mce_decoder_chain, 0, m);
+        ret = atomic_notifier_call_chain(&x86_mce_decoder_chain, 0, m);
+        if (ret == NOTIFY_STOP)
+                return;
+
+        pr_emerg_ratelimited(HW_ERR "Run the above through 'mcelog --ascii'\n");
 }
 
 #define PANIC_TIMEOUT 5 /* 5 seconds */
@@ -590,7 +582,6 @@ void machine_check_poll(enum mcp_flags flags, mce_banks_t *b)
                 if (!(flags & MCP_DONTLOG) && !mce_dont_log_ce) {
                         mce_log(&m);
                         atomic_notifier_call_chain(&x86_mce_decoder_chain, 0, &m);
-                        add_taint(TAINT_MACHINE_CHECK);
                 }
 
                 /*
@@ -1722,8 +1713,6 @@ __setup("mce", mcheck_enable);
 
 int __init mcheck_init(void)
 {
-        atomic_notifier_chain_register(&x86_mce_decoder_chain, &mce_dec_nb);
-
         mcheck_intel_therm_init();
 
         return 0;
diff --git a/arch/x86/kernel/cpu/mcheck/mce_amd.c b/arch/x86/kernel/cpu/mcheck/mce_amd.c
index 167f97b5596e..bb0adad35143 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_amd.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_amd.c
@@ -509,6 +509,7 @@ recurse:
 out_free:
         if (b) {
                 kobject_put(&b->kobj);
+                list_del(&b->miscj);
                 kfree(b);
         }
         return err;
diff --git a/arch/x86/kernel/cpu/mcheck/therm_throt.c b/arch/x86/kernel/cpu/mcheck/therm_throt.c
index 6f8c5e9da97f..27c625178bf1 100644
--- a/arch/x86/kernel/cpu/mcheck/therm_throt.c
+++ b/arch/x86/kernel/cpu/mcheck/therm_throt.c
@@ -187,8 +187,6 @@ static int therm_throt_process(bool new_event, int event, int level)
                                 this_cpu,
                                 level == CORE_LEVEL ? "Core" : "Package",
                                 state->count);
-
-                add_taint(TAINT_MACHINE_CHECK);
                 return 1;
         }
         if (old_event) {
@@ -355,7 +353,6 @@ static void notify_thresholds(__u64 msr_val)
 static void intel_thermal_interrupt(void)
 {
         __u64 msr_val;
-        struct cpuinfo_x86 *c = &cpu_data(smp_processor_id());
 
         rdmsrl(MSR_IA32_THERM_STATUS, msr_val);
 
@@ -367,19 +364,19 @@ static void intel_thermal_interrupt(void)
                                 CORE_LEVEL) != 0)
                 mce_log_therm_throt_event(CORE_THROTTLED | msr_val);
 
-        if (cpu_has(c, X86_FEATURE_PLN))
+        if (this_cpu_has(X86_FEATURE_PLN))
                 if (therm_throt_process(msr_val & THERM_STATUS_POWER_LIMIT,
                                         POWER_LIMIT_EVENT,
                                         CORE_LEVEL) != 0)
                         mce_log_therm_throt_event(CORE_POWER_LIMIT | msr_val);
 
-        if (cpu_has(c, X86_FEATURE_PTS)) {
+        if (this_cpu_has(X86_FEATURE_PTS)) {
                 rdmsrl(MSR_IA32_PACKAGE_THERM_STATUS, msr_val);
                 if (therm_throt_process(msr_val & PACKAGE_THERM_STATUS_PROCHOT,
                                         THERMAL_THROTTLING_EVENT,
                                         PACKAGE_LEVEL) != 0)
                         mce_log_therm_throt_event(PACKAGE_THROTTLED | msr_val);
-                if (cpu_has(c, X86_FEATURE_PLN))
+                if (this_cpu_has(X86_FEATURE_PLN))
                         if (therm_throt_process(msr_val &
                                         PACKAGE_THERM_STATUS_POWER_LIMIT,
                                         POWER_LIMIT_EVENT,
@@ -393,7 +390,6 @@ static void unexpected_thermal_interrupt(void)
 {
         printk(KERN_ERR "CPU%d: Unexpected LVT thermal interrupt!\n",
                         smp_processor_id());
-        add_taint(TAINT_MACHINE_CHECK);
 }
 
 static void (*smp_thermal_vector)(void) = unexpected_thermal_interrupt;
@@ -446,18 +442,20 @@ void intel_init_thermal(struct cpuinfo_x86 *c)
          */
         rdmsr(MSR_IA32_MISC_ENABLE, l, h);
 
+        h = lvtthmr_init;
         /*
          * The initial value of thermal LVT entries on all APs always reads
          * 0x10000 because APs are woken up by BSP issuing INIT-SIPI-SIPI
          * sequence to them and LVT registers are reset to 0s except for
          * the mask bits which are set to 1s when APs receive INIT IPI.
-         * Always restore the value that BIOS has programmed on AP based on
-         * BSP's info we saved since BIOS is always setting the same value
-         * for all threads/cores
+         * If BIOS takes over the thermal interrupt and sets its interrupt
+         * delivery mode to SMI (not fixed), it restores the value that the
+         * BIOS has programmed on AP based on BSP's info we saved since BIOS
+         * is always setting the same value for all threads/cores.
          */
-        apic_write(APIC_LVTTHMR, lvtthmr_init);
+        if ((h & APIC_DM_FIXED_MASK) != APIC_DM_FIXED)
+                apic_write(APIC_LVTTHMR, lvtthmr_init);
 
-        h = lvtthmr_init;
 
         if ((l & MSR_IA32_MISC_ENABLE_TM1) && (h & APIC_DM_SMI)) {
                 printk(KERN_DEBUG
diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c
index e638689279d3..3a0338b4b179 100644
--- a/arch/x86/kernel/cpu/perf_event.c
+++ b/arch/x86/kernel/cpu/perf_event.c
@@ -31,6 +31,7 @@
 #include <asm/nmi.h>
 #include <asm/compat.h>
 #include <asm/smp.h>
+#include <asm/alternative.h>
 
 #if 0
 #undef wrmsrl
@@ -363,12 +364,18 @@ again:
         return new_raw_count;
 }
 
-/* using X86_FEATURE_PERFCTR_CORE to later implement ALTERNATIVE() here */
 static inline int x86_pmu_addr_offset(int index)
 {
-        if (boot_cpu_has(X86_FEATURE_PERFCTR_CORE))
-                return index << 1;
-        return index;
+        int offset;
+
+        /* offset = X86_FEATURE_PERFCTR_CORE ? index << 1 : index */
+        alternative_io(ASM_NOP2,
+                       "shll $1, %%eax",
+                       X86_FEATURE_PERFCTR_CORE,
+                       "=a" (offset),
+                       "a"  (index));
+
+        return offset;
 }
 
 static inline unsigned int x86_pmu_config_addr(int index)
@@ -1766,17 +1773,6 @@ static struct pmu pmu = {
  * callchain support
  */
 
-static void
-backtrace_warning_symbol(void *data, char *msg, unsigned long symbol)
-{
-        /* Ignore warnings */
-}
-
-static void backtrace_warning(void *data, char *msg)
-{
-        /* Ignore warnings */
-}
-
 static int backtrace_stack(void *data, char *name)
 {
         return 0;
@@ -1790,8 +1786,6 @@ static void backtrace_address(void *data, unsigned long addr, int reliable)
 }
 
 static const struct stacktrace_ops backtrace_ops = {
-        .warning                = backtrace_warning,
-        .warning_symbol         = backtrace_warning_symbol,
         .stack                  = backtrace_stack,
         .address                = backtrace_address,
         .walk_stack             = print_context_stack_bp,
diff --git a/arch/x86/kernel/cpu/perf_event_amd.c b/arch/x86/kernel/cpu/perf_event_amd.c
index cf4e369cea67..fe29c1d2219e 100644
--- a/arch/x86/kernel/cpu/perf_event_amd.c
+++ b/arch/x86/kernel/cpu/perf_event_amd.c
@@ -96,12 +96,14 @@ static __initconst const u64 amd_hw_cache_event_ids
  */
 static const u64 amd_perfmon_event_map[] =
 {
-  [PERF_COUNT_HW_CPU_CYCLES]            = 0x0076,
-  [PERF_COUNT_HW_INSTRUCTIONS]          = 0x00c0,
-  [PERF_COUNT_HW_CACHE_REFERENCES]      = 0x0080,
-  [PERF_COUNT_HW_CACHE_MISSES]          = 0x0081,
-  [PERF_COUNT_HW_BRANCH_INSTRUCTIONS]   = 0x00c2,
-  [PERF_COUNT_HW_BRANCH_MISSES]         = 0x00c3,
+  [PERF_COUNT_HW_CPU_CYCLES]                    = 0x0076,
+  [PERF_COUNT_HW_INSTRUCTIONS]                  = 0x00c0,
+  [PERF_COUNT_HW_CACHE_REFERENCES]              = 0x0080,
+  [PERF_COUNT_HW_CACHE_MISSES]                  = 0x0081,
+  [PERF_COUNT_HW_BRANCH_INSTRUCTIONS]           = 0x00c2,
+  [PERF_COUNT_HW_BRANCH_MISSES]                 = 0x00c3,
+  [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND]       = 0x00d0, /* "Decoder empty" event */
+  [PERF_COUNT_HW_STALLED_CYCLES_BACKEND]        = 0x00d1, /* "Dispatch stalls" event */
 };
 
 static u64 amd_pmu_event_map(int hw_event)
diff --git a/arch/x86/kernel/cpu/perf_event_intel.c b/arch/x86/kernel/cpu/perf_event_intel.c
index 447a28de6f09..41178c826c48 100644
--- a/arch/x86/kernel/cpu/perf_event_intel.c
+++ b/arch/x86/kernel/cpu/perf_event_intel.c
@@ -36,7 +36,7 @@ static u64 intel_perfmon_event_map[PERF_COUNT_HW_MAX] __read_mostly =
   [PERF_COUNT_HW_BUS_CYCLES]            = 0x013c,
 };
 
-static struct event_constraint intel_core_event_constraints[] =
+static struct event_constraint intel_core_event_constraints[] __read_mostly =
 {
         INTEL_EVENT_CONSTRAINT(0x11, 0x2), /* FP_ASSIST */
         INTEL_EVENT_CONSTRAINT(0x12, 0x2), /* MUL */
@@ -47,7 +47,7 @@ static struct event_constraint intel_core_event_constraints[] =
         EVENT_CONSTRAINT_END
 };
 
-static struct event_constraint intel_core2_event_constraints[] =
+static struct event_constraint intel_core2_event_constraints[] __read_mostly =
 {
         FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
         FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
@@ -70,7 +70,7 @@ static struct event_constraint intel_core2_event_constraints[] =
         EVENT_CONSTRAINT_END
 };
 
-static struct event_constraint intel_nehalem_event_constraints[] =
+static struct event_constraint intel_nehalem_event_constraints[] __read_mostly =
 {
         FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
         FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
@@ -86,19 +86,19 @@ static struct event_constraint intel_nehalem_event_constraints[] =
         EVENT_CONSTRAINT_END
 };
 
-static struct extra_reg intel_nehalem_extra_regs[] =
+static struct extra_reg intel_nehalem_extra_regs[] __read_mostly =
 {
         INTEL_EVENT_EXTRA_REG(0xb7, MSR_OFFCORE_RSP_0, 0xffff),
         EVENT_EXTRA_END
 };
 
-static struct event_constraint intel_nehalem_percore_constraints[] =
+static struct event_constraint intel_nehalem_percore_constraints[] __read_mostly =
 {
         INTEL_EVENT_CONSTRAINT(0xb7, 0),
         EVENT_CONSTRAINT_END
 };
 
-static struct event_constraint intel_westmere_event_constraints[] =
+static struct event_constraint intel_westmere_event_constraints[] __read_mostly =
 {
         FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
         FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
@@ -110,7 +110,7 @@ static struct event_constraint intel_westmere_event_constraints[] =
         EVENT_CONSTRAINT_END
 };
 
-static struct event_constraint intel_snb_event_constraints[] =
+static struct event_constraint intel_snb_event_constraints[] __read_mostly =
 {
         FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
         FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
@@ -123,21 +123,21 @@ static struct event_constraint intel_snb_event_constraints[] =
         EVENT_CONSTRAINT_END
 };
 
-static struct extra_reg intel_westmere_extra_regs[] =
+static struct extra_reg intel_westmere_extra_regs[] __read_mostly =
 {
         INTEL_EVENT_EXTRA_REG(0xb7, MSR_OFFCORE_RSP_0, 0xffff),
         INTEL_EVENT_EXTRA_REG(0xbb, MSR_OFFCORE_RSP_1, 0xffff),
         EVENT_EXTRA_END
 };
 
-static struct event_constraint intel_westmere_percore_constraints[] =
+static struct event_constraint intel_westmere_percore_constraints[] __read_mostly =
 {
         INTEL_EVENT_CONSTRAINT(0xb7, 0),
         INTEL_EVENT_CONSTRAINT(0xbb, 0),
         EVENT_CONSTRAINT_END
 };
 
-static struct event_constraint intel_gen_event_constraints[] =
+static struct event_constraint intel_gen_event_constraints[] __read_mostly =
 {
         FIXED_EVENT_CONSTRAINT(0x00c0, 0), /* INST_RETIRED.ANY */
         FIXED_EVENT_CONSTRAINT(0x003c, 1), /* CPU_CLK_UNHALTED.CORE */
@@ -1440,6 +1440,11 @@ static __init int intel_pmu_init(void)
                 x86_pmu.enable_all = intel_pmu_nhm_enable_all;
                 x86_pmu.extra_regs = intel_nehalem_extra_regs;
 
+                /* UOPS_ISSUED.STALLED_CYCLES */
+                intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x180010e;
+                /* UOPS_EXECUTED.CORE_ACTIVE_CYCLES,c=1,i=1 */
+                intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x1803fb1;
+
                 if (ebx & 0x40) {
                         /*
                          * Erratum AAJ80 detected, we work it around by using
@@ -1480,6 +1485,12 @@ static __init int intel_pmu_init(void)
                 x86_pmu.enable_all = intel_pmu_nhm_enable_all;
                 x86_pmu.pebs_constraints = intel_westmere_pebs_event_constraints;
                 x86_pmu.extra_regs = intel_westmere_extra_regs;
+
+                /* UOPS_ISSUED.STALLED_CYCLES */
+                intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x180010e;
+                /* UOPS_EXECUTED.CORE_ACTIVE_CYCLES,c=1,i=1 */
+                intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x1803fb1;
+
                 pr_cont("Westmere events, ");
                 break;
 
@@ -1491,6 +1502,12 @@ static __init int intel_pmu_init(void)
 
                 x86_pmu.event_constraints = intel_snb_event_constraints;
                 x86_pmu.pebs_constraints = intel_snb_pebs_events;
+
+                /* UOPS_ISSUED.ANY,c=1,i=1 to count stall cycles */
+                intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = 0x180010e;
+                /* UOPS_DISPATCHED.THREAD,c=1,i=1 to count stall cycles*/
+                intel_perfmon_event_map[PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = 0x18001b1;
+
                 pr_cont("SandyBridge events, ");
                 break;
 
diff --git a/arch/x86/kernel/cpu/perf_event_p4.c b/arch/x86/kernel/cpu/perf_event_p4.c
index e93fcd55fae1..ead584fb6a7d 100644
--- a/arch/x86/kernel/cpu/perf_event_p4.c
+++ b/arch/x86/kernel/cpu/perf_event_p4.c
@@ -468,7 +468,7 @@ static struct p4_event_bind p4_event_bind_map[] = {
                 .opcode         = P4_OPCODE(P4_EVENT_MISPRED_BRANCH_RETIRED),
                 .escr_msr       = { MSR_P4_CRU_ESCR0, MSR_P4_CRU_ESCR1 },
                 .escr_emask     =
-                P4_ESCR_EMASK_BIT(P4_EVENT_MISPRED_BRANCH_RETIRED, NBOGUS),
+                        P4_ESCR_EMASK_BIT(P4_EVENT_MISPRED_BRANCH_RETIRED, NBOGUS),
                 .cntr           = { {12, 13, 16}, {14, 15, 17} },
         },
         [P4_EVENT_X87_ASSIST] = {
@@ -912,8 +912,7 @@ static int p4_pmu_handle_irq(struct pt_regs *regs)
         int idx, handled = 0;
         u64 val;
 
-        data.addr = 0;
-        data.raw = NULL;
+        perf_sample_data_init(&data, 0);
 
         cpuc = &__get_cpu_var(cpu_hw_events);
 
@@ -1197,7 +1196,7 @@ static __init int p4_pmu_init(void)
 {
         unsigned int low, high;
 
-        /* If we get stripped -- indexig fails */
+        /* If we get stripped -- indexing fails */
         BUILD_BUG_ON(ARCH_P4_MAX_CCCR > X86_PMC_MAX_GENERIC);
 
         rdmsr(MSR_IA32_MISC_ENABLE, low, high);
diff --git a/arch/x86/kernel/dumpstack.c b/arch/x86/kernel/dumpstack.c
index e2a3f0606da4..1aae78f775fc 100644
--- a/arch/x86/kernel/dumpstack.c
+++ b/arch/x86/kernel/dumpstack.c
@@ -135,20 +135,6 @@ print_context_stack_bp(struct thread_info *tinfo,
 }
 EXPORT_SYMBOL_GPL(print_context_stack_bp);
 
-
-static void
-print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
-{
-        printk(data);
-        print_symbol(msg, symbol);
-        printk("\n");
-}
-
-static void print_trace_warning(void *data, char *msg)
-{
-        printk("%s%s\n", (char *)data, msg);
-}
-
 static int print_trace_stack(void *data, char *name)
 {
         printk("%s <%s> ", (char *)data, name);
@@ -166,8 +152,6 @@ static void print_trace_address(void *data, unsigned long addr, int reliable)
 }
 
 static const struct stacktrace_ops print_trace_ops = {
-        .warning                = print_trace_warning,
-        .warning_symbol         = print_trace_warning_symbol,
         .stack                  = print_trace_stack,
         .address                = print_trace_address,
         .walk_stack             = print_context_stack,
@@ -279,7 +263,6 @@ int __kprobes __die(const char *str, struct pt_regs *regs, long err)
         printk("DEBUG_PAGEALLOC");
 #endif
         printk("\n");
-        sysfs_printk_last_file();
         if (notify_die(DIE_OOPS, str, regs, err,
                         current->thread.trap_no, SIGSEGV) == NOTIFY_STOP)
                 return 1;
diff --git a/arch/x86/kernel/ftrace.c b/arch/x86/kernel/ftrace.c
index a93742a57468..0ba15a6cc57e 100644
--- a/arch/x86/kernel/ftrace.c
+++ b/arch/x86/kernel/ftrace.c
@@ -260,9 +260,9 @@ do_ftrace_mod_code(unsigned long ip, void *new_code)
         return mod_code_status;
 }
 
-static unsigned char *ftrace_nop_replace(void)
+static const unsigned char *ftrace_nop_replace(void)
 {
-        return ideal_nop5;
+        return ideal_nops[NOP_ATOMIC5];
 }
 
 static int
diff --git a/arch/x86/kernel/head32.c b/arch/x86/kernel/head32.c
index d6d6bb361931..3bb08509a7a1 100644
--- a/arch/x86/kernel/head32.c
+++ b/arch/x86/kernel/head32.c
@@ -23,7 +23,6 @@
 static void __init i386_default_early_setup(void)
 {
         /* Initialize 32bit specific setup functions */
-        x86_init.resources.probe_roms = probe_roms;
         x86_init.resources.reserve_resources = i386_reserve_resources;
         x86_init.mpparse.setup_ioapic_ids = setup_ioapic_ids_from_mpc;
 
diff --git a/arch/x86/kernel/hpet.c b/arch/x86/kernel/hpet.c
index bfe8f729e086..6781765b3a0d 100644
--- a/arch/x86/kernel/hpet.c
+++ b/arch/x86/kernel/hpet.c
@@ -217,7 +217,7 @@ static void hpet_reserve_platform_timers(unsigned int id) { }
 /*
  * Common hpet info
  */
-static unsigned long hpet_period;
+static unsigned long hpet_freq;
 
 static void hpet_legacy_set_mode(enum clock_event_mode mode,
                           struct clock_event_device *evt);
@@ -232,7 +232,6 @@ static struct clock_event_device hpet_clockevent = {
         .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
         .set_mode       = hpet_legacy_set_mode,
         .set_next_event = hpet_legacy_next_event,
-        .shift          = 32,
         .irq            = 0,
         .rating         = 50,
 };
@@ -290,28 +289,12 @@ static void hpet_legacy_clockevent_register(void)
         hpet_enable_legacy_int();
 
         /*
-         * The mult factor is defined as (include/linux/clockchips.h)
-         *  mult/2^shift = cyc/ns (in contrast to ns/cyc in clocksource.h)
-         * hpet_period is in units of femtoseconds (per cycle), so
-         *  mult/2^shift = cyc/ns = 10^6/hpet_period
-         *  mult = (10^6 * 2^shift)/hpet_period
-         *  mult = (FSEC_PER_NSEC << hpet_clockevent.shift)/hpet_period
-         */
-        hpet_clockevent.mult = div_sc((unsigned long) FSEC_PER_NSEC,
-                                      hpet_period, hpet_clockevent.shift);
-        /* Calculate the min / max delta */
-        hpet_clockevent.max_delta_ns = clockevent_delta2ns(0x7FFFFFFF,
-                                                           &hpet_clockevent);
-        /* Setup minimum reprogramming delta. */
-        hpet_clockevent.min_delta_ns = clockevent_delta2ns(HPET_MIN_PROG_DELTA,
-                                                           &hpet_clockevent);
-
-        /*
          * 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_register_device(&hpet_clockevent);
+        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");
 }
@@ -549,7 +532,6 @@ static int hpet_setup_irq(struct hpet_dev *dev)
 static void init_one_hpet_msi_clockevent(struct hpet_dev *hdev, int cpu)
 {
         struct clock_event_device *evt = &hdev->evt;
-        uint64_t hpet_freq;
 
         WARN_ON(cpu != smp_processor_id());
         if (!(hdev->flags & HPET_DEV_VALID))
@@ -571,24 +553,10 @@ static void init_one_hpet_msi_clockevent(struct hpet_dev *hdev, int cpu)
 
         evt->set_mode = hpet_msi_set_mode;
         evt->set_next_event = hpet_msi_next_event;
-        evt->shift = 32;
-
-        /*
-         * The period is a femto seconds value. We need to calculate the
-         * scaled math multiplication factor for nanosecond to hpet tick
-         * conversion.
-         */
-        hpet_freq = FSEC_PER_SEC;
-        do_div(hpet_freq, hpet_period);
-        evt->mult = div_sc((unsigned long) hpet_freq,
-                                      NSEC_PER_SEC, evt->shift);
-        /* Calculate the max delta */
-        evt->max_delta_ns = clockevent_delta2ns(0x7FFFFFFF, evt);
-        /* 5 usec minimum reprogramming delta. */
-        evt->min_delta_ns = 5000;
-
         evt->cpumask = cpumask_of(hdev->cpu);
-        clockevents_register_device(evt);
+
+        clockevents_config_and_register(evt, hpet_freq, HPET_MIN_PROG_DELTA,
+                                        0x7FFFFFFF);
 }
 
 #ifdef CONFIG_HPET
@@ -792,7 +760,6 @@ static struct clocksource clocksource_hpet = {
 static int hpet_clocksource_register(void)
 {
         u64 start, now;
-        u64 hpet_freq;
         cycle_t t1;
 
         /* Start the counter */
@@ -819,24 +786,7 @@ static int hpet_clocksource_register(void)
                 return -ENODEV;
         }
 
-        /*
-         * The definition of mult is (include/linux/clocksource.h)
-         * mult/2^shift = ns/cyc and hpet_period is in units of fsec/cyc
-         * so we first need to convert hpet_period to ns/cyc units:
-         *  mult/2^shift = ns/cyc = hpet_period/10^6
-         *  mult = (hpet_period * 2^shift)/10^6
-         *  mult = (hpet_period << shift)/FSEC_PER_NSEC
-         */
-
-        /* Need to convert hpet_period (fsec/cyc) to cyc/sec:
-         *
-         * cyc/sec = FSEC_PER_SEC/hpet_period(fsec/cyc)
-         * cyc/sec = (FSEC_PER_NSEC * NSEC_PER_SEC)/hpet_period
-         */
-        hpet_freq = FSEC_PER_SEC;
-        do_div(hpet_freq, hpet_period);
         clocksource_register_hz(&clocksource_hpet, (u32)hpet_freq);
-
         return 0;
 }
 
@@ -845,7 +795,9 @@ static int hpet_clocksource_register(void)
  */
 int __init hpet_enable(void)
 {
+        unsigned long hpet_period;
         unsigned int id;
+        u64 freq;
         int i;
 
         if (!is_hpet_capable())
@@ -884,6 +836,14 @@ int __init hpet_enable(void)
                 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
          */
diff --git a/arch/x86/kernel/i8253.c b/arch/x86/kernel/i8253.c
index 2dfd31597443..fb66dc9e36cb 100644
--- a/arch/x86/kernel/i8253.c
+++ b/arch/x86/kernel/i8253.c
@@ -93,7 +93,6 @@ static struct clock_event_device pit_ce = {
         .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
         .set_mode       = init_pit_timer,
         .set_next_event = pit_next_event,
-        .shift          = 32,
         .irq            = 0,
 };
 
@@ -108,90 +107,12 @@ void __init setup_pit_timer(void)
          * IO_APIC has been initialized.
          */
         pit_ce.cpumask = cpumask_of(smp_processor_id());
-        pit_ce.mult = div_sc(CLOCK_TICK_RATE, NSEC_PER_SEC, pit_ce.shift);
-        pit_ce.max_delta_ns = clockevent_delta2ns(0x7FFF, &pit_ce);
-        pit_ce.min_delta_ns = clockevent_delta2ns(0xF, &pit_ce);
 
-        clockevents_register_device(&pit_ce);
+        clockevents_config_and_register(&pit_ce, CLOCK_TICK_RATE, 0xF, 0x7FFF);
         global_clock_event = &pit_ce;
 }
 
 #ifndef CONFIG_X86_64
-/*
- * Since the PIT overflows every tick, its not very useful
- * to just read by itself. So use jiffies to emulate a free
- * running counter:
- */
-static cycle_t pit_read(struct clocksource *cs)
-{
-        static int old_count;
-        static u32 old_jifs;
-        unsigned long flags;
-        int count;
-        u32 jifs;
-
-        raw_spin_lock_irqsave(&i8253_lock, flags);
-        /*
-         * Although our caller may have the read side of xtime_lock,
-         * this is now a seqlock, and we are cheating in this routine
-         * by having side effects on state that we cannot undo if
-         * there is a collision on the seqlock and our caller has to
-         * retry.  (Namely, old_jifs and old_count.)  So we must treat
-         * jiffies as volatile despite the lock.  We read jiffies
-         * before latching the timer count to guarantee that although
-         * the jiffies value might be older than the count (that is,
-         * the counter may underflow between the last point where
-         * jiffies was incremented and the point where we latch the
-         * count), it cannot be newer.
-         */
-        jifs = jiffies;
-        outb_pit(0x00, PIT_MODE);       /* latch the count ASAP */
-        count = inb_pit(PIT_CH0);       /* read the latched count */
-        count |= inb_pit(PIT_CH0) << 8;
-
-        /* VIA686a test code... reset the latch if count > max + 1 */
-        if (count > LATCH) {
-                outb_pit(0x34, PIT_MODE);
-                outb_pit(LATCH & 0xff, PIT_CH0);
-                outb_pit(LATCH >> 8, PIT_CH0);
-                count = LATCH - 1;
-        }
-
-        /*
-         * It's possible for count to appear to go the wrong way for a
-         * couple of reasons:
-         *
-         *  1. The timer counter underflows, but we haven't handled the
-         *     resulting interrupt and incremented jiffies yet.
-         *  2. Hardware problem with the timer, not giving us continuous time,
-         *     the counter does small "jumps" upwards on some Pentium systems,
-         *     (see c't 95/10 page 335 for Neptun bug.)
-         *
-         * Previous attempts to handle these cases intelligently were
-         * buggy, so we just do the simple thing now.
-         */
-        if (count > old_count && jifs == old_jifs)
-                count = old_count;
-
-        old_count = count;
-        old_jifs = jifs;
-
-        raw_spin_unlock_irqrestore(&i8253_lock, flags);
-
-        count = (LATCH - 1) - count;
-
-        return (cycle_t)(jifs * LATCH) + count;
-}
-
-static struct clocksource pit_cs = {
-        .name           = "pit",
-        .rating         = 110,
-        .read           = pit_read,
-        .mask           = CLOCKSOURCE_MASK(32),
-        .mult           = 0,
-        .shift          = 20,
-};
-
 static int __init init_pit_clocksource(void)
 {
          /*
@@ -205,10 +126,7 @@ static int __init init_pit_clocksource(void)
             pit_ce.mode != CLOCK_EVT_MODE_PERIODIC)
                 return 0;
 
-        pit_cs.mult = clocksource_hz2mult(CLOCK_TICK_RATE, pit_cs.shift);
-
-        return clocksource_register(&pit_cs);
+        return clocksource_i8253_init();
 }
 arch_initcall(init_pit_clocksource);
-
 #endif /* !CONFIG_X86_64 */
diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c
index 1cb0b9fc78dc..6c0802eb2f7f 100644
--- a/arch/x86/kernel/irq.c
+++ b/arch/x86/kernel/irq.c
@@ -249,7 +249,7 @@ void fixup_irqs(void)
 
                 data = irq_desc_get_irq_data(desc);
                 affinity = data->affinity;
-                if (!irq_has_action(irq) ||
+                if (!irq_has_action(irq) || irqd_is_per_cpu(data) ||
                     cpumask_subset(affinity, cpu_online_mask)) {
                         raw_spin_unlock(&desc->lock);
                         continue;
@@ -276,7 +276,8 @@ void fixup_irqs(void)
                 else if (!(warned++))
                         set_affinity = 0;
 
-                if (!irqd_can_move_in_process_context(data) && chip->irq_unmask)
+                if (!irqd_can_move_in_process_context(data) &&
+                    !irqd_irq_disabled(data) && chip->irq_unmask)
                         chip->irq_unmask(data);
 
                 raw_spin_unlock(&desc->lock);
diff --git a/arch/x86/kernel/jump_label.c b/arch/x86/kernel/jump_label.c
index 961b6b30ba90..3fee346ef545 100644
--- a/arch/x86/kernel/jump_label.c
+++ b/arch/x86/kernel/jump_label.c
@@ -34,7 +34,7 @@ void arch_jump_label_transform(struct jump_entry *entry,
                 code.offset = entry->target -
                                 (entry->code + JUMP_LABEL_NOP_SIZE);
         } else
-                memcpy(&code, ideal_nop5, JUMP_LABEL_NOP_SIZE);
+                memcpy(&code, ideal_nops[NOP_ATOMIC5], JUMP_LABEL_NOP_SIZE);
         get_online_cpus();
         mutex_lock(&text_mutex);
         text_poke_smp((void *)entry->code, &code, JUMP_LABEL_NOP_SIZE);
@@ -44,7 +44,8 @@ void arch_jump_label_transform(struct jump_entry *entry,
 
 void arch_jump_label_text_poke_early(jump_label_t addr)
 {
-        text_poke_early((void *)addr, ideal_nop5, JUMP_LABEL_NOP_SIZE);
+        text_poke_early((void *)addr, ideal_nops[NOP_ATOMIC5],
+                        JUMP_LABEL_NOP_SIZE);
 }
 
 #endif
diff --git a/arch/x86/kernel/kprobes.c b/arch/x86/kernel/kprobes.c
index c969fd9d1566..f1a6244d7d93 100644
--- a/arch/x86/kernel/kprobes.c
+++ b/arch/x86/kernel/kprobes.c
@@ -1183,12 +1183,13 @@ static void __kprobes optimized_callback(struct optimized_kprobe *op,
                                          struct pt_regs *regs)
 {
         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
+        unsigned long flags;
 
         /* This is possible if op is under delayed unoptimizing */
         if (kprobe_disabled(&op->kp))
                 return;
 
-        preempt_disable();
+        local_irq_save(flags);
         if (kprobe_running()) {
                 kprobes_inc_nmissed_count(&op->kp);
         } else {
@@ -1207,7 +1208,7 @@ static void __kprobes optimized_callback(struct optimized_kprobe *op,
                 opt_pre_handler(&op->kp, regs);
                 __this_cpu_write(current_kprobe, NULL);
         }
-        preempt_enable_no_resched();
+        local_irq_restore(flags);
 }
 
 static int __kprobes copy_optimized_instructions(u8 *dest, u8 *src)
diff --git a/arch/x86/kernel/kvmclock.c b/arch/x86/kernel/kvmclock.c
index f98d3eafe07a..6389a6bca11b 100644
--- a/arch/x86/kernel/kvmclock.c
+++ b/arch/x86/kernel/kvmclock.c
@@ -26,8 +26,6 @@
 #include <asm/x86_init.h>
 #include <asm/reboot.h>
 
-#define KVM_SCALE 22
-
 static int kvmclock = 1;
 static int msr_kvm_system_time = MSR_KVM_SYSTEM_TIME;
 static int msr_kvm_wall_clock = MSR_KVM_WALL_CLOCK;
@@ -120,8 +118,6 @@ static struct clocksource kvm_clock = {
         .read = kvm_clock_get_cycles,
         .rating = 400,
         .mask = CLOCKSOURCE_MASK(64),
-        .mult = 1 << KVM_SCALE,
-        .shift = KVM_SCALE,
         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
@@ -203,7 +199,7 @@ void __init kvmclock_init(void)
         machine_ops.crash_shutdown  = kvm_crash_shutdown;
 #endif
         kvm_get_preset_lpj();
-        clocksource_register(&kvm_clock);
+        clocksource_register_hz(&kvm_clock, NSEC_PER_SEC);
         pv_info.paravirt_enabled = 1;
         pv_info.name = "KVM";
 
diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c
index ab23f1ad4bf1..52f256f2cc81 100644
--- a/arch/x86/kernel/module.c
+++ b/arch/x86/kernel/module.c
@@ -24,6 +24,7 @@
 #include <linux/bug.h>
 #include <linux/mm.h>
 #include <linux/gfp.h>
+#include <linux/jump_label.h>
 
 #include <asm/system.h>
 #include <asm/page.h>
diff --git a/arch/x86/kernel/mpparse.c b/arch/x86/kernel/mpparse.c
index 5a532ce646bf..6f9bfffb2720 100644
--- a/arch/x86/kernel/mpparse.c
+++ b/arch/x86/kernel/mpparse.c
@@ -715,17 +715,15 @@ static void __init check_irq_src(struct mpc_intsrc *m, int *nr_m_spare)
         }
 }
 
-static int
+static int __init
 check_slot(unsigned long mpc_new_phys, unsigned long mpc_new_length, int count)
 {
-        int ret = 0;
-
         if (!mpc_new_phys || count <= mpc_new_length) {
                 WARN(1, "update_mptable: No spare slots (length: %x)\n", count);
                 return -1;
         }
 
-        return ret;
+        return 0;
 }
 #else /* CONFIG_X86_IO_APIC */
 static
diff --git a/arch/x86/kernel/pci-iommu_table.c b/arch/x86/kernel/pci-iommu_table.c
index 55d745ec1181..35ccf75696eb 100644
--- a/arch/x86/kernel/pci-iommu_table.c
+++ b/arch/x86/kernel/pci-iommu_table.c
@@ -50,20 +50,14 @@ void __init check_iommu_entries(struct iommu_table_entry *start,
                                 struct iommu_table_entry *finish)
 {
         struct iommu_table_entry *p, *q, *x;
-        char sym_p[KSYM_SYMBOL_LEN];
-        char sym_q[KSYM_SYMBOL_LEN];
 
         /* Simple cyclic dependency checker. */
         for (p = start; p < finish; p++) {
                 q = find_dependents_of(start, finish, p);
                 x = find_dependents_of(start, finish, q);
                 if (p == x) {
-                        sprint_symbol(sym_p, (unsigned long)p->detect);
-                        sprint_symbol(sym_q, (unsigned long)q->detect);
-
-                        printk(KERN_ERR "CYCLIC DEPENDENCY FOUND! %s depends" \
-                                        " on %s and vice-versa. BREAKING IT.\n",
-                                        sym_p, sym_q);
+                        printk(KERN_ERR "CYCLIC DEPENDENCY FOUND! %pS depends on %pS and vice-versa. BREAKING IT.\n",
+                               p->detect, q->detect);
                         /* Heavy handed way..*/
                         x->depend = 0;
                 }
@@ -72,12 +66,8 @@ void __init check_iommu_entries(struct iommu_table_entry *start,
         for (p = start; p < finish; p++) {
                 q = find_dependents_of(p, finish, p);
                 if (q && q > p) {
-                        sprint_symbol(sym_p, (unsigned long)p->detect);
-                        sprint_symbol(sym_q, (unsigned long)q->detect);
-
-                        printk(KERN_ERR "EXECUTION ORDER INVALID! %s "\
-                                        "should be called before %s!\n",
-                                        sym_p, sym_q);
+                        printk(KERN_ERR "EXECUTION ORDER INVALID! %pS should be called before %pS!\n",
+                               p->detect, q->detect);
                 }
         }
 }
diff --git a/arch/x86/kernel/probe_roms_32.c b/arch/x86/kernel/probe_roms.c
index 071e7fea42e5..ba0a4cce53be 100644
--- a/arch/x86/kernel/probe_roms_32.c
+++ b/arch/x86/kernel/probe_roms.c
@@ -73,6 +73,107 @@ static struct resource video_rom_resource = {
         .flags  = IORESOURCE_BUSY | IORESOURCE_READONLY | IORESOURCE_MEM
 };
 
+/* does this oprom support the given pci device, or any of the devices
+ * that the driver supports?
+ */
+static bool match_id(struct pci_dev *pdev, unsigned short vendor, unsigned short device)
+{
+        struct pci_driver *drv = pdev->driver;
+        const struct pci_device_id *id;
+
+        if (pdev->vendor == vendor && pdev->device == device)
+                return true;
+
+        for (id = drv ? drv->id_table : NULL; id && id->vendor; id++)
+                if (id->vendor == vendor && id->device == device)
+                        break;
+
+        return id && id->vendor;
+}
+
+static bool probe_list(struct pci_dev *pdev, unsigned short vendor,
+                       const unsigned char *rom_list)
+{
+        unsigned short device;
+
+        do {
+                if (probe_kernel_address(rom_list, device) != 0)
+                        device = 0;
+
+                if (device && match_id(pdev, vendor, device))
+                        break;
+
+                rom_list += 2;
+        } while (device);
+
+        return !!device;
+}
+
+static struct resource *find_oprom(struct pci_dev *pdev)
+{
+        struct resource *oprom = NULL;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(adapter_rom_resources); i++) {
+                struct resource *res = &adapter_rom_resources[i];
+                unsigned short offset, vendor, device, list, rev;
+                const unsigned char *rom;
+
+                if (res->end == 0)
+                        break;
+
+                rom = isa_bus_to_virt(res->start);
+                if (probe_kernel_address(rom + 0x18, offset) != 0)
+                        continue;
+
+                if (probe_kernel_address(rom + offset + 0x4, vendor) != 0)
+                        continue;
+
+                if (probe_kernel_address(rom + offset + 0x6, device) != 0)
+                        continue;
+
+                if (match_id(pdev, vendor, device)) {
+                        oprom = res;
+                        break;
+                }
+
+                if (probe_kernel_address(rom + offset + 0x8, list) == 0 &&
+                    probe_kernel_address(rom + offset + 0xc, rev) == 0 &&
+                    rev >= 3 && list &&
+                    probe_list(pdev, vendor, rom + offset + list)) {
+                        oprom = res;
+                        break;
+                }
+        }
+
+        return oprom;
+}
+
+void *pci_map_biosrom(struct pci_dev *pdev)
+{
+        struct resource *oprom = find_oprom(pdev);
+
+        if (!oprom)
+                return NULL;
+
+        return ioremap(oprom->start, resource_size(oprom));
+}
+EXPORT_SYMBOL(pci_map_biosrom);
+
+void pci_unmap_biosrom(void __iomem *image)
+{
+        iounmap(image);
+}
+EXPORT_SYMBOL(pci_unmap_biosrom);
+
+size_t pci_biosrom_size(struct pci_dev *pdev)
+{
+        struct resource *oprom = find_oprom(pdev);
+
+        return oprom ? resource_size(oprom) : 0;
+}
+EXPORT_SYMBOL(pci_biosrom_size);
+
 #define ROMSIGNATURE 0xaa55
 
 static int __init romsignature(const unsigned char *rom)
diff --git a/arch/x86/kernel/process.c b/arch/x86/kernel/process.c
index d46cbe46b7ab..88a90a977f8e 100644
--- a/arch/x86/kernel/process.c
+++ b/arch/x86/kernel/process.c
@@ -449,7 +449,7 @@ EXPORT_SYMBOL_GPL(cpu_idle_wait);
 void mwait_idle_with_hints(unsigned long ax, unsigned long cx)
 {
         if (!need_resched()) {
-                if (cpu_has(__this_cpu_ptr(&cpu_info), X86_FEATURE_CLFLUSH_MONITOR))
+                if (this_cpu_has(X86_FEATURE_CLFLUSH_MONITOR))
                         clflush((void *)&current_thread_info()->flags);
 
                 __monitor((void *)&current_thread_info()->flags, 0, 0);
@@ -465,7 +465,7 @@ static void mwait_idle(void)
         if (!need_resched()) {
                 trace_power_start(POWER_CSTATE, 1, smp_processor_id());
                 trace_cpu_idle(1, smp_processor_id());
-                if (cpu_has(__this_cpu_ptr(&cpu_info), X86_FEATURE_CLFLUSH_MONITOR))
+                if (this_cpu_has(X86_FEATURE_CLFLUSH_MONITOR))
                         clflush((void *)&current_thread_info()->flags);
 
                 __monitor((void *)&current_thread_info()->flags, 0, 0);
diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index 08c44b08bf5b..0c016f727695 100644
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -36,7 +36,7 @@ EXPORT_SYMBOL(pm_power_off);
 
 static const struct desc_ptr no_idt = {};
 static int reboot_mode;
-enum reboot_type reboot_type = BOOT_KBD;
+enum reboot_type reboot_type = BOOT_ACPI;
 int reboot_force;
 
 #if defined(CONFIG_X86_32) && defined(CONFIG_SMP)
@@ -478,9 +478,24 @@ void __attribute__((weak)) mach_reboot_fixups(void)
 {
 }
 
+/*
+ * Windows compatible x86 hardware expects the following on reboot:
+ *
+ * 1) If the FADT has the ACPI reboot register flag set, try it
+ * 2) If still alive, write to the keyboard controller
+ * 3) If still alive, write to the ACPI reboot register again
+ * 4) If still alive, write to the keyboard controller again
+ *
+ * If the machine is still alive at this stage, it gives up. We default to
+ * following the same pattern, except that if we're still alive after (4) we'll
+ * try to force a triple fault and then cycle between hitting the keyboard
+ * controller and doing that
+ */
 static void native_machine_emergency_restart(void)
 {
         int i;
+        int attempt = 0;
+        int orig_reboot_type = reboot_type;
 
         if (reboot_emergency)
                 emergency_vmx_disable_all();
@@ -502,6 +517,13 @@ static void native_machine_emergency_restart(void)
                                 outb(0xfe, 0x64); /* pulse reset low */
                                 udelay(50);
                         }
+                        if (attempt == 0 && orig_reboot_type == BOOT_ACPI) {
+                                attempt = 1;
+                                reboot_type = BOOT_ACPI;
+                        } else {
+                                reboot_type = BOOT_TRIPLE;
+                        }
+                        break;
 
                 case BOOT_TRIPLE:
                         load_idt(&no_idt);
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 4be9b398470e..c3050af9306d 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -691,8 +691,6 @@ early_param("reservelow", parse_reservelow);
 
 void __init setup_arch(char **cmdline_p)
 {
-        unsigned long flags;
-
 #ifdef CONFIG_X86_32
         memcpy(&boot_cpu_data, &new_cpu_data, sizeof(new_cpu_data));
         visws_early_detect();
@@ -1041,9 +1039,7 @@ void __init setup_arch(char **cmdline_p)
 
         mcheck_init();
 
-        local_irq_save(flags);
-        arch_init_ideal_nop5();
-        local_irq_restore(flags);
+        arch_init_ideal_nops();
 }
 
 #ifdef CONFIG_X86_32
diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c
index 4fd173cd8e57..40a24932a8a1 100644
--- a/arch/x86/kernel/signal.c
+++ b/arch/x86/kernel/signal.c
@@ -601,10 +601,7 @@ long sys_rt_sigreturn(struct pt_regs *regs)
                 goto badframe;
 
         sigdelsetmask(&set, ~_BLOCKABLE);
-        spin_lock_irq(&current->sighand->siglock);
-        current->blocked = set;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
+        set_current_blocked(&set);
 
         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
                 goto badframe;
@@ -682,6 +679,7 @@ static int
 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
               sigset_t *oldset, struct pt_regs *regs)
 {
+        sigset_t blocked;
         int ret;
 
         /* Are we from a system call? */
@@ -741,12 +739,10 @@ handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
          */
         regs->flags &= ~X86_EFLAGS_TF;
 
-        spin_lock_irq(&current->sighand->siglock);
-        sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
+        sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
         if (!(ka->sa.sa_flags & SA_NODEFER))
-                sigaddset(&current->blocked, sig);
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
+                sigaddset(&blocked, sig);
+        set_current_blocked(&blocked);
 
         tracehook_signal_handler(sig, info, ka, regs,
                                  test_thread_flag(TIF_SINGLESTEP));
diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
index 513deac7228d..013e7eba83bb 100644
--- a/arch/x86/kernel/smp.c
+++ b/arch/x86/kernel/smp.c
@@ -194,14 +194,13 @@ static void native_stop_other_cpus(int wait)
 }
 
 /*
- * Reschedule call back. Nothing to do,
- * all the work is done automatically when
- * we return from the interrupt.
+ * Reschedule call back.
  */
 void smp_reschedule_interrupt(struct pt_regs *regs)
 {
         ack_APIC_irq();
         inc_irq_stat(irq_resched_count);
+        scheduler_ipi();
         /*
          * KVM uses this interrupt to force a cpu out of guest mode
          */
diff --git a/arch/x86/kernel/smpboot.c b/arch/x86/kernel/smpboot.c
index c2871d3c71b6..a3c430bdfb60 100644
--- a/arch/x86/kernel/smpboot.c
+++ b/arch/x86/kernel/smpboot.c
@@ -1332,9 +1332,9 @@ static inline void mwait_play_dead(void)
         void *mwait_ptr;
         struct cpuinfo_x86 *c = __this_cpu_ptr(&cpu_info);
 
-        if (!(cpu_has(c, X86_FEATURE_MWAIT) && mwait_usable(c)))
+        if (!this_cpu_has(X86_FEATURE_MWAIT) && mwait_usable(c))
                 return;
-        if (!cpu_has(__this_cpu_ptr(&cpu_info), X86_FEATURE_CLFLSH))
+        if (!this_cpu_has(X86_FEATURE_CLFLSH))
                 return;
         if (__this_cpu_read(cpu_info.cpuid_level) < CPUID_MWAIT_LEAF)
                 return;
diff --git a/arch/x86/kernel/stacktrace.c b/arch/x86/kernel/stacktrace.c
index 6515733a289d..55d9bc03f696 100644
--- a/arch/x86/kernel/stacktrace.c
+++ b/arch/x86/kernel/stacktrace.c
@@ -9,15 +9,6 @@
 #include <linux/uaccess.h>
 #include <asm/stacktrace.h>
 
-static void save_stack_warning(void *data, char *msg)
-{
-}
-
-static void
-save_stack_warning_symbol(void *data, char *msg, unsigned long symbol)
-{
-}
-
 static int save_stack_stack(void *data, char *name)
 {
         return 0;
@@ -53,16 +44,12 @@ save_stack_address_nosched(void *data, unsigned long addr, int reliable)
 }
 
 static const struct stacktrace_ops save_stack_ops = {
-        .warning        = save_stack_warning,
-        .warning_symbol = save_stack_warning_symbol,
         .stack          = save_stack_stack,
         .address        = save_stack_address,
         .walk_stack     = print_context_stack,
 };
 
 static const struct stacktrace_ops save_stack_ops_nosched = {
-        .warning        = save_stack_warning,
-        .warning_symbol = save_stack_warning_symbol,
         .stack          = save_stack_stack,
         .address        = save_stack_address_nosched,
         .walk_stack     = print_context_stack,
diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
index abce34d5c79d..32cbffb0c494 100644
--- a/arch/x86/kernel/syscall_table_32.S
+++ b/arch/x86/kernel/syscall_table_32.S
@@ -344,3 +344,4 @@ ENTRY(sys_call_table)
         .long sys_open_by_handle_at
         .long sys_clock_adjtime
         .long sys_syncfs
+        .long sys_sendmmsg              /* 345 */
diff --git a/arch/x86/kernel/x86_init.c b/arch/x86/kernel/x86_init.c
index 75ef4b18e9b7..6f164bd5e14d 100644
--- a/arch/x86/kernel/x86_init.c
+++ b/arch/x86/kernel/x86_init.c
@@ -35,7 +35,7 @@ void iommu_shutdown_noop(void) { }
 struct x86_init_ops x86_init __initdata = {
 
         .resources = {
-                .probe_roms             = x86_init_noop,
+                .probe_roms             = probe_roms,
                 .reserve_resources      = reserve_standard_io_resources,
                 .memory_setup           = default_machine_specific_memory_setup,
         },
diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c
index 1cd608973ce5..e191c096ab90 100644
--- a/arch/x86/lguest/boot.c
+++ b/arch/x86/lguest/boot.c
@@ -7,7 +7,7 @@
  * kernel and insert a module (lg.ko) which allows us to run other Linux
  * kernels the same way we'd run processes.  We call the first kernel the Host,
  * and the others the Guests.  The program which sets up and configures Guests
- * (such as the example in Documentation/lguest/lguest.c) is called the
+ * (such as the example in Documentation/virtual/lguest/lguest.c) is called the
  * Launcher.
  *
  * Secondly, we only run specially modified Guests, not normal kernels: setting
@@ -913,8 +913,6 @@ static struct clocksource lguest_clock = {
         .rating         = 200,
         .read           = lguest_clock_read,
         .mask           = CLOCKSOURCE_MASK(64),
-        .mult           = 1 << 22,
-        .shift          = 22,
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
@@ -997,7 +995,7 @@ static void lguest_time_init(void)
         /* Set up the timer interrupt (0) to go to our simple timer routine */
         irq_set_handler(0, lguest_time_irq);
 
-        clocksource_register(&lguest_clock);
+        clocksource_register_hz(&lguest_clock, NSEC_PER_SEC);
 
         /* We can't set cpumask in the initializer: damn C limitations!  Set it
          * here and register our timer device. */
diff --git a/arch/x86/lib/clear_page_64.S b/arch/x86/lib/clear_page_64.S
index aa4326bfb24a..f2145cfa12a6 100644
--- a/arch/x86/lib/clear_page_64.S
+++ b/arch/x86/lib/clear_page_64.S
@@ -1,5 +1,6 @@
 #include <linux/linkage.h>
 #include <asm/dwarf2.h>
+#include <asm/alternative-asm.h>
 
 /*
  * Zero a page.         
@@ -14,6 +15,15 @@ ENTRY(clear_page_c)
         CFI_ENDPROC
 ENDPROC(clear_page_c)
 
+ENTRY(clear_page_c_e)
+        CFI_STARTPROC
+        movl $4096,%ecx
+        xorl %eax,%eax
+        rep stosb
+        ret
+        CFI_ENDPROC
+ENDPROC(clear_page_c_e)
+
 ENTRY(clear_page)
         CFI_STARTPROC
         xorl   %eax,%eax
@@ -38,21 +48,26 @@ ENTRY(clear_page)
 .Lclear_page_end:
 ENDPROC(clear_page)
 
-        /* Some CPUs run faster using the string instructions.
-           It is also a lot simpler. Use this when possible */
+        /*
+         * Some CPUs support enhanced REP MOVSB/STOSB instructions.
+         * It is recommended to use this when possible.
+         * If enhanced REP MOVSB/STOSB is not available, try to use fast string.
+         * Otherwise, use original function.
+         *
+         */
 
 #include <asm/cpufeature.h>
 
         .section .altinstr_replacement,"ax"
 1:      .byte 0xeb                                      /* jmp <disp8> */
         .byte (clear_page_c - clear_page) - (2f - 1b)   /* offset */
-2:
+2:      .byte 0xeb                                      /* jmp <disp8> */
+        .byte (clear_page_c_e - clear_page) - (3f - 2b) /* offset */
+3:
         .previous
         .section .altinstructions,"a"
-        .align 8
-        .quad clear_page
-        .quad 1b
-        .word X86_FEATURE_REP_GOOD
-        .byte .Lclear_page_end - clear_page
-        .byte 2b - 1b
+        altinstruction_entry clear_page,1b,X86_FEATURE_REP_GOOD,\
+                             .Lclear_page_end-clear_page, 2b-1b
+        altinstruction_entry clear_page,2b,X86_FEATURE_ERMS,   \
+                             .Lclear_page_end-clear_page,3b-2b
         .previous
diff --git a/arch/x86/lib/copy_user_64.S b/arch/x86/lib/copy_user_64.S
index 99e482615195..024840266ba0 100644
--- a/arch/x86/lib/copy_user_64.S
+++ b/arch/x86/lib/copy_user_64.S
@@ -15,23 +15,30 @@
 #include <asm/asm-offsets.h>
 #include <asm/thread_info.h>
 #include <asm/cpufeature.h>
+#include <asm/alternative-asm.h>
 
-        .macro ALTERNATIVE_JUMP feature,orig,alt
+/*
+ * By placing feature2 after feature1 in altinstructions section, we logically
+ * implement:
+ * If CPU has feature2, jmp to alt2 is used
+ * else if CPU has feature1, jmp to alt1 is used
+ * else jmp to orig is used.
+ */
+        .macro ALTERNATIVE_JUMP feature1,feature2,orig,alt1,alt2
 0:
         .byte 0xe9      /* 32bit jump */
         .long \orig-1f  /* by default jump to orig */
 1:
         .section .altinstr_replacement,"ax"
 2:      .byte 0xe9                      /* near jump with 32bit immediate */
-        .long \alt-1b /* offset */   /* or alternatively to alt */
+        .long \alt1-1b /* offset */   /* or alternatively to alt1 */
+3:      .byte 0xe9                      /* near jump with 32bit immediate */
+        .long \alt2-1b /* offset */   /* or alternatively to alt2 */
         .previous
+
         .section .altinstructions,"a"
-        .align 8
-        .quad  0b
-        .quad  2b
-        .word  \feature                 /* when feature is set */
-        .byte  5
-        .byte  5
+        altinstruction_entry 0b,2b,\feature1,5,5
+        altinstruction_entry 0b,3b,\feature2,5,5
         .previous
         .endm
 
@@ -72,8 +79,10 @@ ENTRY(_copy_to_user)
         addq %rdx,%rcx
         jc bad_to_user
         cmpq TI_addr_limit(%rax),%rcx
-        jae bad_to_user
-        ALTERNATIVE_JUMP X86_FEATURE_REP_GOOD,copy_user_generic_unrolled,copy_user_generic_string
+        ja bad_to_user
+        ALTERNATIVE_JUMP X86_FEATURE_REP_GOOD,X86_FEATURE_ERMS, \
+                copy_user_generic_unrolled,copy_user_generic_string,    \
+                copy_user_enhanced_fast_string
         CFI_ENDPROC
 ENDPROC(_copy_to_user)
 
@@ -85,8 +94,10 @@ ENTRY(_copy_from_user)
         addq %rdx,%rcx
         jc bad_from_user
         cmpq TI_addr_limit(%rax),%rcx
-        jae bad_from_user
-        ALTERNATIVE_JUMP X86_FEATURE_REP_GOOD,copy_user_generic_unrolled,copy_user_generic_string
+        ja bad_from_user
+        ALTERNATIVE_JUMP X86_FEATURE_REP_GOOD,X86_FEATURE_ERMS, \
+                copy_user_generic_unrolled,copy_user_generic_string,    \
+                copy_user_enhanced_fast_string
         CFI_ENDPROC
 ENDPROC(_copy_from_user)
 
@@ -255,3 +266,37 @@ ENTRY(copy_user_generic_string)
         .previous
         CFI_ENDPROC
 ENDPROC(copy_user_generic_string)
+
+/*
+ * Some CPUs are adding enhanced REP MOVSB/STOSB instructions.
+ * It's recommended to use enhanced REP MOVSB/STOSB if it's enabled.
+ *
+ * Input:
+ * rdi destination
+ * rsi source
+ * rdx count
+ *
+ * Output:
+ * eax uncopied bytes or 0 if successful.
+ */
+ENTRY(copy_user_enhanced_fast_string)
+        CFI_STARTPROC
+        andl %edx,%edx
+        jz 2f
+        movl %edx,%ecx
+1:      rep
+        movsb
+2:      xorl %eax,%eax
+        ret
+
+        .section .fixup,"ax"
+12:     movl %ecx,%edx          /* ecx is zerorest also */
+        jmp copy_user_handle_tail
+        .previous
+
+        .section __ex_table,"a"
+        .align 8
+        .quad 1b,12b
+        .previous
+        CFI_ENDPROC
+ENDPROC(copy_user_enhanced_fast_string)
diff --git a/arch/x86/lib/memcpy_64.S b/arch/x86/lib/memcpy_64.S
index 75ef61e35e38..efbf2a0ecdea 100644
--- a/arch/x86/lib/memcpy_64.S
+++ b/arch/x86/lib/memcpy_64.S
@@ -4,6 +4,7 @@
 
 #include <asm/cpufeature.h>
 #include <asm/dwarf2.h>
+#include <asm/alternative-asm.h>
 
 /*
  * memcpy - Copy a memory block.
@@ -37,6 +38,23 @@
 .Lmemcpy_e:
         .previous
 
+/*
+ * memcpy_c_e() - enhanced fast string memcpy. This is faster and simpler than
+ * memcpy_c. Use memcpy_c_e when possible.
+ *
+ * This gets patched over the unrolled variant (below) via the
+ * alternative instructions framework:
+ */
+        .section .altinstr_replacement, "ax", @progbits
+.Lmemcpy_c_e:
+        movq %rdi, %rax
+
+        movl %edx, %ecx
+        rep movsb
+        ret
+.Lmemcpy_e_e:
+        .previous
+
 ENTRY(__memcpy)
 ENTRY(memcpy)
         CFI_STARTPROC
@@ -49,7 +67,7 @@ ENTRY(memcpy)
         jb .Lhandle_tail
 
         /*
-         * We check whether memory false dependece could occur,
+         * We check whether memory false dependence could occur,
          * then jump to corresponding copy mode.
          */
         cmp  %dil, %sil
@@ -171,21 +189,22 @@ ENDPROC(memcpy)
 ENDPROC(__memcpy)
 
         /*
-         * Some CPUs run faster using the string copy instructions.
-         * It is also a lot simpler. Use this when possible:
-         */
-
-        .section .altinstructions, "a"
-        .align 8
-        .quad memcpy
-        .quad .Lmemcpy_c
-        .word X86_FEATURE_REP_GOOD
-
-        /*
+         * Some CPUs are adding enhanced REP MOVSB/STOSB feature
+         * If the feature is supported, memcpy_c_e() is the first choice.
+         * If enhanced rep movsb copy is not available, use fast string copy
+         * memcpy_c() when possible. This is faster and code is simpler than
+         * original memcpy().
+         * Otherwise, original memcpy() is used.
+         * In .altinstructions section, ERMS feature is placed after REG_GOOD
+         * feature to implement the right patch order.
+         *
          * Replace only beginning, memcpy is used to apply alternatives,
          * so it is silly to overwrite itself with nops - reboot is the
          * only outcome...
          */
-        .byte .Lmemcpy_e - .Lmemcpy_c
-        .byte .Lmemcpy_e - .Lmemcpy_c
+        .section .altinstructions, "a"
+        altinstruction_entry memcpy,.Lmemcpy_c,X86_FEATURE_REP_GOOD,\
+                             .Lmemcpy_e-.Lmemcpy_c,.Lmemcpy_e-.Lmemcpy_c
+        altinstruction_entry memcpy,.Lmemcpy_c_e,X86_FEATURE_ERMS, \
+                             .Lmemcpy_e_e-.Lmemcpy_c_e,.Lmemcpy_e_e-.Lmemcpy_c_e
         .previous
diff --git a/arch/x86/lib/memmove_64.S b/arch/x86/lib/memmove_64.S
index 0ecb8433e5a8..d0ec9c2936d7 100644
--- a/arch/x86/lib/memmove_64.S
+++ b/arch/x86/lib/memmove_64.S
@@ -8,6 +8,7 @@
 #define _STRING_C
 #include <linux/linkage.h>
 #include <asm/dwarf2.h>
+#include <asm/cpufeature.h>
 
 #undef memmove
 
@@ -24,6 +25,7 @@
  */
 ENTRY(memmove)
         CFI_STARTPROC
+
         /* Handle more 32bytes in loop */
         mov %rdi, %rax
         cmp $0x20, %rdx
@@ -31,8 +33,13 @@ ENTRY(memmove)
 
         /* Decide forward/backward copy mode */
         cmp %rdi, %rsi
-        jb      2f
+        jge .Lmemmove_begin_forward
+        mov %rsi, %r8
+        add %rdx, %r8
+        cmp %rdi, %r8
+        jg 2f
 
+.Lmemmove_begin_forward:
         /*
          * movsq instruction have many startup latency
          * so we handle small size by general register.
@@ -78,6 +85,8 @@ ENTRY(memmove)
         rep movsq
         movq %r11, (%r10)
         jmp 13f
+.Lmemmove_end_forward:
+
         /*
          * Handle data backward by movsq.
          */
@@ -194,4 +203,22 @@ ENTRY(memmove)
 13:
         retq
         CFI_ENDPROC
+
+        .section .altinstr_replacement,"ax"
+.Lmemmove_begin_forward_efs:
+        /* Forward moving data. */
+        movq %rdx, %rcx
+        rep movsb
+        retq
+.Lmemmove_end_forward_efs:
+        .previous
+
+        .section .altinstructions,"a"
+        .align 8
+        .quad .Lmemmove_begin_forward
+        .quad .Lmemmove_begin_forward_efs
+        .word X86_FEATURE_ERMS
+        .byte .Lmemmove_end_forward-.Lmemmove_begin_forward
+        .byte .Lmemmove_end_forward_efs-.Lmemmove_begin_forward_efs
+        .previous
 ENDPROC(memmove)
diff --git a/arch/x86/lib/memset_64.S b/arch/x86/lib/memset_64.S
index 09d344269652..79bd454b78a3 100644
--- a/arch/x86/lib/memset_64.S
+++ b/arch/x86/lib/memset_64.S
@@ -2,9 +2,13 @@
 
 #include <linux/linkage.h>
 #include <asm/dwarf2.h>
+#include <asm/cpufeature.h>
+#include <asm/alternative-asm.h>
 
 /*
- * ISO C memset - set a memory block to a byte value.
+ * ISO C memset - set a memory block to a byte value. This function uses fast
+ * string to get better performance than the original function. The code is
+ * simpler and shorter than the orignal function as well.
  *      
  * rdi   destination
  * rsi   value (char) 
@@ -31,6 +35,28 @@
 .Lmemset_e:
         .previous
 
+/*
+ * ISO C memset - set a memory block to a byte value. This function uses
+ * enhanced rep stosb to override the fast string function.
+ * The code is simpler and shorter than the fast string function as well.
+ *
+ * rdi   destination
+ * rsi   value (char)
+ * rdx   count (bytes)
+ *
+ * rax   original destination
+ */
+        .section .altinstr_replacement, "ax", @progbits
+.Lmemset_c_e:
+        movq %rdi,%r9
+        movb %sil,%al
+        movl %edx,%ecx
+        rep stosb
+        movq %r9,%rax
+        ret
+.Lmemset_e_e:
+        .previous
+
 ENTRY(memset)
 ENTRY(__memset)
         CFI_STARTPROC
@@ -112,16 +138,20 @@ ENTRY(__memset)
 ENDPROC(memset)
 ENDPROC(__memset)
 
-        /* Some CPUs run faster using the string instructions.
-           It is also a lot simpler. Use this when possible */
-
-#include <asm/cpufeature.h>
-
+        /* Some CPUs support enhanced REP MOVSB/STOSB feature.
+         * It is recommended to use this when possible.
+         *
+         * If enhanced REP MOVSB/STOSB feature is not available, use fast string
+         * instructions.
+         *
+         * Otherwise, use original memset function.
+         *
+         * In .altinstructions section, ERMS feature is placed after REG_GOOD
+         * feature to implement the right patch order.
+         */
         .section .altinstructions,"a"
-        .align 8
-        .quad memset
-        .quad .Lmemset_c
-        .word X86_FEATURE_REP_GOOD
-        .byte .Lfinal - memset
-        .byte .Lmemset_e - .Lmemset_c
+        altinstruction_entry memset,.Lmemset_c,X86_FEATURE_REP_GOOD,\
+                             .Lfinal-memset,.Lmemset_e-.Lmemset_c
+        altinstruction_entry memset,.Lmemset_c_e,X86_FEATURE_ERMS, \
+                             .Lfinal-memset,.Lmemset_e_e-.Lmemset_c_e
         .previous
diff --git a/arch/x86/mm/Makefile b/arch/x86/mm/Makefile
index 3e608edf9958..3d11327c9ab4 100644
--- a/arch/x86/mm/Makefile
+++ b/arch/x86/mm/Makefile
@@ -23,8 +23,8 @@ mmiotrace-y			:= kmmio.o pf_in.o mmio-mod.o
 obj-$(CONFIG_MMIOTRACE_TEST)    += testmmiotrace.o
 
 obj-$(CONFIG_NUMA)              += numa.o numa_$(BITS).o
-obj-$(CONFIG_AMD_NUMA)          += amdtopology_64.o
-obj-$(CONFIG_ACPI_NUMA)         += srat_$(BITS).o
+obj-$(CONFIG_AMD_NUMA)          += amdtopology.o
+obj-$(CONFIG_ACPI_NUMA)         += srat.o
 obj-$(CONFIG_NUMA_EMU)          += numa_emulation.o
 
 obj-$(CONFIG_HAVE_MEMBLOCK)             += memblock.o
diff --git a/arch/x86/mm/amdtopology_64.c b/arch/x86/mm/amdtopology.c
index 0919c26820d4..5247d01329ca 100644
--- a/arch/x86/mm/amdtopology_64.c
+++ b/arch/x86/mm/amdtopology.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/nodemask.h>
 #include <linux/memblock.h>
+#include <linux/bootmem.h>
 
 #include <asm/io.h>
 #include <linux/pci_ids.h>
@@ -69,10 +70,10 @@ static __init void early_get_boot_cpu_id(void)
 
 int __init amd_numa_init(void)
 {
-        unsigned long start = PFN_PHYS(0);
-        unsigned long end = PFN_PHYS(max_pfn);
+        u64 start = PFN_PHYS(0);
+        u64 end = PFN_PHYS(max_pfn);
         unsigned numnodes;
-        unsigned long prevbase;
+        u64 prevbase;
         int i, j, nb;
         u32 nodeid, reg;
         unsigned int bits, cores, apicid_base;
@@ -95,7 +96,7 @@ int __init amd_numa_init(void)
 
         prevbase = 0;
         for (i = 0; i < 8; i++) {
-                unsigned long base, limit;
+                u64 base, limit;
 
                 base = read_pci_config(0, nb, 1, 0x40 + i*8);
                 limit = read_pci_config(0, nb, 1, 0x44 + i*8);
@@ -107,18 +108,18 @@ int __init amd_numa_init(void)
                         continue;
                 }
                 if (nodeid >= numnodes) {
-                        pr_info("Ignoring excess node %d (%lx:%lx)\n", nodeid,
+                        pr_info("Ignoring excess node %d (%Lx:%Lx)\n", nodeid,
                                 base, limit);
                         continue;
                 }
 
                 if (!limit) {
-                        pr_info("Skipping node entry %d (base %lx)\n",
+                        pr_info("Skipping node entry %d (base %Lx)\n",
                                 i, base);
                         continue;
                 }
                 if ((base >> 8) & 3 || (limit >> 8) & 3) {
-                        pr_err("Node %d using interleaving mode %lx/%lx\n",
+                        pr_err("Node %d using interleaving mode %Lx/%Lx\n",
                                nodeid, (base >> 8) & 3, (limit >> 8) & 3);
                         return -EINVAL;
                 }
@@ -150,19 +151,19 @@ int __init amd_numa_init(void)
                         continue;
                 }
                 if (limit < base) {
-                        pr_err("Node %d bogus settings %lx-%lx.\n",
+                        pr_err("Node %d bogus settings %Lx-%Lx.\n",
                                nodeid, base, limit);
                         continue;
                 }
 
                 /* Could sort here, but pun for now. Should not happen anyroads. */
                 if (prevbase > base) {
-                        pr_err("Node map not sorted %lx,%lx\n",
+                        pr_err("Node map not sorted %Lx,%Lx\n",
                                prevbase, base);
                         return -EINVAL;
                 }
 
-                pr_info("Node %d MemBase %016lx Limit %016lx\n",
+                pr_info("Node %d MemBase %016Lx Limit %016Lx\n",
                         nodeid, base, limit);
 
                 prevbase = base;
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index 20e3f8702d1e..bcb394dfbb35 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -12,6 +12,7 @@
 #include <linux/mmiotrace.h>            /* kmmio_handler, ...           */
 #include <linux/perf_event.h>           /* perf_sw_event                */
 #include <linux/hugetlb.h>              /* hstate_index_to_shift        */
+#include <linux/prefetch.h>             /* prefetchw                    */
 
 #include <asm/traps.h>                  /* dotraplinkage, ...           */
 #include <asm/pgalloc.h>                /* pgd_*(), ...                 */
diff --git a/arch/x86/mm/init_32.c b/arch/x86/mm/init_32.c
index 80088f994193..29f7c6d98179 100644
--- a/arch/x86/mm/init_32.c
+++ b/arch/x86/mm/init_32.c
@@ -678,8 +678,10 @@ static void __init zone_sizes_init(void)
 {
         unsigned long max_zone_pfns[MAX_NR_ZONES];
         memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
+#ifdef CONFIG_ZONE_DMA
         max_zone_pfns[ZONE_DMA] =
                 virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
+#endif
         max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
 #ifdef CONFIG_HIGHMEM
         max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;
@@ -716,6 +718,7 @@ void __init paging_init(void)
          * NOTE: at this point the bootmem allocator is fully available.
          */
         olpc_dt_build_devicetree();
+        sparse_memory_present_with_active_regions(MAX_NUMNODES);
         sparse_init();
         zone_sizes_init();
 }
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 794233587287..d865c4aeec55 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -616,7 +616,9 @@ void __init paging_init(void)
         unsigned long max_zone_pfns[MAX_NR_ZONES];
 
         memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
+#ifdef CONFIG_ZONE_DMA
         max_zone_pfns[ZONE_DMA] = MAX_DMA_PFN;
+#endif
         max_zone_pfns[ZONE_DMA32] = MAX_DMA32_PFN;
         max_zone_pfns[ZONE_NORMAL] = max_pfn;
 
@@ -679,14 +681,6 @@ int arch_add_memory(int nid, u64 start, u64 size)
 }
 EXPORT_SYMBOL_GPL(arch_add_memory);
 
-#if !defined(CONFIG_ACPI_NUMA) && defined(CONFIG_NUMA)
-int memory_add_physaddr_to_nid(u64 start)
-{
-        return 0;
-}
-EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
-#endif
-
 #endif /* CONFIG_MEMORY_HOTPLUG */
 
 static struct kcore_list kcore_vsyscall;
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index 0369843511dc..be1ef574ce9a 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -91,13 +91,6 @@ static void __iomem *__ioremap_caller(resource_size_t phys_addr,
                 return (__force void __iomem *)phys_to_virt(phys_addr);
 
         /*
-         * Check if the request spans more than any BAR in the iomem resource
-         * tree.
-         */
-        WARN_ONCE(iomem_map_sanity_check(phys_addr, size),
-                  KERN_INFO "Info: mapping multiple BARs. Your kernel is fine.");
-
-        /*
          * Don't allow anybody to remap normal RAM that we're using..
          */
         last_pfn = last_addr >> PAGE_SHIFT;
@@ -170,6 +163,13 @@ static void __iomem *__ioremap_caller(resource_size_t phys_addr,
         ret_addr = (void __iomem *) (vaddr + offset);
         mmiotrace_ioremap(unaligned_phys_addr, unaligned_size, ret_addr);
 
+        /*
+         * Check if the request spans more than any BAR in the iomem resource
+         * tree.
+         */
+        WARN_ONCE(iomem_map_sanity_check(unaligned_phys_addr, unaligned_size),
+                  KERN_INFO "Info: mapping multiple BARs. Your kernel is fine.");
+
         return ret_addr;
 err_free_area:
         free_vm_area(area);
diff --git a/arch/x86/mm/numa.c b/arch/x86/mm/numa.c
index 745258dfc4dc..f5510d889a22 100644
--- a/arch/x86/mm/numa.c
+++ b/arch/x86/mm/numa.c
@@ -1,11 +1,39 @@
 /* Common code for 32 and 64-bit NUMA */
-#include <linux/topology.h>
-#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/init.h>
 #include <linux/bootmem.h>
-#include <asm/numa.h>
+#include <linux/memblock.h>
+#include <linux/mmzone.h>
+#include <linux/ctype.h>
+#include <linux/module.h>
+#include <linux/nodemask.h>
+#include <linux/sched.h>
+#include <linux/topology.h>
+
+#include <asm/e820.h>
+#include <asm/proto.h>
+#include <asm/dma.h>
 #include <asm/acpi.h>
+#include <asm/amd_nb.h>
+
+#include "numa_internal.h"
 
 int __initdata numa_off;
+nodemask_t numa_nodes_parsed __initdata;
+
+struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
+EXPORT_SYMBOL(node_data);
+
+static struct numa_meminfo numa_meminfo
+#ifndef CONFIG_MEMORY_HOTPLUG
+__initdata
+#endif
+;
+
+static int numa_distance_cnt;
+static u8 *numa_distance;
 
 static __init int numa_setup(char *opt)
 {
@@ -32,6 +60,15 @@ s16 __apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
         [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
 };
 
+int __cpuinit numa_cpu_node(int cpu)
+{
+        int apicid = early_per_cpu(x86_cpu_to_apicid, cpu);
+
+        if (apicid != BAD_APICID)
+                return __apicid_to_node[apicid];
+        return NUMA_NO_NODE;
+}
+
 cpumask_var_t node_to_cpumask_map[MAX_NUMNODES];
 EXPORT_SYMBOL(node_to_cpumask_map);
 
@@ -95,6 +132,407 @@ void __init setup_node_to_cpumask_map(void)
         pr_debug("Node to cpumask map for %d nodes\n", nr_node_ids);
 }
 
+static int __init numa_add_memblk_to(int nid, u64 start, u64 end,
+                                     struct numa_meminfo *mi)
+{
+        /* ignore zero length blks */
+        if (start == end)
+                return 0;
+
+        /* whine about and ignore invalid blks */
+        if (start > end || nid < 0 || nid >= MAX_NUMNODES) {
+                pr_warning("NUMA: Warning: invalid memblk node %d (%Lx-%Lx)\n",
+                           nid, start, end);
+                return 0;
+        }
+
+        if (mi->nr_blks >= NR_NODE_MEMBLKS) {
+                pr_err("NUMA: too many memblk ranges\n");
+                return -EINVAL;
+        }
+
+        mi->blk[mi->nr_blks].start = start;
+        mi->blk[mi->nr_blks].end = end;
+        mi->blk[mi->nr_blks].nid = nid;
+        mi->nr_blks++;
+        return 0;
+}
+
+/**
+ * numa_remove_memblk_from - Remove one numa_memblk from a numa_meminfo
+ * @idx: Index of memblk to remove
+ * @mi: numa_meminfo to remove memblk from
+ *
+ * Remove @idx'th numa_memblk from @mi by shifting @mi->blk[] and
+ * decrementing @mi->nr_blks.
+ */
+void __init numa_remove_memblk_from(int idx, struct numa_meminfo *mi)
+{
+        mi->nr_blks--;
+        memmove(&mi->blk[idx], &mi->blk[idx + 1],
+                (mi->nr_blks - idx) * sizeof(mi->blk[0]));
+}
+
+/**
+ * numa_add_memblk - Add one numa_memblk to numa_meminfo
+ * @nid: NUMA node ID of the new memblk
+ * @start: Start address of the new memblk
+ * @end: End address of the new memblk
+ *
+ * Add a new memblk to the default numa_meminfo.
+ *
+ * RETURNS:
+ * 0 on success, -errno on failure.
+ */
+int __init numa_add_memblk(int nid, u64 start, u64 end)
+{
+        return numa_add_memblk_to(nid, start, end, &numa_meminfo);
+}
+
+/* Initialize NODE_DATA for a node on the local memory */
+static void __init setup_node_data(int nid, u64 start, u64 end)
+{
+        const u64 nd_low = PFN_PHYS(MAX_DMA_PFN);
+        const u64 nd_high = PFN_PHYS(max_pfn_mapped);
+        const size_t nd_size = roundup(sizeof(pg_data_t), PAGE_SIZE);
+        bool remapped = false;
+        u64 nd_pa;
+        void *nd;
+        int tnid;
+
+        /*
+         * Don't confuse VM with a node that doesn't have the
+         * minimum amount of memory:
+         */
+        if (end && (end - start) < NODE_MIN_SIZE)
+                return;
+
+        /* initialize remap allocator before aligning to ZONE_ALIGN */
+        init_alloc_remap(nid, start, end);
+
+        start = roundup(start, ZONE_ALIGN);
+
+        printk(KERN_INFO "Initmem setup node %d %016Lx-%016Lx\n",
+               nid, start, end);
+
+        /*
+         * Allocate node data.  Try remap allocator first, node-local
+         * memory and then any node.  Never allocate in DMA zone.
+         */
+        nd = alloc_remap(nid, nd_size);
+        if (nd) {
+                nd_pa = __pa(nd);
+                remapped = true;
+        } else {
+                nd_pa = memblock_x86_find_in_range_node(nid, nd_low, nd_high,
+                                                nd_size, SMP_CACHE_BYTES);
+                if (nd_pa == MEMBLOCK_ERROR)
+                        nd_pa = memblock_find_in_range(nd_low, nd_high,
+                                                nd_size, SMP_CACHE_BYTES);
+                if (nd_pa == MEMBLOCK_ERROR) {
+                        pr_err("Cannot find %zu bytes in node %d\n",
+                               nd_size, nid);
+                        return;
+                }
+                memblock_x86_reserve_range(nd_pa, nd_pa + nd_size, "NODE_DATA");
+                nd = __va(nd_pa);
+        }
+
+        /* report and initialize */
+        printk(KERN_INFO "  NODE_DATA [%016Lx - %016Lx]%s\n",
+               nd_pa, nd_pa + nd_size - 1, remapped ? " (remapped)" : "");
+        tnid = early_pfn_to_nid(nd_pa >> PAGE_SHIFT);
+        if (!remapped && tnid != nid)
+                printk(KERN_INFO "    NODE_DATA(%d) on node %d\n", nid, tnid);
+
+        node_data[nid] = nd;
+        memset(NODE_DATA(nid), 0, sizeof(pg_data_t));
+        NODE_DATA(nid)->node_id = nid;
+        NODE_DATA(nid)->node_start_pfn = start >> PAGE_SHIFT;
+        NODE_DATA(nid)->node_spanned_pages = (end - start) >> PAGE_SHIFT;
+
+        node_set_online(nid);
+}
+
+/**
+ * numa_cleanup_meminfo - Cleanup a numa_meminfo
+ * @mi: numa_meminfo to clean up
+ *
+ * Sanitize @mi by merging and removing unncessary memblks.  Also check for
+ * conflicts and clear unused memblks.
+ *
+ * RETURNS:
+ * 0 on success, -errno on failure.
+ */
+int __init numa_cleanup_meminfo(struct numa_meminfo *mi)
+{
+        const u64 low = 0;
+        const u64 high = PFN_PHYS(max_pfn);
+        int i, j, k;
+
+        /* first, trim all entries */
+        for (i = 0; i < mi->nr_blks; i++) {
+                struct numa_memblk *bi = &mi->blk[i];
+
+                /* make sure all blocks are inside the limits */
+                bi->start = max(bi->start, low);
+                bi->end = min(bi->end, high);
+
+                /* and there's no empty block */
+                if (bi->start >= bi->end)
+                        numa_remove_memblk_from(i--, mi);
+        }
+
+        /* merge neighboring / overlapping entries */
+        for (i = 0; i < mi->nr_blks; i++) {
+                struct numa_memblk *bi = &mi->blk[i];
+
+                for (j = i + 1; j < mi->nr_blks; j++) {
+                        struct numa_memblk *bj = &mi->blk[j];
+                        u64 start, end;
+
+                        /*
+                         * See whether there are overlapping blocks.  Whine
+                         * about but allow overlaps of the same nid.  They
+                         * will be merged below.
+                         */
+                        if (bi->end > bj->start && bi->start < bj->end) {
+                                if (bi->nid != bj->nid) {
+                                        pr_err("NUMA: node %d (%Lx-%Lx) overlaps with node %d (%Lx-%Lx)\n",
+                                               bi->nid, bi->start, bi->end,
+                                               bj->nid, bj->start, bj->end);
+                                        return -EINVAL;
+                                }
+                                pr_warning("NUMA: Warning: node %d (%Lx-%Lx) overlaps with itself (%Lx-%Lx)\n",
+                                           bi->nid, bi->start, bi->end,
+                                           bj->start, bj->end);
+                        }
+
+                        /*
+                         * Join together blocks on the same node, holes
+                         * between which don't overlap with memory on other
+                         * nodes.
+                         */
+                        if (bi->nid != bj->nid)
+                                continue;
+                        start = min(bi->start, bj->start);
+                        end = max(bi->end, bj->end);
+                        for (k = 0; k < mi->nr_blks; k++) {
+                                struct numa_memblk *bk = &mi->blk[k];
+
+                                if (bi->nid == bk->nid)
+                                        continue;
+                                if (start < bk->end && end > bk->start)
+                                        break;
+                        }
+                        if (k < mi->nr_blks)
+                                continue;
+                        printk(KERN_INFO "NUMA: Node %d [%Lx,%Lx) + [%Lx,%Lx) -> [%Lx,%Lx)\n",
+                               bi->nid, bi->start, bi->end, bj->start, bj->end,
+                               start, end);
+                        bi->start = start;
+                        bi->end = end;
+                        numa_remove_memblk_from(j--, mi);
+                }
+        }
+
+        /* clear unused ones */
+        for (i = mi->nr_blks; i < ARRAY_SIZE(mi->blk); i++) {
+                mi->blk[i].start = mi->blk[i].end = 0;
+                mi->blk[i].nid = NUMA_NO_NODE;
+        }
+
+        return 0;
+}
+
+/*
+ * Set nodes, which have memory in @mi, in *@nodemask.
+ */
+static void __init numa_nodemask_from_meminfo(nodemask_t *nodemask,
+                                              const struct numa_meminfo *mi)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(mi->blk); i++)
+                if (mi->blk[i].start != mi->blk[i].end &&
+                    mi->blk[i].nid != NUMA_NO_NODE)
+                        node_set(mi->blk[i].nid, *nodemask);
+}
+
+/**
+ * numa_reset_distance - Reset NUMA distance table
+ *
+ * The current table is freed.  The next numa_set_distance() call will
+ * create a new one.
+ */
+void __init numa_reset_distance(void)
+{
+        size_t size = numa_distance_cnt * numa_distance_cnt * sizeof(numa_distance[0]);
+
+        /* numa_distance could be 1LU marking allocation failure, test cnt */
+        if (numa_distance_cnt)
+                memblock_x86_free_range(__pa(numa_distance),
+                                        __pa(numa_distance) + size);
+        numa_distance_cnt = 0;
+        numa_distance = NULL;   /* enable table creation */
+}
+
+static int __init numa_alloc_distance(void)
+{
+        nodemask_t nodes_parsed;
+        size_t size;
+        int i, j, cnt = 0;
+        u64 phys;
+
+        /* size the new table and allocate it */
+        nodes_parsed = numa_nodes_parsed;
+        numa_nodemask_from_meminfo(&nodes_parsed, &numa_meminfo);
+
+        for_each_node_mask(i, nodes_parsed)
+                cnt = i;
+        cnt++;
+        size = cnt * cnt * sizeof(numa_distance[0]);
+
+        phys = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped),
+                                      size, PAGE_SIZE);
+        if (phys == MEMBLOCK_ERROR) {
+                pr_warning("NUMA: Warning: can't allocate distance table!\n");
+                /* don't retry until explicitly reset */
+                numa_distance = (void *)1LU;
+                return -ENOMEM;
+        }
+        memblock_x86_reserve_range(phys, phys + size, "NUMA DIST");
+
+        numa_distance = __va(phys);
+        numa_distance_cnt = cnt;
+
+        /* fill with the default distances */
+        for (i = 0; i < cnt; i++)
+                for (j = 0; j < cnt; j++)
+                        numa_distance[i * cnt + j] = i == j ?
+                                LOCAL_DISTANCE : REMOTE_DISTANCE;
+        printk(KERN_DEBUG "NUMA: Initialized distance table, cnt=%d\n", cnt);
+
+        return 0;
+}
+
+/**
+ * numa_set_distance - Set NUMA distance from one NUMA to another
+ * @from: the 'from' node to set distance
+ * @to: the 'to'  node to set distance
+ * @distance: NUMA distance
+ *
+ * Set the distance from node @from to @to to @distance.  If distance table
+ * doesn't exist, one which is large enough to accommodate all the currently
+ * known nodes will be created.
+ *
+ * If such table cannot be allocated, a warning is printed and further
+ * calls are ignored until the distance table is reset with
+ * numa_reset_distance().
+ *
+ * If @from or @to is higher than the highest known node at the time of
+ * table creation or @distance doesn't make sense, the call is ignored.
+ * This is to allow simplification of specific NUMA config implementations.
+ */
+void __init numa_set_distance(int from, int to, int distance)
+{
+        if (!numa_distance && numa_alloc_distance() < 0)
+                return;
+
+        if (from >= numa_distance_cnt || to >= numa_distance_cnt) {
+                printk_once(KERN_DEBUG "NUMA: Debug: distance out of bound, from=%d to=%d distance=%d\n",
+                            from, to, distance);
+                return;
+        }
+
+        if ((u8)distance != distance ||
+            (from == to && distance != LOCAL_DISTANCE)) {
+                pr_warn_once("NUMA: Warning: invalid distance parameter, from=%d to=%d distance=%d\n",
+                             from, to, distance);
+                return;
+        }
+
+        numa_distance[from * numa_distance_cnt + to] = distance;
+}
+
+int __node_distance(int from, int to)
+{
+        if (from >= numa_distance_cnt || to >= numa_distance_cnt)
+                return from == to ? LOCAL_DISTANCE : REMOTE_DISTANCE;
+        return numa_distance[from * numa_distance_cnt + to];
+}
+EXPORT_SYMBOL(__node_distance);
+
+/*
+ * Sanity check to catch more bad NUMA configurations (they are amazingly
+ * common).  Make sure the nodes cover all memory.
+ */
+static bool __init numa_meminfo_cover_memory(const struct numa_meminfo *mi)
+{
+        u64 numaram, e820ram;
+        int i;
+
+        numaram = 0;
+        for (i = 0; i < mi->nr_blks; i++) {
+                u64 s = mi->blk[i].start >> PAGE_SHIFT;
+                u64 e = mi->blk[i].end >> PAGE_SHIFT;
+                numaram += e - s;
+                numaram -= __absent_pages_in_range(mi->blk[i].nid, s, e);
+                if ((s64)numaram < 0)
+                        numaram = 0;
+        }
+
+        e820ram = max_pfn - (memblock_x86_hole_size(0,
+                                        PFN_PHYS(max_pfn)) >> PAGE_SHIFT);
+        /* We seem to lose 3 pages somewhere. Allow 1M of slack. */
+        if ((s64)(e820ram - numaram) >= (1 << (20 - PAGE_SHIFT))) {
+                printk(KERN_ERR "NUMA: nodes only cover %LuMB of your %LuMB e820 RAM. Not used.\n",
+                       (numaram << PAGE_SHIFT) >> 20,
+                       (e820ram << PAGE_SHIFT) >> 20);
+                return false;
+        }
+        return true;
+}
+
+static int __init numa_register_memblks(struct numa_meminfo *mi)
+{
+        int i, nid;
+
+        /* Account for nodes with cpus and no memory */
+        node_possible_map = numa_nodes_parsed;
+        numa_nodemask_from_meminfo(&node_possible_map, mi);
+        if (WARN_ON(nodes_empty(node_possible_map)))
+                return -EINVAL;
+
+        for (i = 0; i < mi->nr_blks; i++)
+                memblock_x86_register_active_regions(mi->blk[i].nid,
+                                        mi->blk[i].start >> PAGE_SHIFT,
+                                        mi->blk[i].end >> PAGE_SHIFT);
+
+        /* for out of order entries */
+        sort_node_map();
+        if (!numa_meminfo_cover_memory(mi))
+                return -EINVAL;
+
+        /* Finally register nodes. */
+        for_each_node_mask(nid, node_possible_map) {
+                u64 start = PFN_PHYS(max_pfn);
+                u64 end = 0;
+
+                for (i = 0; i < mi->nr_blks; i++) {
+                        if (nid != mi->blk[i].nid)
+                                continue;
+                        start = min(mi->blk[i].start, start);
+                        end = max(mi->blk[i].end, end);
+                }
+
+                if (start < end)
+                        setup_node_data(nid, start, end);
+        }
+
+        return 0;
+}
+
 /*
  * There are unfortunately some poorly designed mainboards around that
  * only connect memory to a single CPU. This breaks the 1:1 cpu->node
@@ -102,7 +540,7 @@ void __init setup_node_to_cpumask_map(void)
  * as the number of CPUs is not known yet. We round robin the existing
  * nodes.
  */
-void __init numa_init_array(void)
+static void __init numa_init_array(void)
 {
         int rr, i;
 
@@ -117,6 +555,95 @@ void __init numa_init_array(void)
         }
 }
 
+static int __init numa_init(int (*init_func)(void))
+{
+        int i;
+        int ret;
+
+        for (i = 0; i < MAX_LOCAL_APIC; i++)
+                set_apicid_to_node(i, NUMA_NO_NODE);
+
+        nodes_clear(numa_nodes_parsed);
+        nodes_clear(node_possible_map);
+        nodes_clear(node_online_map);
+        memset(&numa_meminfo, 0, sizeof(numa_meminfo));
+        remove_all_active_ranges();
+        numa_reset_distance();
+
+        ret = init_func();
+        if (ret < 0)
+                return ret;
+        ret = numa_cleanup_meminfo(&numa_meminfo);
+        if (ret < 0)
+                return ret;
+
+        numa_emulation(&numa_meminfo, numa_distance_cnt);
+
+        ret = numa_register_memblks(&numa_meminfo);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0; i < nr_cpu_ids; i++) {
+                int nid = early_cpu_to_node(i);
+
+                if (nid == NUMA_NO_NODE)
+                        continue;
+                if (!node_online(nid))
+                        numa_clear_node(i);
+        }
+        numa_init_array();
+        return 0;
+}
+
+/**
+ * dummy_numa_init - Fallback dummy NUMA init
+ *
+ * Used if there's no underlying NUMA architecture, NUMA initialization
+ * fails, or NUMA is disabled on the command line.
+ *
+ * Must online at least one node and add memory blocks that cover all
+ * allowed memory.  This function must not fail.
+ */
+static int __init dummy_numa_init(void)
+{
+        printk(KERN_INFO "%s\n",
+               numa_off ? "NUMA turned off" : "No NUMA configuration found");
+        printk(KERN_INFO "Faking a node at %016Lx-%016Lx\n",
+               0LLU, PFN_PHYS(max_pfn));
+
+        node_set(0, numa_nodes_parsed);
+        numa_add_memblk(0, 0, PFN_PHYS(max_pfn));
+
+        return 0;
+}
+
+/**
+ * x86_numa_init - Initialize NUMA
+ *
+ * Try each configured NUMA initialization method until one succeeds.  The
+ * last fallback is dummy single node config encomapssing whole memory and
+ * never fails.
+ */
+void __init x86_numa_init(void)
+{
+        if (!numa_off) {
+#ifdef CONFIG_X86_NUMAQ
+                if (!numa_init(numaq_numa_init))
+                        return;
+#endif
+#ifdef CONFIG_ACPI_NUMA
+                if (!numa_init(x86_acpi_numa_init))
+                        return;
+#endif
+#ifdef CONFIG_AMD_NUMA
+                if (!numa_init(amd_numa_init))
+                        return;
+#endif
+        }
+
+        numa_init(dummy_numa_init);
+}
+
 static __init int find_near_online_node(int node)
 {
         int n, val;
@@ -282,3 +809,18 @@ const struct cpumask *cpumask_of_node(int node)
 EXPORT_SYMBOL(cpumask_of_node);
 
 #endif  /* !CONFIG_DEBUG_PER_CPU_MAPS */
+
+#ifdef CONFIG_MEMORY_HOTPLUG
+int memory_add_physaddr_to_nid(u64 start)
+{
+        struct numa_meminfo *mi = &numa_meminfo;
+        int nid = mi->blk[0].nid;
+        int i;
+
+        for (i = 0; i < mi->nr_blks; i++)
+                if (mi->blk[i].start <= start && mi->blk[i].end > start)
+                        nid = mi->blk[i].nid;
+        return nid;
+}
+EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
+#endif
diff --git a/arch/x86/mm/numa_32.c b/arch/x86/mm/numa_32.c
index bde3906420df..849a975d3fa0 100644
--- a/arch/x86/mm/numa_32.c
+++ b/arch/x86/mm/numa_32.c
@@ -22,39 +22,11 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <linux/mm.h>
 #include <linux/bootmem.h>
 #include <linux/memblock.h>
-#include <linux/mmzone.h>
-#include <linux/highmem.h>
-#include <linux/initrd.h>
-#include <linux/nodemask.h>
 #include <linux/module.h>
-#include <linux/kexec.h>
-#include <linux/pfn.h>
-#include <linux/swap.h>
-#include <linux/acpi.h>
-
-#include <asm/e820.h>
-#include <asm/setup.h>
-#include <asm/mmzone.h>
-#include <asm/bios_ebda.h>
-#include <asm/proto.h>
-
-struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
-EXPORT_SYMBOL(node_data);
-
-/*
- * numa interface - we expect the numa architecture specific code to have
- *                  populated the following initialisation.
- *
- * 1) node_online_map  - the map of all nodes configured (online) in the system
- * 2) node_start_pfn   - the starting page frame number for a node
- * 3) node_end_pfn     - the ending page fram number for a node
- */
-unsigned long node_start_pfn[MAX_NUMNODES] __read_mostly;
-unsigned long node_end_pfn[MAX_NUMNODES] __read_mostly;
 
+#include "numa_internal.h"
 
 #ifdef CONFIG_DISCONTIGMEM
 /*
@@ -99,108 +71,46 @@ unsigned long node_memmap_size_bytes(int nid, unsigned long start_pfn,
 }
 #endif
 
-extern unsigned long find_max_low_pfn(void);
 extern unsigned long highend_pfn, highstart_pfn;
 
 #define LARGE_PAGE_BYTES (PTRS_PER_PTE * PAGE_SIZE)
 
-unsigned long node_remap_size[MAX_NUMNODES];
 static void *node_remap_start_vaddr[MAX_NUMNODES];
 void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags);
 
-static unsigned long kva_start_pfn;
-static unsigned long kva_pages;
-
-int __cpuinit numa_cpu_node(int cpu)
-{
-        return apic->x86_32_numa_cpu_node(cpu);
-}
-
-/*
- * FLAT - support for basic PC memory model with discontig enabled, essentially
- *        a single node with all available processors in it with a flat
- *        memory map.
- */
-int __init get_memcfg_numa_flat(void)
-{
-        printk(KERN_DEBUG "NUMA - single node, flat memory mode\n");
-
-        node_start_pfn[0] = 0;
-        node_end_pfn[0] = max_pfn;
-        memblock_x86_register_active_regions(0, 0, max_pfn);
-        memory_present(0, 0, max_pfn);
-        node_remap_size[0] = node_memmap_size_bytes(0, 0, max_pfn);
-
-        /* Indicate there is one node available. */
-        nodes_clear(node_online_map);
-        node_set_online(0);
-        return 1;
-}
-
-/*
- * Find the highest page frame number we have available for the node
- */
-static void __init propagate_e820_map_node(int nid)
-{
-        if (node_end_pfn[nid] > max_pfn)
-                node_end_pfn[nid] = max_pfn;
-        /*
-         * if a user has given mem=XXXX, then we need to make sure 
-         * that the node _starts_ before that, too, not just ends
-         */
-        if (node_start_pfn[nid] > max_pfn)
-                node_start_pfn[nid] = max_pfn;
-        BUG_ON(node_start_pfn[nid] > node_end_pfn[nid]);
-}
-
-/* 
- * Allocate memory for the pg_data_t for this node via a crude pre-bootmem
- * method.  For node zero take this from the bottom of memory, for
- * subsequent nodes place them at node_remap_start_vaddr which contains
- * node local data in physically node local memory.  See setup_memory()
- * for details.
- */
-static void __init allocate_pgdat(int nid)
-{
-        char buf[16];
-
-        if (node_has_online_mem(nid) && node_remap_start_vaddr[nid])
-                NODE_DATA(nid) = (pg_data_t *)node_remap_start_vaddr[nid];
-        else {
-                unsigned long pgdat_phys;
-                pgdat_phys = memblock_find_in_range(min_low_pfn<<PAGE_SHIFT,
-                                 max_pfn_mapped<<PAGE_SHIFT,
-                                 sizeof(pg_data_t),
-                                 PAGE_SIZE);
-                NODE_DATA(nid) = (pg_data_t *)(pfn_to_kaddr(pgdat_phys>>PAGE_SHIFT));
-                memset(buf, 0, sizeof(buf));
-                sprintf(buf, "NODE_DATA %d",  nid);
-                memblock_x86_reserve_range(pgdat_phys, pgdat_phys + sizeof(pg_data_t), buf);
-        }
-        printk(KERN_DEBUG "allocate_pgdat: node %d NODE_DATA %08lx\n",
-                nid, (unsigned long)NODE_DATA(nid));
-}
-
 /*
- * In the DISCONTIGMEM and SPARSEMEM memory model, a portion of the kernel
- * virtual address space (KVA) is reserved and portions of nodes are mapped
- * using it. This is to allow node-local memory to be allocated for
- * structures that would normally require ZONE_NORMAL. The memory is
- * allocated with alloc_remap() and callers should be prepared to allocate
- * from the bootmem allocator instead.
+ * Remap memory allocator
  */
 static unsigned long node_remap_start_pfn[MAX_NUMNODES];
 static void *node_remap_end_vaddr[MAX_NUMNODES];
 static void *node_remap_alloc_vaddr[MAX_NUMNODES];
-static unsigned long node_remap_offset[MAX_NUMNODES];
 
+/**
+ * alloc_remap - Allocate remapped memory
+ * @nid: NUMA node to allocate memory from
+ * @size: The size of allocation
+ *
+ * Allocate @size bytes from the remap area of NUMA node @nid.  The
+ * size of the remap area is predetermined by init_alloc_remap() and
+ * only the callers considered there should call this function.  For
+ * more info, please read the comment on top of init_alloc_remap().
+ *
+ * The caller must be ready to handle allocation failure from this
+ * function and fall back to regular memory allocator in such cases.
+ *
+ * CONTEXT:
+ * Single CPU early boot context.
+ *
+ * RETURNS:
+ * Pointer to the allocated memory on success, %NULL on failure.
+ */
 void *alloc_remap(int nid, unsigned long size)
 {
         void *allocation = node_remap_alloc_vaddr[nid];
 
         size = ALIGN(size, L1_CACHE_BYTES);
 
-        if (!allocation || (allocation + size) >= node_remap_end_vaddr[nid])
+        if (!allocation || (allocation + size) > node_remap_end_vaddr[nid])
                 return NULL;
 
         node_remap_alloc_vaddr[nid] += size;
@@ -209,26 +119,6 @@ void *alloc_remap(int nid, unsigned long size)
         return allocation;
 }
 
-static void __init remap_numa_kva(void)
-{
-        void *vaddr;
-        unsigned long pfn;
-        int node;
-
-        for_each_online_node(node) {
-                printk(KERN_DEBUG "remap_numa_kva: node %d\n", node);
-                for (pfn=0; pfn < node_remap_size[node]; pfn += PTRS_PER_PTE) {
-                        vaddr = node_remap_start_vaddr[node]+(pfn<<PAGE_SHIFT);
-                        printk(KERN_DEBUG "remap_numa_kva: %08lx to pfn %08lx\n",
-                                (unsigned long)vaddr,
-                                node_remap_start_pfn[node] + pfn);
-                        set_pmd_pfn((ulong) vaddr, 
-                                node_remap_start_pfn[node] + pfn, 
-                                PAGE_KERNEL_LARGE);
-                }
-        }
-}
-
 #ifdef CONFIG_HIBERNATION
 /**
  * resume_map_numa_kva - add KVA mapping to the temporary page tables created
@@ -240,15 +130,16 @@ void resume_map_numa_kva(pgd_t *pgd_base)
         int node;
 
         for_each_online_node(node) {
-                unsigned long start_va, start_pfn, size, pfn;
+                unsigned long start_va, start_pfn, nr_pages, pfn;
 
                 start_va = (unsigned long)node_remap_start_vaddr[node];
                 start_pfn = node_remap_start_pfn[node];
-                size = node_remap_size[node];
+                nr_pages = (node_remap_end_vaddr[node] -
+                            node_remap_start_vaddr[node]) >> PAGE_SHIFT;
 
                 printk(KERN_DEBUG "%s: node %d\n", __func__, node);
 
-                for (pfn = 0; pfn < size; pfn += PTRS_PER_PTE) {
+                for (pfn = 0; pfn < nr_pages; pfn += PTRS_PER_PTE) {
                         unsigned long vaddr = start_va + (pfn << PAGE_SHIFT);
                         pgd_t *pgd = pgd_base + pgd_index(vaddr);
                         pud_t *pud = pud_offset(pgd, vaddr);
@@ -264,132 +155,89 @@ void resume_map_numa_kva(pgd_t *pgd_base)
 }
 #endif
 
-static __init unsigned long calculate_numa_remap_pages(void)
+/**
+ * init_alloc_remap - Initialize remap allocator for a NUMA node
+ * @nid: NUMA node to initizlie remap allocator for
+ *
+ * NUMA nodes may end up without any lowmem.  As allocating pgdat and
+ * memmap on a different node with lowmem is inefficient, a special
+ * remap allocator is implemented which can be used by alloc_remap().
+ *
+ * For each node, the amount of memory which will be necessary for
+ * pgdat and memmap is calculated and two memory areas of the size are
+ * allocated - one in the node and the other in lowmem; then, the area
+ * in the node is remapped to the lowmem area.
+ *
+ * As pgdat and memmap must be allocated in lowmem anyway, this
+ * doesn't waste lowmem address space; however, the actual lowmem
+ * which gets remapped over is wasted.  The amount shouldn't be
+ * problematic on machines this feature will be used.
+ *
+ * Initialization failure isn't fatal.  alloc_remap() is used
+ * opportunistically and the callers will fall back to other memory
+ * allocation mechanisms on failure.
+ */
+void __init init_alloc_remap(int nid, u64 start, u64 end)
 {
-        int nid;
-        unsigned long size, reserve_pages = 0;
-
-        for_each_online_node(nid) {
-                u64 node_kva_target;
-                u64 node_kva_final;
-
-                /*
-                 * The acpi/srat node info can show hot-add memroy zones
-                 * where memory could be added but not currently present.
-                 */
-                printk(KERN_DEBUG "node %d pfn: [%lx - %lx]\n",
-                        nid, node_start_pfn[nid], node_end_pfn[nid]);
-                if (node_start_pfn[nid] > max_pfn)
-                        continue;
-                if (!node_end_pfn[nid])
-                        continue;
-                if (node_end_pfn[nid] > max_pfn)
-                        node_end_pfn[nid] = max_pfn;
-
-                /* ensure the remap includes space for the pgdat. */
-                size = node_remap_size[nid] + sizeof(pg_data_t);
-
-                /* convert size to large (pmd size) pages, rounding up */
-                size = (size + LARGE_PAGE_BYTES - 1) / LARGE_PAGE_BYTES;
-                /* now the roundup is correct, convert to PAGE_SIZE pages */
-                size = size * PTRS_PER_PTE;
-
-                node_kva_target = round_down(node_end_pfn[nid] - size,
-                                                 PTRS_PER_PTE);
-                node_kva_target <<= PAGE_SHIFT;
-                do {
-                        node_kva_final = memblock_find_in_range(node_kva_target,
-                                        ((u64)node_end_pfn[nid])<<PAGE_SHIFT,
-                                                ((u64)size)<<PAGE_SHIFT,
-                                                LARGE_PAGE_BYTES);
-                        node_kva_target -= LARGE_PAGE_BYTES;
-                } while (node_kva_final == MEMBLOCK_ERROR &&
-                         (node_kva_target>>PAGE_SHIFT) > (node_start_pfn[nid]));
-
-                if (node_kva_final == MEMBLOCK_ERROR)
-                        panic("Can not get kva ram\n");
-
-                node_remap_size[nid] = size;
-                node_remap_offset[nid] = reserve_pages;
-                reserve_pages += size;
-                printk(KERN_DEBUG "Reserving %ld pages of KVA for lmem_map of"
-                                  " node %d at %llx\n",
-                                size, nid, node_kva_final>>PAGE_SHIFT);
-
-                /*
-                 *  prevent kva address below max_low_pfn want it on system
-                 *  with less memory later.
-                 *  layout will be: KVA address , KVA RAM
-                 *
-                 *  we are supposed to only record the one less then max_low_pfn
-                 *  but we could have some hole in high memory, and it will only
-                 *  check page_is_ram(pfn) && !page_is_reserved_early(pfn) to decide
-                 *  to use it as free.
-                 *  So memblock_x86_reserve_range here, hope we don't run out of that array
-                 */
-                memblock_x86_reserve_range(node_kva_final,
-                              node_kva_final+(((u64)size)<<PAGE_SHIFT),
-                              "KVA RAM");
-
-                node_remap_start_pfn[nid] = node_kva_final>>PAGE_SHIFT;
-        }
-        printk(KERN_INFO "Reserving total of %lx pages for numa KVA remap\n",
-                        reserve_pages);
-        return reserve_pages;
-}
+        unsigned long start_pfn = start >> PAGE_SHIFT;
+        unsigned long end_pfn = end >> PAGE_SHIFT;
+        unsigned long size, pfn;
+        u64 node_pa, remap_pa;
+        void *remap_va;
 
-static void init_remap_allocator(int nid)
-{
-        node_remap_start_vaddr[nid] = pfn_to_kaddr(
-                        kva_start_pfn + node_remap_offset[nid]);
-        node_remap_end_vaddr[nid] = node_remap_start_vaddr[nid] +
-                (node_remap_size[nid] * PAGE_SIZE);
-        node_remap_alloc_vaddr[nid] = node_remap_start_vaddr[nid] +
-                ALIGN(sizeof(pg_data_t), PAGE_SIZE);
-
-        printk(KERN_DEBUG "node %d will remap to vaddr %08lx - %08lx\n", nid,
-                (ulong) node_remap_start_vaddr[nid],
-                (ulong) node_remap_end_vaddr[nid]);
+        /*
+         * The acpi/srat node info can show hot-add memroy zones where
+         * memory could be added but not currently present.
+         */
+        printk(KERN_DEBUG "node %d pfn: [%lx - %lx]\n",
+               nid, start_pfn, end_pfn);
+
+        /* calculate the necessary space aligned to large page size */
+        size = node_memmap_size_bytes(nid, start_pfn, end_pfn);
+        size += ALIGN(sizeof(pg_data_t), PAGE_SIZE);
+        size = ALIGN(size, LARGE_PAGE_BYTES);
+
+        /* allocate node memory and the lowmem remap area */
+        node_pa = memblock_find_in_range(start, end, size, LARGE_PAGE_BYTES);
+        if (node_pa == MEMBLOCK_ERROR) {
+                pr_warning("remap_alloc: failed to allocate %lu bytes for node %d\n",
+                           size, nid);
+                return;
+        }
+        memblock_x86_reserve_range(node_pa, node_pa + size, "KVA RAM");
+
+        remap_pa = memblock_find_in_range(min_low_pfn << PAGE_SHIFT,
+                                          max_low_pfn << PAGE_SHIFT,
+                                          size, LARGE_PAGE_BYTES);
+        if (remap_pa == MEMBLOCK_ERROR) {
+                pr_warning("remap_alloc: failed to allocate %lu bytes remap area for node %d\n",
+                           size, nid);
+                memblock_x86_free_range(node_pa, node_pa + size);
+                return;
+        }
+        memblock_x86_reserve_range(remap_pa, remap_pa + size, "KVA PG");
+        remap_va = phys_to_virt(remap_pa);
+
+        /* perform actual remap */
+        for (pfn = 0; pfn < size >> PAGE_SHIFT; pfn += PTRS_PER_PTE)
+                set_pmd_pfn((unsigned long)remap_va + (pfn << PAGE_SHIFT),
+                            (node_pa >> PAGE_SHIFT) + pfn,
+                            PAGE_KERNEL_LARGE);
+
+        /* initialize remap allocator parameters */
+        node_remap_start_pfn[nid] = node_pa >> PAGE_SHIFT;
+        node_remap_start_vaddr[nid] = remap_va;
+        node_remap_end_vaddr[nid] = remap_va + size;
+        node_remap_alloc_vaddr[nid] = remap_va;
+
+        printk(KERN_DEBUG "remap_alloc: node %d [%08llx-%08llx) -> [%p-%p)\n",
+               nid, node_pa, node_pa + size, remap_va, remap_va + size);
 }
 
 void __init initmem_init(void)
 {
-        int nid;
-        long kva_target_pfn;
-
-        /*
-         * When mapping a NUMA machine we allocate the node_mem_map arrays
-         * from node local memory.  They are then mapped directly into KVA
-         * between zone normal and vmalloc space.  Calculate the size of
-         * this space and use it to adjust the boundary between ZONE_NORMAL
-         * and ZONE_HIGHMEM.
-         */
-
-        get_memcfg_numa();
-        numa_init_array();
-
-        kva_pages = roundup(calculate_numa_remap_pages(), PTRS_PER_PTE);
+        x86_numa_init();
 
-        kva_target_pfn = round_down(max_low_pfn - kva_pages, PTRS_PER_PTE);
-        do {
-                kva_start_pfn = memblock_find_in_range(kva_target_pfn<<PAGE_SHIFT,
-                                        max_low_pfn<<PAGE_SHIFT,
-                                        kva_pages<<PAGE_SHIFT,
-                                        PTRS_PER_PTE<<PAGE_SHIFT) >> PAGE_SHIFT;
-                kva_target_pfn -= PTRS_PER_PTE;
-        } while (kva_start_pfn == MEMBLOCK_ERROR && kva_target_pfn > min_low_pfn);
-
-        if (kva_start_pfn == MEMBLOCK_ERROR)
-                panic("Can not get kva space\n");
-
-        printk(KERN_INFO "kva_start_pfn ~ %lx max_low_pfn ~ %lx\n",
-                kva_start_pfn, max_low_pfn);
-        printk(KERN_INFO "max_pfn = %lx\n", max_pfn);
-
-        /* avoid clash with initrd */
-        memblock_x86_reserve_range(kva_start_pfn<<PAGE_SHIFT,
-                      (kva_start_pfn + kva_pages)<<PAGE_SHIFT,
-                     "KVA PG");
 #ifdef CONFIG_HIGHMEM
         highstart_pfn = highend_pfn = max_pfn;
         if (max_pfn > max_low_pfn)
@@ -409,51 +257,9 @@ void __init initmem_init(void)
 
         printk(KERN_DEBUG "Low memory ends at vaddr %08lx\n",
                         (ulong) pfn_to_kaddr(max_low_pfn));
-        for_each_online_node(nid) {
-                init_remap_allocator(nid);
-
-                allocate_pgdat(nid);
-        }
-        remap_numa_kva();
 
         printk(KERN_DEBUG "High memory starts at vaddr %08lx\n",
                         (ulong) pfn_to_kaddr(highstart_pfn));
-        for_each_online_node(nid)
-                propagate_e820_map_node(nid);
-
-        for_each_online_node(nid) {
-                memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
-                NODE_DATA(nid)->node_id = nid;
-        }
 
         setup_bootmem_allocator();
 }
-
-#ifdef CONFIG_MEMORY_HOTPLUG
-static int paddr_to_nid(u64 addr)
-{
-        int nid;
-        unsigned long pfn = PFN_DOWN(addr);
-
-        for_each_node(nid)
-                if (node_start_pfn[nid] <= pfn &&
-                    pfn < node_end_pfn[nid])
-                        return nid;
-
-        return -1;
-}
-
-/*
- * This function is used to ask node id BEFORE memmap and mem_section's
- * initialization (pfn_to_nid() can't be used yet).
- * If _PXM is not defined on ACPI's DSDT, node id must be found by this.
- */
-int memory_add_physaddr_to_nid(u64 addr)
-{
-        int nid = paddr_to_nid(addr);
-        return (nid >= 0) ? nid : 0;
-}
-
-EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
-#endif
-
diff --git a/arch/x86/mm/numa_64.c b/arch/x86/mm/numa_64.c
index 85b52fc03084..dd27f401f0a0 100644
--- a/arch/x86/mm/numa_64.c
+++ b/arch/x86/mm/numa_64.c
@@ -2,646 +2,13 @@
  * Generic VM initialization for x86-64 NUMA setups.
  * Copyright 2002,2003 Andi Kleen, SuSE Labs.
  */
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/string.h>
-#include <linux/init.h>
 #include <linux/bootmem.h>
-#include <linux/memblock.h>
-#include <linux/mmzone.h>
-#include <linux/ctype.h>
-#include <linux/module.h>
-#include <linux/nodemask.h>
-#include <linux/sched.h>
-#include <linux/acpi.h>
-
-#include <asm/e820.h>
-#include <asm/proto.h>
-#include <asm/dma.h>
-#include <asm/acpi.h>
-#include <asm/amd_nb.h>
 
 #include "numa_internal.h"
 
-struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
-EXPORT_SYMBOL(node_data);
-
-nodemask_t numa_nodes_parsed __initdata;
-
-struct memnode memnode;
-
-static unsigned long __initdata nodemap_addr;
-static unsigned long __initdata nodemap_size;
-
-static struct numa_meminfo numa_meminfo __initdata;
-
-static int numa_distance_cnt;
-static u8 *numa_distance;
-
-/*
- * Given a shift value, try to populate memnodemap[]
- * Returns :
- * 1 if OK
- * 0 if memnodmap[] too small (of shift too small)
- * -1 if node overlap or lost ram (shift too big)
- */
-static int __init populate_memnodemap(const struct numa_meminfo *mi, int shift)
-{
-        unsigned long addr, end;
-        int i, res = -1;
-
-        memset(memnodemap, 0xff, sizeof(s16)*memnodemapsize);
-        for (i = 0; i < mi->nr_blks; i++) {
-                addr = mi->blk[i].start;
-                end = mi->blk[i].end;
-                if (addr >= end)
-                        continue;
-                if ((end >> shift) >= memnodemapsize)
-                        return 0;
-                do {
-                        if (memnodemap[addr >> shift] != NUMA_NO_NODE)
-                                return -1;
-                        memnodemap[addr >> shift] = mi->blk[i].nid;
-                        addr += (1UL << shift);
-                } while (addr < end);
-                res = 1;
-        }
-        return res;
-}
-
-static int __init allocate_cachealigned_memnodemap(void)
-{
-        unsigned long addr;
-
-        memnodemap = memnode.embedded_map;
-        if (memnodemapsize <= ARRAY_SIZE(memnode.embedded_map))
-                return 0;
-
-        addr = 0x8000;
-        nodemap_size = roundup(sizeof(s16) * memnodemapsize, L1_CACHE_BYTES);
-        nodemap_addr = memblock_find_in_range(addr, get_max_mapped(),
-                                      nodemap_size, L1_CACHE_BYTES);
-        if (nodemap_addr == MEMBLOCK_ERROR) {
-                printk(KERN_ERR
-                       "NUMA: Unable to allocate Memory to Node hash map\n");
-                nodemap_addr = nodemap_size = 0;
-                return -1;
-        }
-        memnodemap = phys_to_virt(nodemap_addr);
-        memblock_x86_reserve_range(nodemap_addr, nodemap_addr + nodemap_size, "MEMNODEMAP");
-
-        printk(KERN_DEBUG "NUMA: Allocated memnodemap from %lx - %lx\n",
-               nodemap_addr, nodemap_addr + nodemap_size);
-        return 0;
-}
-
-/*
- * The LSB of all start and end addresses in the node map is the value of the
- * maximum possible shift.
- */
-static int __init extract_lsb_from_nodes(const struct numa_meminfo *mi)
-{
-        int i, nodes_used = 0;
-        unsigned long start, end;
-        unsigned long bitfield = 0, memtop = 0;
-
-        for (i = 0; i < mi->nr_blks; i++) {
-                start = mi->blk[i].start;
-                end = mi->blk[i].end;
-                if (start >= end)
-                        continue;
-                bitfield |= start;
-                nodes_used++;
-                if (end > memtop)
-                        memtop = end;
-        }
-        if (nodes_used <= 1)
-                i = 63;
-        else
-                i = find_first_bit(&bitfield, sizeof(unsigned long)*8);
-        memnodemapsize = (memtop >> i)+1;
-        return i;
-}
-
-static int __init compute_hash_shift(const struct numa_meminfo *mi)
-{
-        int shift;
-
-        shift = extract_lsb_from_nodes(mi);
-        if (allocate_cachealigned_memnodemap())
-                return -1;
-        printk(KERN_DEBUG "NUMA: Using %d for the hash shift.\n",
-                shift);
-
-        if (populate_memnodemap(mi, shift) != 1) {
-                printk(KERN_INFO "Your memory is not aligned you need to "
-                       "rebuild your kernel with a bigger NODEMAPSIZE "
-                       "shift=%d\n", shift);
-                return -1;
-        }
-        return shift;
-}
-
-int __meminit  __early_pfn_to_nid(unsigned long pfn)
-{
-        return phys_to_nid(pfn << PAGE_SHIFT);
-}
-
-static void * __init early_node_mem(int nodeid, unsigned long start,
-                                    unsigned long end, unsigned long size,
-                                    unsigned long align)
-{
-        unsigned long mem;
-
-        /*
-         * put it on high as possible
-         * something will go with NODE_DATA
-         */
-        if (start < (MAX_DMA_PFN<<PAGE_SHIFT))
-                start = MAX_DMA_PFN<<PAGE_SHIFT;
-        if (start < (MAX_DMA32_PFN<<PAGE_SHIFT) &&
-            end > (MAX_DMA32_PFN<<PAGE_SHIFT))
-                start = MAX_DMA32_PFN<<PAGE_SHIFT;
-        mem = memblock_x86_find_in_range_node(nodeid, start, end, size, align);
-        if (mem != MEMBLOCK_ERROR)
-                return __va(mem);
-
-        /* extend the search scope */
-        end = max_pfn_mapped << PAGE_SHIFT;
-        start = MAX_DMA_PFN << PAGE_SHIFT;
-        mem = memblock_find_in_range(start, end, size, align);
-        if (mem != MEMBLOCK_ERROR)
-                return __va(mem);
-
-        printk(KERN_ERR "Cannot find %lu bytes in node %d\n",
-                       size, nodeid);
-
-        return NULL;
-}
-
-static int __init numa_add_memblk_to(int nid, u64 start, u64 end,
-                                     struct numa_meminfo *mi)
-{
-        /* ignore zero length blks */
-        if (start == end)
-                return 0;
-
-        /* whine about and ignore invalid blks */
-        if (start > end || nid < 0 || nid >= MAX_NUMNODES) {
-                pr_warning("NUMA: Warning: invalid memblk node %d (%Lx-%Lx)\n",
-                           nid, start, end);
-                return 0;
-        }
-
-        if (mi->nr_blks >= NR_NODE_MEMBLKS) {
-                pr_err("NUMA: too many memblk ranges\n");
-                return -EINVAL;
-        }
-
-        mi->blk[mi->nr_blks].start = start;
-        mi->blk[mi->nr_blks].end = end;
-        mi->blk[mi->nr_blks].nid = nid;
-        mi->nr_blks++;
-        return 0;
-}
-
-/**
- * numa_remove_memblk_from - Remove one numa_memblk from a numa_meminfo
- * @idx: Index of memblk to remove
- * @mi: numa_meminfo to remove memblk from
- *
- * Remove @idx'th numa_memblk from @mi by shifting @mi->blk[] and
- * decrementing @mi->nr_blks.
- */
-void __init numa_remove_memblk_from(int idx, struct numa_meminfo *mi)
-{
-        mi->nr_blks--;
-        memmove(&mi->blk[idx], &mi->blk[idx + 1],
-                (mi->nr_blks - idx) * sizeof(mi->blk[0]));
-}
-
-/**
- * numa_add_memblk - Add one numa_memblk to numa_meminfo
- * @nid: NUMA node ID of the new memblk
- * @start: Start address of the new memblk
- * @end: End address of the new memblk
- *
- * Add a new memblk to the default numa_meminfo.
- *
- * RETURNS:
- * 0 on success, -errno on failure.
- */
-int __init numa_add_memblk(int nid, u64 start, u64 end)
-{
-        return numa_add_memblk_to(nid, start, end, &numa_meminfo);
-}
-
-/* Initialize bootmem allocator for a node */
-void __init
-setup_node_bootmem(int nodeid, unsigned long start, unsigned long end)
-{
-        unsigned long start_pfn, last_pfn, nodedata_phys;
-        const int pgdat_size = roundup(sizeof(pg_data_t), PAGE_SIZE);
-        int nid;
-
-        if (!end)
-                return;
-
-        /*
-         * Don't confuse VM with a node that doesn't have the
-         * minimum amount of memory:
-         */
-        if (end && (end - start) < NODE_MIN_SIZE)
-                return;
-
-        start = roundup(start, ZONE_ALIGN);
-
-        printk(KERN_INFO "Initmem setup node %d %016lx-%016lx\n", nodeid,
-               start, end);
-
-        start_pfn = start >> PAGE_SHIFT;
-        last_pfn = end >> PAGE_SHIFT;
-
-        node_data[nodeid] = early_node_mem(nodeid, start, end, pgdat_size,
-                                           SMP_CACHE_BYTES);
-        if (node_data[nodeid] == NULL)
-                return;
-        nodedata_phys = __pa(node_data[nodeid]);
-        memblock_x86_reserve_range(nodedata_phys, nodedata_phys + pgdat_size, "NODE_DATA");
-        printk(KERN_INFO "  NODE_DATA [%016lx - %016lx]\n", nodedata_phys,
-                nodedata_phys + pgdat_size - 1);
-        nid = phys_to_nid(nodedata_phys);
-        if (nid != nodeid)
-                printk(KERN_INFO "    NODE_DATA(%d) on node %d\n", nodeid, nid);
-
-        memset(NODE_DATA(nodeid), 0, sizeof(pg_data_t));
-        NODE_DATA(nodeid)->node_id = nodeid;
-        NODE_DATA(nodeid)->node_start_pfn = start_pfn;
-        NODE_DATA(nodeid)->node_spanned_pages = last_pfn - start_pfn;
-
-        node_set_online(nodeid);
-}
-
-/**
- * numa_cleanup_meminfo - Cleanup a numa_meminfo
- * @mi: numa_meminfo to clean up
- *
- * Sanitize @mi by merging and removing unncessary memblks.  Also check for
- * conflicts and clear unused memblks.
- *
- * RETURNS:
- * 0 on success, -errno on failure.
- */
-int __init numa_cleanup_meminfo(struct numa_meminfo *mi)
-{
-        const u64 low = 0;
-        const u64 high = (u64)max_pfn << PAGE_SHIFT;
-        int i, j, k;
-
-        for (i = 0; i < mi->nr_blks; i++) {
-                struct numa_memblk *bi = &mi->blk[i];
-
-                /* make sure all blocks are inside the limits */
-                bi->start = max(bi->start, low);
-                bi->end = min(bi->end, high);
-
-                /* and there's no empty block */
-                if (bi->start >= bi->end) {
-                        numa_remove_memblk_from(i--, mi);
-                        continue;
-                }
-
-                for (j = i + 1; j < mi->nr_blks; j++) {
-                        struct numa_memblk *bj = &mi->blk[j];
-                        unsigned long start, end;
-
-                        /*
-                         * See whether there are overlapping blocks.  Whine
-                         * about but allow overlaps of the same nid.  They
-                         * will be merged below.
-                         */
-                        if (bi->end > bj->start && bi->start < bj->end) {
-                                if (bi->nid != bj->nid) {
-                                        pr_err("NUMA: node %d (%Lx-%Lx) overlaps with node %d (%Lx-%Lx)\n",
-                                               bi->nid, bi->start, bi->end,
-                                               bj->nid, bj->start, bj->end);
-                                        return -EINVAL;
-                                }
-                                pr_warning("NUMA: Warning: node %d (%Lx-%Lx) overlaps with itself (%Lx-%Lx)\n",
-                                           bi->nid, bi->start, bi->end,
-                                           bj->start, bj->end);
-                        }
-
-                        /*
-                         * Join together blocks on the same node, holes
-                         * between which don't overlap with memory on other
-                         * nodes.
-                         */
-                        if (bi->nid != bj->nid)
-                                continue;
-                        start = max(min(bi->start, bj->start), low);
-                        end = min(max(bi->end, bj->end), high);
-                        for (k = 0; k < mi->nr_blks; k++) {
-                                struct numa_memblk *bk = &mi->blk[k];
-
-                                if (bi->nid == bk->nid)
-                                        continue;
-                                if (start < bk->end && end > bk->start)
-                                        break;
-                        }
-                        if (k < mi->nr_blks)
-                                continue;
-                        printk(KERN_INFO "NUMA: Node %d [%Lx,%Lx) + [%Lx,%Lx) -> [%lx,%lx)\n",
-                               bi->nid, bi->start, bi->end, bj->start, bj->end,
-                               start, end);
-                        bi->start = start;
-                        bi->end = end;
-                        numa_remove_memblk_from(j--, mi);
-                }
-        }
-
-        for (i = mi->nr_blks; i < ARRAY_SIZE(mi->blk); i++) {
-                mi->blk[i].start = mi->blk[i].end = 0;
-                mi->blk[i].nid = NUMA_NO_NODE;
-        }
-
-        return 0;
-}
-
-/*
- * Set nodes, which have memory in @mi, in *@nodemask.
- */
-static void __init numa_nodemask_from_meminfo(nodemask_t *nodemask,
-                                              const struct numa_meminfo *mi)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(mi->blk); i++)
-                if (mi->blk[i].start != mi->blk[i].end &&
-                    mi->blk[i].nid != NUMA_NO_NODE)
-                        node_set(mi->blk[i].nid, *nodemask);
-}
-
-/**
- * numa_reset_distance - Reset NUMA distance table
- *
- * The current table is freed.  The next numa_set_distance() call will
- * create a new one.
- */
-void __init numa_reset_distance(void)
-{
-        size_t size = numa_distance_cnt * numa_distance_cnt * sizeof(numa_distance[0]);
-
-        /* numa_distance could be 1LU marking allocation failure, test cnt */
-        if (numa_distance_cnt)
-                memblock_x86_free_range(__pa(numa_distance),
-                                        __pa(numa_distance) + size);
-        numa_distance_cnt = 0;
-        numa_distance = NULL;   /* enable table creation */
-}
-
-static int __init numa_alloc_distance(void)
-{
-        nodemask_t nodes_parsed;
-        size_t size;
-        int i, j, cnt = 0;
-        u64 phys;
-
-        /* size the new table and allocate it */
-        nodes_parsed = numa_nodes_parsed;
-        numa_nodemask_from_meminfo(&nodes_parsed, &numa_meminfo);
-
-        for_each_node_mask(i, nodes_parsed)
-                cnt = i;
-        cnt++;
-        size = cnt * cnt * sizeof(numa_distance[0]);
-
-        phys = memblock_find_in_range(0, (u64)max_pfn_mapped << PAGE_SHIFT,
-                                      size, PAGE_SIZE);
-        if (phys == MEMBLOCK_ERROR) {
-                pr_warning("NUMA: Warning: can't allocate distance table!\n");
-                /* don't retry until explicitly reset */
-                numa_distance = (void *)1LU;
-                return -ENOMEM;
-        }
-        memblock_x86_reserve_range(phys, phys + size, "NUMA DIST");
-
-        numa_distance = __va(phys);
-        numa_distance_cnt = cnt;
-
-        /* fill with the default distances */
-        for (i = 0; i < cnt; i++)
-                for (j = 0; j < cnt; j++)
-                        numa_distance[i * cnt + j] = i == j ?
-                                LOCAL_DISTANCE : REMOTE_DISTANCE;
-        printk(KERN_DEBUG "NUMA: Initialized distance table, cnt=%d\n", cnt);
-
-        return 0;
-}
-
-/**
- * numa_set_distance - Set NUMA distance from one NUMA to another
- * @from: the 'from' node to set distance
- * @to: the 'to'  node to set distance
- * @distance: NUMA distance
- *
- * Set the distance from node @from to @to to @distance.  If distance table
- * doesn't exist, one which is large enough to accommodate all the currently
- * known nodes will be created.
- *
- * If such table cannot be allocated, a warning is printed and further
- * calls are ignored until the distance table is reset with
- * numa_reset_distance().
- *
- * If @from or @to is higher than the highest known node at the time of
- * table creation or @distance doesn't make sense, the call is ignored.
- * This is to allow simplification of specific NUMA config implementations.
- */
-void __init numa_set_distance(int from, int to, int distance)
-{
-        if (!numa_distance && numa_alloc_distance() < 0)
-                return;
-
-        if (from >= numa_distance_cnt || to >= numa_distance_cnt) {
-                printk_once(KERN_DEBUG "NUMA: Debug: distance out of bound, from=%d to=%d distance=%d\n",
-                            from, to, distance);
-                return;
-        }
-
-        if ((u8)distance != distance ||
-            (from == to && distance != LOCAL_DISTANCE)) {
-                pr_warn_once("NUMA: Warning: invalid distance parameter, from=%d to=%d distance=%d\n",
-                             from, to, distance);
-                return;
-        }
-
-        numa_distance[from * numa_distance_cnt + to] = distance;
-}
-
-int __node_distance(int from, int to)
-{
-        if (from >= numa_distance_cnt || to >= numa_distance_cnt)
-                return from == to ? LOCAL_DISTANCE : REMOTE_DISTANCE;
-        return numa_distance[from * numa_distance_cnt + to];
-}
-EXPORT_SYMBOL(__node_distance);
-
-/*
- * Sanity check to catch more bad NUMA configurations (they are amazingly
- * common).  Make sure the nodes cover all memory.
- */
-static bool __init numa_meminfo_cover_memory(const struct numa_meminfo *mi)
-{
-        unsigned long numaram, e820ram;
-        int i;
-
-        numaram = 0;
-        for (i = 0; i < mi->nr_blks; i++) {
-                unsigned long s = mi->blk[i].start >> PAGE_SHIFT;
-                unsigned long e = mi->blk[i].end >> PAGE_SHIFT;
-                numaram += e - s;
-                numaram -= __absent_pages_in_range(mi->blk[i].nid, s, e);
-                if ((long)numaram < 0)
-                        numaram = 0;
-        }
-
-        e820ram = max_pfn - (memblock_x86_hole_size(0,
-                                        max_pfn << PAGE_SHIFT) >> PAGE_SHIFT);
-        /* We seem to lose 3 pages somewhere. Allow 1M of slack. */
-        if ((long)(e820ram - numaram) >= (1 << (20 - PAGE_SHIFT))) {
-                printk(KERN_ERR "NUMA: nodes only cover %luMB of your %luMB e820 RAM. Not used.\n",
-                       (numaram << PAGE_SHIFT) >> 20,
-                       (e820ram << PAGE_SHIFT) >> 20);
-                return false;
-        }
-        return true;
-}
-
-static int __init numa_register_memblks(struct numa_meminfo *mi)
-{
-        int i, nid;
-
-        /* Account for nodes with cpus and no memory */
-        node_possible_map = numa_nodes_parsed;
-        numa_nodemask_from_meminfo(&node_possible_map, mi);
-        if (WARN_ON(nodes_empty(node_possible_map)))
-                return -EINVAL;
-
-        memnode_shift = compute_hash_shift(mi);
-        if (memnode_shift < 0) {
-                printk(KERN_ERR "NUMA: No NUMA node hash function found. Contact maintainer\n");
-                return -EINVAL;
-        }
-
-        for (i = 0; i < mi->nr_blks; i++)
-                memblock_x86_register_active_regions(mi->blk[i].nid,
-                                        mi->blk[i].start >> PAGE_SHIFT,
-                                        mi->blk[i].end >> PAGE_SHIFT);
-
-        /* for out of order entries */
-        sort_node_map();
-        if (!numa_meminfo_cover_memory(mi))
-                return -EINVAL;
-
-        /* Finally register nodes. */
-        for_each_node_mask(nid, node_possible_map) {
-                u64 start = (u64)max_pfn << PAGE_SHIFT;
-                u64 end = 0;
-
-                for (i = 0; i < mi->nr_blks; i++) {
-                        if (nid != mi->blk[i].nid)
-                                continue;
-                        start = min(mi->blk[i].start, start);
-                        end = max(mi->blk[i].end, end);
-                }
-
-                if (start < end)
-                        setup_node_bootmem(nid, start, end);
-        }
-
-        return 0;
-}
-
-/**
- * dummy_numma_init - Fallback dummy NUMA init
- *
- * Used if there's no underlying NUMA architecture, NUMA initialization
- * fails, or NUMA is disabled on the command line.
- *
- * Must online at least one node and add memory blocks that cover all
- * allowed memory.  This function must not fail.
- */
-static int __init dummy_numa_init(void)
-{
-        printk(KERN_INFO "%s\n",
-               numa_off ? "NUMA turned off" : "No NUMA configuration found");
-        printk(KERN_INFO "Faking a node at %016lx-%016lx\n",
-               0LU, max_pfn << PAGE_SHIFT);
-
-        node_set(0, numa_nodes_parsed);
-        numa_add_memblk(0, 0, (u64)max_pfn << PAGE_SHIFT);
-
-        return 0;
-}
-
-static int __init numa_init(int (*init_func)(void))
-{
-        int i;
-        int ret;
-
-        for (i = 0; i < MAX_LOCAL_APIC; i++)
-                set_apicid_to_node(i, NUMA_NO_NODE);
-
-        nodes_clear(numa_nodes_parsed);
-        nodes_clear(node_possible_map);
-        nodes_clear(node_online_map);
-        memset(&numa_meminfo, 0, sizeof(numa_meminfo));
-        remove_all_active_ranges();
-        numa_reset_distance();
-
-        ret = init_func();
-        if (ret < 0)
-                return ret;
-        ret = numa_cleanup_meminfo(&numa_meminfo);
-        if (ret < 0)
-                return ret;
-
-        numa_emulation(&numa_meminfo, numa_distance_cnt);
-
-        ret = numa_register_memblks(&numa_meminfo);
-        if (ret < 0)
-                return ret;
-
-        for (i = 0; i < nr_cpu_ids; i++) {
-                int nid = early_cpu_to_node(i);
-
-                if (nid == NUMA_NO_NODE)
-                        continue;
-                if (!node_online(nid))
-                        numa_clear_node(i);
-        }
-        numa_init_array();
-        return 0;
-}
-
 void __init initmem_init(void)
 {
-        int ret;
-
-        if (!numa_off) {
-#ifdef CONFIG_ACPI_NUMA
-                ret = numa_init(x86_acpi_numa_init);
-                if (!ret)
-                        return;
-#endif
-#ifdef CONFIG_AMD_NUMA
-                ret = numa_init(amd_numa_init);
-                if (!ret)
-                        return;
-#endif
-        }
-
-        numa_init(dummy_numa_init);
+        x86_numa_init();
 }
 
 unsigned long __init numa_free_all_bootmem(void)
@@ -656,12 +23,3 @@ unsigned long __init numa_free_all_bootmem(void)
 
         return pages;
 }
-
-int __cpuinit numa_cpu_node(int cpu)
-{
-        int apicid = early_per_cpu(x86_cpu_to_apicid, cpu);
-
-        if (apicid != BAD_APICID)
-                return __apicid_to_node[apicid];
-        return NUMA_NO_NODE;
-}
diff --git a/arch/x86/mm/numa_emulation.c b/arch/x86/mm/numa_emulation.c
index de84cc140379..d0ed086b6247 100644
--- a/arch/x86/mm/numa_emulation.c
+++ b/arch/x86/mm/numa_emulation.c
@@ -5,6 +5,7 @@
 #include <linux/errno.h>
 #include <linux/topology.h>
 #include <linux/memblock.h>
+#include <linux/bootmem.h>
 #include <asm/dma.h>
 
 #include "numa_internal.h"
@@ -84,7 +85,13 @@ static int __init split_nodes_interleave(struct numa_meminfo *ei,
                 nr_nodes = MAX_NUMNODES;
         }
 
-        size = (max_addr - addr - memblock_x86_hole_size(addr, max_addr)) / nr_nodes;
+        /*
+         * Calculate target node size.  x86_32 freaks on __udivdi3() so do
+         * the division in ulong number of pages and convert back.
+         */
+        size = max_addr - addr - memblock_x86_hole_size(addr, max_addr);
+        size = PFN_PHYS((unsigned long)(size >> PAGE_SHIFT) / nr_nodes);
+
         /*
          * Calculate the number of big nodes that can be allocated as a result
          * of consolidating the remainder.
@@ -226,7 +233,7 @@ static int __init split_nodes_size_interleave(struct numa_meminfo *ei,
          */
         while (nodes_weight(physnode_mask)) {
                 for_each_node_mask(i, physnode_mask) {
-                        u64 dma32_end = MAX_DMA32_PFN << PAGE_SHIFT;
+                        u64 dma32_end = PFN_PHYS(MAX_DMA32_PFN);
                         u64 start, limit, end;
                         int phys_blk;
 
@@ -298,7 +305,7 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
 {
         static struct numa_meminfo ei __initdata;
         static struct numa_meminfo pi __initdata;
-        const u64 max_addr = max_pfn << PAGE_SHIFT;
+        const u64 max_addr = PFN_PHYS(max_pfn);
         u8 *phys_dist = NULL;
         size_t phys_size = numa_dist_cnt * numa_dist_cnt * sizeof(phys_dist[0]);
         int max_emu_nid, dfl_phys_nid;
@@ -342,8 +349,7 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
         if (numa_dist_cnt) {
                 u64 phys;
 
-                phys = memblock_find_in_range(0,
-                                              (u64)max_pfn_mapped << PAGE_SHIFT,
+                phys = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped),
                                               phys_size, PAGE_SIZE);
                 if (phys == MEMBLOCK_ERROR) {
                         pr_warning("NUMA: Warning: can't allocate copy of distance table, disabling emulation\n");
diff --git a/arch/x86/mm/numa_internal.h b/arch/x86/mm/numa_internal.h
index ef2d97377d7c..7178c3afe05e 100644
--- a/arch/x86/mm/numa_internal.h
+++ b/arch/x86/mm/numa_internal.h
@@ -19,6 +19,14 @@ void __init numa_remove_memblk_from(int idx, struct numa_meminfo *mi);
 int __init numa_cleanup_meminfo(struct numa_meminfo *mi);
 void __init numa_reset_distance(void);
 
+void __init x86_numa_init(void);
+
+#ifdef CONFIG_X86_64
+static inline void init_alloc_remap(int nid, u64 start, u64 end)        { }
+#else
+void __init init_alloc_remap(int nid, u64 start, u64 end);
+#endif
+
 #ifdef CONFIG_NUMA_EMU
 void __init numa_emulation(struct numa_meminfo *numa_meminfo,
                            int numa_dist_cnt);
diff --git a/arch/x86/mm/srat_64.c b/arch/x86/mm/srat.c
index 8e9d3394f6d4..81dbfdeb080d 100644
--- a/arch/x86/mm/srat_64.c
+++ b/arch/x86/mm/srat.c
@@ -26,8 +26,6 @@
 
 int acpi_numa __initdata;
 
-static struct bootnode nodes_add[MAX_NUMNODES];
-
 static __init int setup_node(int pxm)
 {
         return acpi_map_pxm_to_node(pxm);
@@ -37,7 +35,6 @@ static __init void bad_srat(void)
 {
         printk(KERN_ERR "SRAT: SRAT not used.\n");
         acpi_numa = -1;
-        memset(nodes_add, 0, sizeof(nodes_add));
 }
 
 static __init inline int srat_disabled(void)
@@ -131,73 +128,17 @@ acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
                pxm, apic_id, node);
 }
 
-#ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
+#ifdef CONFIG_MEMORY_HOTPLUG
 static inline int save_add_info(void) {return 1;}
 #else
 static inline int save_add_info(void) {return 0;}
 #endif
-/*
- * Update nodes_add[]
- * This code supports one contiguous hot add area per node
- */
-static void __init
-update_nodes_add(int node, unsigned long start, unsigned long end)
-{
-        unsigned long s_pfn = start >> PAGE_SHIFT;
-        unsigned long e_pfn = end >> PAGE_SHIFT;
-        int changed = 0;
-        struct bootnode *nd = &nodes_add[node];
-
-        /* I had some trouble with strange memory hotadd regions breaking
-           the boot. Be very strict here and reject anything unexpected.
-           If you want working memory hotadd write correct SRATs.
-
-           The node size check is a basic sanity check to guard against
-           mistakes */
-        if ((signed long)(end - start) < NODE_MIN_SIZE) {
-                printk(KERN_ERR "SRAT: Hotplug area too small\n");
-                return;
-        }
-
-        /* This check might be a bit too strict, but I'm keeping it for now. */
-        if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
-                printk(KERN_ERR
-                        "SRAT: Hotplug area %lu -> %lu has existing memory\n",
-                        s_pfn, e_pfn);
-                return;
-        }
-
-        /* Looks good */
-
-        if (nd->start == nd->end) {
-                nd->start = start;
-                nd->end = end;
-                changed = 1;
-        } else {
-                if (nd->start == end) {
-                        nd->start = start;
-                        changed = 1;
-                }
-                if (nd->end == start) {
-                        nd->end = end;
-                        changed = 1;
-                }
-                if (!changed)
-                        printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
-        }
-
-        if (changed) {
-                node_set(node, numa_nodes_parsed);
-                printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n",
-                                 nd->start, nd->end);
-        }
-}
 
 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
 void __init
 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 {
-        unsigned long start, end;
+        u64 start, end;
         int node, pxm;
 
         if (srat_disabled())
@@ -226,11 +167,8 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
                 return;
         }
 
-        printk(KERN_INFO "SRAT: Node %u PXM %u %lx-%lx\n", node, pxm,
+        printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
                start, end);
-
-        if (ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE)
-                update_nodes_add(node, start, end);
 }
 
 void __init acpi_numa_arch_fixup(void) {}
@@ -244,17 +182,3 @@ int __init x86_acpi_numa_init(void)
                 return ret;
         return srat_disabled() ? -EINVAL : 0;
 }
-
-#if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) || defined(CONFIG_ACPI_HOTPLUG_MEMORY)
-int memory_add_physaddr_to_nid(u64 start)
-{
-        int i, ret = 0;
-
-        for_each_node(i)
-                if (nodes_add[i].start <= start && nodes_add[i].end > start)
-                        ret = i;
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
-#endif
diff --git a/arch/x86/mm/srat_32.c b/arch/x86/mm/srat_32.c
deleted file mode 100644
index 364f36bdfad8..000000000000
--- a/arch/x86/mm/srat_32.c
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * Some of the code in this file has been gleaned from the 64 bit 
- * discontigmem support code base.
- *
- * Copyright (C) 2002, IBM Corp.
- *
- * All rights reserved.          
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * Send feedback to Pat Gaughen <gone@us.ibm.com>
- */
-#include <linux/mm.h>
-#include <linux/bootmem.h>
-#include <linux/memblock.h>
-#include <linux/mmzone.h>
-#include <linux/acpi.h>
-#include <linux/nodemask.h>
-#include <asm/srat.h>
-#include <asm/topology.h>
-#include <asm/smp.h>
-#include <asm/e820.h>
-
-/*
- * proximity macros and definitions
- */
-#define NODE_ARRAY_INDEX(x)     ((x) / 8)       /* 8 bits/char */
-#define NODE_ARRAY_OFFSET(x)    ((x) % 8)       /* 8 bits/char */
-#define BMAP_SET(bmap, bit)     ((bmap)[NODE_ARRAY_INDEX(bit)] |= 1 << NODE_ARRAY_OFFSET(bit))
-#define BMAP_TEST(bmap, bit)    ((bmap)[NODE_ARRAY_INDEX(bit)] & (1 << NODE_ARRAY_OFFSET(bit)))
-/* bitmap length; _PXM is at most 255 */
-#define PXM_BITMAP_LEN (MAX_PXM_DOMAINS / 8) 
-static u8 __initdata pxm_bitmap[PXM_BITMAP_LEN];        /* bitmap of proximity domains */
-
-#define MAX_CHUNKS_PER_NODE     3
-#define MAXCHUNKS               (MAX_CHUNKS_PER_NODE * MAX_NUMNODES)
-struct node_memory_chunk_s {
-        unsigned long   start_pfn;
-        unsigned long   end_pfn;
-        u8      pxm;            // proximity domain of node
-        u8      nid;            // which cnode contains this chunk?
-        u8      bank;           // which mem bank on this node
-};
-static struct node_memory_chunk_s __initdata node_memory_chunk[MAXCHUNKS];
-
-static int __initdata num_memory_chunks; /* total number of memory chunks */
-static u8 __initdata apicid_to_pxm[MAX_LOCAL_APIC];
-
-int acpi_numa __initdata;
-
-static __init void bad_srat(void)
-{
-        printk(KERN_ERR "SRAT: SRAT not used.\n");
-        acpi_numa = -1;
-        num_memory_chunks = 0;
-}
-
-static __init inline int srat_disabled(void)
-{
-        return numa_off || acpi_numa < 0;
-}
-
-/* Identify CPU proximity domains */
-void __init
-acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *cpu_affinity)
-{
-        if (srat_disabled())
-                return;
-        if (cpu_affinity->header.length !=
-             sizeof(struct acpi_srat_cpu_affinity)) {
-                bad_srat();
-                return;
-        }
-
-        if ((cpu_affinity->flags & ACPI_SRAT_CPU_ENABLED) == 0)
-                return;         /* empty entry */
-
-        /* mark this node as "seen" in node bitmap */
-        BMAP_SET(pxm_bitmap, cpu_affinity->proximity_domain_lo);
-
-        /* don't need to check apic_id here, because it is always 8 bits */
-        apicid_to_pxm[cpu_affinity->apic_id] = cpu_affinity->proximity_domain_lo;
-
-        printk(KERN_DEBUG "CPU %02x in proximity domain %02x\n",
-                cpu_affinity->apic_id, cpu_affinity->proximity_domain_lo);
-}
-
-/*
- * Identify memory proximity domains and hot-remove capabilities.
- * Fill node memory chunk list structure.
- */
-void __init
-acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *memory_affinity)
-{
-        unsigned long long paddr, size;
-        unsigned long start_pfn, end_pfn;
-        u8 pxm;
-        struct node_memory_chunk_s *p, *q, *pend;
-
-        if (srat_disabled())
-                return;
-        if (memory_affinity->header.length !=
-             sizeof(struct acpi_srat_mem_affinity)) {
-                bad_srat();
-                return;
-        }
-
-        if ((memory_affinity->flags & ACPI_SRAT_MEM_ENABLED) == 0)
-                return;         /* empty entry */
-
-        pxm = memory_affinity->proximity_domain & 0xff;
-
-        /* mark this node as "seen" in node bitmap */
-        BMAP_SET(pxm_bitmap, pxm);
-
-        /* calculate info for memory chunk structure */
-        paddr = memory_affinity->base_address;
-        size = memory_affinity->length;
-
-        start_pfn = paddr >> PAGE_SHIFT;
-        end_pfn = (paddr + size) >> PAGE_SHIFT;
-
-
-        if (num_memory_chunks >= MAXCHUNKS) {
-                printk(KERN_WARNING "Too many mem chunks in SRAT."
-                        " Ignoring %lld MBytes at %llx\n",
-                        size/(1024*1024), paddr);
-                return;
-        }
-
-        /* Insertion sort based on base address */
-        pend = &node_memory_chunk[num_memory_chunks];
-        for (p = &node_memory_chunk[0]; p < pend; p++) {
-                if (start_pfn < p->start_pfn)
-                        break;
-        }
-        if (p < pend) {
-                for (q = pend; q >= p; q--)
-                        *(q + 1) = *q;
-        }
-        p->start_pfn = start_pfn;
-        p->end_pfn = end_pfn;
-        p->pxm = pxm;
-
-        num_memory_chunks++;
-
-        printk(KERN_DEBUG "Memory range %08lx to %08lx"
-                          " in proximity domain %02x %s\n",
-                start_pfn, end_pfn,
-                pxm,
-                ((memory_affinity->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) ?
-                 "enabled and removable" : "enabled" ) );
-}
-
-/* Callback for SLIT parsing */
-void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
-{
-}
-
-void acpi_numa_arch_fixup(void)
-{
-}
-/*
- * The SRAT table always lists ascending addresses, so can always
- * assume that the first "start" address that you see is the real
- * start of the node, and that the current "end" address is after
- * the previous one.
- */
-static __init int node_read_chunk(int nid, struct node_memory_chunk_s *memory_chunk)
-{
-        /*
-         * Only add present memory as told by the e820.
-         * There is no guarantee from the SRAT that the memory it
-         * enumerates is present at boot time because it represents
-         * *possible* memory hotplug areas the same as normal RAM.
-         */
-        if (memory_chunk->start_pfn >= max_pfn) {
-                printk(KERN_INFO "Ignoring SRAT pfns: %08lx - %08lx\n",
-                        memory_chunk->start_pfn, memory_chunk->end_pfn);
-                return -1;
-        }
-        if (memory_chunk->nid != nid)
-                return -1;
-
-        if (!node_has_online_mem(nid))
-                node_start_pfn[nid] = memory_chunk->start_pfn;
-
-        if (node_start_pfn[nid] > memory_chunk->start_pfn)
-                node_start_pfn[nid] = memory_chunk->start_pfn;
-
-        if (node_end_pfn[nid] < memory_chunk->end_pfn)
-                node_end_pfn[nid] = memory_chunk->end_pfn;
-
-        return 0;
-}
-
-int __init get_memcfg_from_srat(void)
-{
-        int i, j, nid;
-
-        if (srat_disabled())
-                goto out_fail;
-
-        if (acpi_numa_init() < 0)
-                goto out_fail;
-
-        if (num_memory_chunks == 0) {
-                printk(KERN_DEBUG
-                         "could not find any ACPI SRAT memory areas.\n");
-                goto out_fail;
-        }
-
-        /* Calculate total number of nodes in system from PXM bitmap and create
-         * a set of sequential node IDs starting at zero.  (ACPI doesn't seem
-         * to specify the range of _PXM values.)
-         */
-        /*
-         * MCD - we no longer HAVE to number nodes sequentially.  PXM domain
-         * numbers could go as high as 256, and MAX_NUMNODES for i386 is typically
-         * 32, so we will continue numbering them in this manner until MAX_NUMNODES
-         * approaches MAX_PXM_DOMAINS for i386.
-         */
-        nodes_clear(node_online_map);
-        for (i = 0; i < MAX_PXM_DOMAINS; i++) {
-                if (BMAP_TEST(pxm_bitmap, i)) {
-                        int nid = acpi_map_pxm_to_node(i);
-                        node_set_online(nid);
-                }
-        }
-        BUG_ON(num_online_nodes() == 0);
-
-        /* set cnode id in memory chunk structure */
-        for (i = 0; i < num_memory_chunks; i++)
-                node_memory_chunk[i].nid = pxm_to_node(node_memory_chunk[i].pxm);
-
-        printk(KERN_DEBUG "pxm bitmap: ");
-        for (i = 0; i < sizeof(pxm_bitmap); i++) {
-                printk(KERN_CONT "%02x ", pxm_bitmap[i]);
-        }
-        printk(KERN_CONT "\n");
-        printk(KERN_DEBUG "Number of logical nodes in system = %d\n",
-                         num_online_nodes());
-        printk(KERN_DEBUG "Number of memory chunks in system = %d\n",
-                         num_memory_chunks);
-
-        for (i = 0; i < MAX_LOCAL_APIC; i++)
-                set_apicid_to_node(i, pxm_to_node(apicid_to_pxm[i]));
-
-        for (j = 0; j < num_memory_chunks; j++){
-                struct node_memory_chunk_s * chunk = &node_memory_chunk[j];
-                printk(KERN_DEBUG
-                        "chunk %d nid %d start_pfn %08lx end_pfn %08lx\n",
-                       j, chunk->nid, chunk->start_pfn, chunk->end_pfn);
-                if (node_read_chunk(chunk->nid, chunk))
-                        continue;
-
-                memblock_x86_register_active_regions(chunk->nid, chunk->start_pfn,
-                                             min(chunk->end_pfn, max_pfn));
-        }
-        /* for out of order entries in SRAT */
-        sort_node_map();
-
-        for_each_online_node(nid) {
-                unsigned long start = node_start_pfn[nid];
-                unsigned long end = min(node_end_pfn[nid], max_pfn);
-
-                memory_present(nid, start, end);
-                node_remap_size[nid] = node_memmap_size_bytes(nid, start, end);
-        }
-        return 1;
-out_fail:
-        printk(KERN_DEBUG "failed to get NUMA memory information from SRAT"
-                        " table\n");
-        return 0;
-}
diff --git a/arch/x86/net/Makefile b/arch/x86/net/Makefile
new file mode 100644
index 000000000000..90568c33ddb0
--- /dev/null
+++ b/arch/x86/net/Makefile
@@ -0,0 +1,4 @@
+#
+# Arch-specific network modules
+#
+obj-$(CONFIG_BPF_JIT) += bpf_jit.o bpf_jit_comp.o
diff --git a/arch/x86/net/bpf_jit.S b/arch/x86/net/bpf_jit.S
new file mode 100644
index 000000000000..66870223f8c5
--- /dev/null
+++ b/arch/x86/net/bpf_jit.S
@@ -0,0 +1,140 @@
+/* bpf_jit.S : BPF JIT helper functions
+ *
+ * Copyright (C) 2011 Eric Dumazet (eric.dumazet@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ */
+#include <linux/linkage.h>
+#include <asm/dwarf2.h>
+
+/*
+ * Calling convention :
+ * rdi : skb pointer
+ * esi : offset of byte(s) to fetch in skb (can be scratched)
+ * r8  : copy of skb->data
+ * r9d : hlen = skb->len - skb->data_len
+ */
+#define SKBDATA %r8
+
+sk_load_word_ind:
+        .globl  sk_load_word_ind
+
+        add     %ebx,%esi       /* offset += X */
+#       test    %esi,%esi       /* if (offset < 0) goto bpf_error; */
+        js      bpf_error
+
+sk_load_word:
+        .globl  sk_load_word
+
+        mov     %r9d,%eax               # hlen
+        sub     %esi,%eax               # hlen - offset
+        cmp     $3,%eax
+        jle     bpf_slow_path_word
+        mov     (SKBDATA,%rsi),%eax
+        bswap   %eax                    /* ntohl() */
+        ret
+
+
+sk_load_half_ind:
+        .globl sk_load_half_ind
+
+        add     %ebx,%esi       /* offset += X */
+        js      bpf_error
+
+sk_load_half:
+        .globl  sk_load_half
+
+        mov     %r9d,%eax
+        sub     %esi,%eax               #       hlen - offset
+        cmp     $1,%eax
+        jle     bpf_slow_path_half
+        movzwl  (SKBDATA,%rsi),%eax
+        rol     $8,%ax                  # ntohs()
+        ret
+
+sk_load_byte_ind:
+        .globl sk_load_byte_ind
+        add     %ebx,%esi       /* offset += X */
+        js      bpf_error
+
+sk_load_byte:
+        .globl  sk_load_byte
+
+        cmp     %esi,%r9d   /* if (offset >= hlen) goto bpf_slow_path_byte */
+        jle     bpf_slow_path_byte
+        movzbl  (SKBDATA,%rsi),%eax
+        ret
+
+/**
+ * sk_load_byte_msh - BPF_S_LDX_B_MSH helper
+ *
+ * Implements BPF_S_LDX_B_MSH : ldxb  4*([offset]&0xf)
+ * Must preserve A accumulator (%eax)
+ * Inputs : %esi is the offset value, already known positive
+ */
+ENTRY(sk_load_byte_msh)
+        CFI_STARTPROC
+        cmp     %esi,%r9d      /* if (offset >= hlen) goto bpf_slow_path_byte_msh */
+        jle     bpf_slow_path_byte_msh
+        movzbl  (SKBDATA,%rsi),%ebx
+        and     $15,%bl
+        shl     $2,%bl
+        ret
+        CFI_ENDPROC
+ENDPROC(sk_load_byte_msh)
+
+bpf_error:
+# force a return 0 from jit handler
+        xor             %eax,%eax
+        mov             -8(%rbp),%rbx
+        leaveq
+        ret
+
+/* rsi contains offset and can be scratched */
+#define bpf_slow_path_common(LEN)               \
+        push    %rdi;    /* save skb */         \
+        push    %r9;                            \
+        push    SKBDATA;                        \
+/* rsi already has offset */                    \
+        mov     $LEN,%ecx;      /* len */       \
+        lea     -12(%rbp),%rdx;                 \
+        call    skb_copy_bits;                  \
+        test    %eax,%eax;                      \
+        pop     SKBDATA;                        \
+        pop     %r9;                            \
+        pop     %rdi
+
+
+bpf_slow_path_word:
+        bpf_slow_path_common(4)
+        js      bpf_error
+        mov     -12(%rbp),%eax
+        bswap   %eax
+        ret
+
+bpf_slow_path_half:
+        bpf_slow_path_common(2)
+        js      bpf_error
+        mov     -12(%rbp),%ax
+        rol     $8,%ax
+        movzwl  %ax,%eax
+        ret
+
+bpf_slow_path_byte:
+        bpf_slow_path_common(1)
+        js      bpf_error
+        movzbl  -12(%rbp),%eax
+        ret
+
+bpf_slow_path_byte_msh:
+        xchg    %eax,%ebx /* dont lose A , X is about to be scratched */
+        bpf_slow_path_common(1)
+        js      bpf_error
+        movzbl  -12(%rbp),%eax
+        and     $15,%al
+        shl     $2,%al
+        xchg    %eax,%ebx
+        ret
diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
new file mode 100644
index 000000000000..bfab3fa10edc
--- /dev/null
+++ b/arch/x86/net/bpf_jit_comp.c
@@ -0,0 +1,654 @@
+/* bpf_jit_comp.c : BPF JIT compiler
+ *
+ * Copyright (C) 2011 Eric Dumazet (eric.dumazet@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ */
+#include <linux/moduleloader.h>
+#include <asm/cacheflush.h>
+#include <linux/netdevice.h>
+#include <linux/filter.h>
+
+/*
+ * Conventions :
+ *  EAX : BPF A accumulator
+ *  EBX : BPF X accumulator
+ *  RDI : pointer to skb   (first argument given to JIT function)
+ *  RBP : frame pointer (even if CONFIG_FRAME_POINTER=n)
+ *  ECX,EDX,ESI : scratch registers
+ *  r9d : skb->len - skb->data_len (headlen)
+ *  r8  : skb->data
+ * -8(RBP) : saved RBX value
+ * -16(RBP)..-80(RBP) : BPF_MEMWORDS values
+ */
+int bpf_jit_enable __read_mostly;
+
+/*
+ * assembly code in arch/x86/net/bpf_jit.S
+ */
+extern u8 sk_load_word[], sk_load_half[], sk_load_byte[], sk_load_byte_msh[];
+extern u8 sk_load_word_ind[], sk_load_half_ind[], sk_load_byte_ind[];
+
+static inline u8 *emit_code(u8 *ptr, u32 bytes, unsigned int len)
+{
+        if (len == 1)
+                *ptr = bytes;
+        else if (len == 2)
+                *(u16 *)ptr = bytes;
+        else {
+                *(u32 *)ptr = bytes;
+                barrier();
+        }
+        return ptr + len;
+}
+
+#define EMIT(bytes, len)        do { prog = emit_code(prog, bytes, len); } while (0)
+
+#define EMIT1(b1)               EMIT(b1, 1)
+#define EMIT2(b1, b2)           EMIT((b1) + ((b2) << 8), 2)
+#define EMIT3(b1, b2, b3)       EMIT((b1) + ((b2) << 8) + ((b3) << 16), 3)
+#define EMIT4(b1, b2, b3, b4)   EMIT((b1) + ((b2) << 8) + ((b3) << 16) + ((b4) << 24), 4)
+#define EMIT1_off32(b1, off)    do { EMIT1(b1); EMIT(off, 4);} while (0)
+
+#define CLEAR_A() EMIT2(0x31, 0xc0) /* xor %eax,%eax */
+#define CLEAR_X() EMIT2(0x31, 0xdb) /* xor %ebx,%ebx */
+
+static inline bool is_imm8(int value)
+{
+        return value <= 127 && value >= -128;
+}
+
+static inline bool is_near(int offset)
+{
+        return offset <= 127 && offset >= -128;
+}
+
+#define EMIT_JMP(offset)                                                \
+do {                                                                    \
+        if (offset) {                                                   \
+                if (is_near(offset))                                    \
+                        EMIT2(0xeb, offset); /* jmp .+off8 */           \
+                else                                                    \
+                        EMIT1_off32(0xe9, offset); /* jmp .+off32 */    \
+        }                                                               \
+} while (0)
+
+/* list of x86 cond jumps opcodes (. + s8)
+ * Add 0x10 (and an extra 0x0f) to generate far jumps (. + s32)
+ */
+#define X86_JB  0x72
+#define X86_JAE 0x73
+#define X86_JE  0x74
+#define X86_JNE 0x75
+#define X86_JBE 0x76
+#define X86_JA  0x77
+
+#define EMIT_COND_JMP(op, offset)                               \
+do {                                                            \
+        if (is_near(offset))                                    \
+                EMIT2(op, offset); /* jxx .+off8 */             \
+        else {                                                  \
+                EMIT2(0x0f, op + 0x10);                         \
+                EMIT(offset, 4); /* jxx .+off32 */              \
+        }                                                       \
+} while (0)
+
+#define COND_SEL(CODE, TOP, FOP)        \
+        case CODE:                      \
+                t_op = TOP;             \
+                f_op = FOP;             \
+                goto cond_branch
+
+
+#define SEEN_DATAREF 1 /* might call external helpers */
+#define SEEN_XREG    2 /* ebx is used */
+#define SEEN_MEM     4 /* use mem[] for temporary storage */
+
+static inline void bpf_flush_icache(void *start, void *end)
+{
+        mm_segment_t old_fs = get_fs();
+
+        set_fs(KERNEL_DS);
+        smp_wmb();
+        flush_icache_range((unsigned long)start, (unsigned long)end);
+        set_fs(old_fs);
+}
+
+
+void bpf_jit_compile(struct sk_filter *fp)
+{
+        u8 temp[64];
+        u8 *prog;
+        unsigned int proglen, oldproglen = 0;
+        int ilen, i;
+        int t_offset, f_offset;
+        u8 t_op, f_op, seen = 0, pass;
+        u8 *image = NULL;
+        u8 *func;
+        int pc_ret0 = -1; /* bpf index of first RET #0 instruction (if any) */
+        unsigned int cleanup_addr; /* epilogue code offset */
+        unsigned int *addrs;
+        const struct sock_filter *filter = fp->insns;
+        int flen = fp->len;
+
+        if (!bpf_jit_enable)
+                return;
+
+        addrs = kmalloc(flen * sizeof(*addrs), GFP_KERNEL);
+        if (addrs == NULL)
+                return;
+
+        /* Before first pass, make a rough estimation of addrs[]
+         * each bpf instruction is translated to less than 64 bytes
+         */
+        for (proglen = 0, i = 0; i < flen; i++) {
+                proglen += 64;
+                addrs[i] = proglen;
+        }
+        cleanup_addr = proglen; /* epilogue address */
+
+        for (pass = 0; pass < 10; pass++) {
+                /* no prologue/epilogue for trivial filters (RET something) */
+                proglen = 0;
+                prog = temp;
+
+                if (seen) {
+                        EMIT4(0x55, 0x48, 0x89, 0xe5); /* push %rbp; mov %rsp,%rbp */
+                        EMIT4(0x48, 0x83, 0xec, 96);    /* subq  $96,%rsp       */
+                        /* note : must save %rbx in case bpf_error is hit */
+                        if (seen & (SEEN_XREG | SEEN_DATAREF))
+                                EMIT4(0x48, 0x89, 0x5d, 0xf8); /* mov %rbx, -8(%rbp) */
+                        if (seen & SEEN_XREG)
+                                CLEAR_X(); /* make sure we dont leek kernel memory */
+
+                        /*
+                         * If this filter needs to access skb data,
+                         * loads r9 and r8 with :
+                         *  r9 = skb->len - skb->data_len
+                         *  r8 = skb->data
+                         */
+                        if (seen & SEEN_DATAREF) {
+                                if (offsetof(struct sk_buff, len) <= 127)
+                                        /* mov    off8(%rdi),%r9d */
+                                        EMIT4(0x44, 0x8b, 0x4f, offsetof(struct sk_buff, len));
+                                else {
+                                        /* mov    off32(%rdi),%r9d */
+                                        EMIT3(0x44, 0x8b, 0x8f);
+                                        EMIT(offsetof(struct sk_buff, len), 4);
+                                }
+                                if (is_imm8(offsetof(struct sk_buff, data_len)))
+                                        /* sub    off8(%rdi),%r9d */
+                                        EMIT4(0x44, 0x2b, 0x4f, offsetof(struct sk_buff, data_len));
+                                else {
+                                        EMIT3(0x44, 0x2b, 0x8f);
+                                        EMIT(offsetof(struct sk_buff, data_len), 4);
+                                }
+
+                                if (is_imm8(offsetof(struct sk_buff, data)))
+                                        /* mov off8(%rdi),%r8 */
+                                        EMIT4(0x4c, 0x8b, 0x47, offsetof(struct sk_buff, data));
+                                else {
+                                        /* mov off32(%rdi),%r8 */
+                                        EMIT3(0x4c, 0x8b, 0x87);
+                                        EMIT(offsetof(struct sk_buff, data), 4);
+                                }
+                        }
+                }
+
+                switch (filter[0].code) {
+                case BPF_S_RET_K:
+                case BPF_S_LD_W_LEN:
+                case BPF_S_ANC_PROTOCOL:
+                case BPF_S_ANC_IFINDEX:
+                case BPF_S_ANC_MARK:
+                case BPF_S_ANC_RXHASH:
+                case BPF_S_ANC_CPU:
+                case BPF_S_ANC_QUEUE:
+                case BPF_S_LD_W_ABS:
+                case BPF_S_LD_H_ABS:
+                case BPF_S_LD_B_ABS:
+                        /* first instruction sets A register (or is RET 'constant') */
+                        break;
+                default:
+                        /* make sure we dont leak kernel information to user */
+                        CLEAR_A(); /* A = 0 */
+                }
+
+                for (i = 0; i < flen; i++) {
+                        unsigned int K = filter[i].k;
+
+                        switch (filter[i].code) {
+                        case BPF_S_ALU_ADD_X: /* A += X; */
+                                seen |= SEEN_XREG;
+                                EMIT2(0x01, 0xd8);              /* add %ebx,%eax */
+                                break;
+                        case BPF_S_ALU_ADD_K: /* A += K; */
+                                if (!K)
+                                        break;
+                                if (is_imm8(K))
+                                        EMIT3(0x83, 0xc0, K);   /* add imm8,%eax */
+                                else
+                                        EMIT1_off32(0x05, K);   /* add imm32,%eax */
+                                break;
+                        case BPF_S_ALU_SUB_X: /* A -= X; */
+                                seen |= SEEN_XREG;
+                                EMIT2(0x29, 0xd8);              /* sub    %ebx,%eax */
+                                break;
+                        case BPF_S_ALU_SUB_K: /* A -= K */
+                                if (!K)
+                                        break;
+                                if (is_imm8(K))
+                                        EMIT3(0x83, 0xe8, K); /* sub imm8,%eax */
+                                else
+                                        EMIT1_off32(0x2d, K); /* sub imm32,%eax */
+                                break;
+                        case BPF_S_ALU_MUL_X: /* A *= X; */
+                                seen |= SEEN_XREG;
+                                EMIT3(0x0f, 0xaf, 0xc3);        /* imul %ebx,%eax */
+                                break;
+                        case BPF_S_ALU_MUL_K: /* A *= K */
+                                if (is_imm8(K))
+                                        EMIT3(0x6b, 0xc0, K); /* imul imm8,%eax,%eax */
+                                else {
+                                        EMIT2(0x69, 0xc0);              /* imul imm32,%eax */
+                                        EMIT(K, 4);
+                                }
+                                break;
+                        case BPF_S_ALU_DIV_X: /* A /= X; */
+                                seen |= SEEN_XREG;
+                                EMIT2(0x85, 0xdb);      /* test %ebx,%ebx */
+                                if (pc_ret0 != -1)
+                                        EMIT_COND_JMP(X86_JE, addrs[pc_ret0] - (addrs[i] - 4));
+                                else {
+                                        EMIT_COND_JMP(X86_JNE, 2 + 5);
+                                        CLEAR_A();
+                                        EMIT1_off32(0xe9, cleanup_addr - (addrs[i] - 4)); /* jmp .+off32 */
+                                }
+                                EMIT4(0x31, 0xd2, 0xf7, 0xf3); /* xor %edx,%edx; div %ebx */
+                                break;
+                        case BPF_S_ALU_DIV_K: /* A = reciprocal_divide(A, K); */
+                                EMIT3(0x48, 0x69, 0xc0); /* imul imm32,%rax,%rax */
+                                EMIT(K, 4);
+                                EMIT4(0x48, 0xc1, 0xe8, 0x20); /* shr $0x20,%rax */
+                                break;
+                        case BPF_S_ALU_AND_X:
+                                seen |= SEEN_XREG;
+                                EMIT2(0x21, 0xd8);              /* and %ebx,%eax */
+                                break;
+                        case BPF_S_ALU_AND_K:
+                                if (K >= 0xFFFFFF00) {
+                                        EMIT2(0x24, K & 0xFF); /* and imm8,%al */
+                                } else if (K >= 0xFFFF0000) {
+                                        EMIT2(0x66, 0x25);      /* and imm16,%ax */
+                                        EMIT2(K, 2);
+                                } else {
+                                        EMIT1_off32(0x25, K);   /* and imm32,%eax */
+                                }
+                                break;
+                        case BPF_S_ALU_OR_X:
+                                seen |= SEEN_XREG;
+                                EMIT2(0x09, 0xd8);              /* or %ebx,%eax */
+                                break;
+                        case BPF_S_ALU_OR_K:
+                                if (is_imm8(K))
+                                        EMIT3(0x83, 0xc8, K); /* or imm8,%eax */
+                                else
+                                        EMIT1_off32(0x0d, K);   /* or imm32,%eax */
+                                break;
+                        case BPF_S_ALU_LSH_X: /* A <<= X; */
+                                seen |= SEEN_XREG;
+                                EMIT4(0x89, 0xd9, 0xd3, 0xe0);  /* mov %ebx,%ecx; shl %cl,%eax */
+                                break;
+                        case BPF_S_ALU_LSH_K:
+                                if (K == 0)
+                                        break;
+                                else if (K == 1)
+                                        EMIT2(0xd1, 0xe0); /* shl %eax */
+                                else
+                                        EMIT3(0xc1, 0xe0, K);
+                                break;
+                        case BPF_S_ALU_RSH_X: /* A >>= X; */
+                                seen |= SEEN_XREG;
+                                EMIT4(0x89, 0xd9, 0xd3, 0xe8);  /* mov %ebx,%ecx; shr %cl,%eax */
+                                break;
+                        case BPF_S_ALU_RSH_K: /* A >>= K; */
+                                if (K == 0)
+                                        break;
+                                else if (K == 1)
+                                        EMIT2(0xd1, 0xe8); /* shr %eax */
+                                else
+                                        EMIT3(0xc1, 0xe8, K);
+                                break;
+                        case BPF_S_ALU_NEG:
+                                EMIT2(0xf7, 0xd8);              /* neg %eax */
+                                break;
+                        case BPF_S_RET_K:
+                                if (!K) {
+                                        if (pc_ret0 == -1)
+                                                pc_ret0 = i;
+                                        CLEAR_A();
+                                } else {
+                                        EMIT1_off32(0xb8, K);   /* mov $imm32,%eax */
+                                }
+                                /* fallinto */
+                        case BPF_S_RET_A:
+                                if (seen) {
+                                        if (i != flen - 1) {
+                                                EMIT_JMP(cleanup_addr - addrs[i]);
+                                                break;
+                                        }
+                                        if (seen & SEEN_XREG)
+                                                EMIT4(0x48, 0x8b, 0x5d, 0xf8);  /* mov  -8(%rbp),%rbx */
+                                        EMIT1(0xc9);            /* leaveq */
+                                }
+                                EMIT1(0xc3);            /* ret */
+                                break;
+                        case BPF_S_MISC_TAX: /* X = A */
+                                seen |= SEEN_XREG;
+                                EMIT2(0x89, 0xc3);      /* mov    %eax,%ebx */
+                                break;
+                        case BPF_S_MISC_TXA: /* A = X */
+                                seen |= SEEN_XREG;
+                                EMIT2(0x89, 0xd8);      /* mov    %ebx,%eax */
+                                break;
+                        case BPF_S_LD_IMM: /* A = K */
+                                if (!K)
+                                        CLEAR_A();
+                                else
+                                        EMIT1_off32(0xb8, K); /* mov $imm32,%eax */
+                                break;
+                        case BPF_S_LDX_IMM: /* X = K */
+                                seen |= SEEN_XREG;
+                                if (!K)
+                                        CLEAR_X();
+                                else
+                                        EMIT1_off32(0xbb, K); /* mov $imm32,%ebx */
+                                break;
+                        case BPF_S_LD_MEM: /* A = mem[K] : mov off8(%rbp),%eax */
+                                seen |= SEEN_MEM;
+                                EMIT3(0x8b, 0x45, 0xf0 - K*4);
+                                break;
+                        case BPF_S_LDX_MEM: /* X = mem[K] : mov off8(%rbp),%ebx */
+                                seen |= SEEN_XREG | SEEN_MEM;
+                                EMIT3(0x8b, 0x5d, 0xf0 - K*4);
+                                break;
+                        case BPF_S_ST: /* mem[K] = A : mov %eax,off8(%rbp) */
+                                seen |= SEEN_MEM;
+                                EMIT3(0x89, 0x45, 0xf0 - K*4);
+                                break;
+                        case BPF_S_STX: /* mem[K] = X : mov %ebx,off8(%rbp) */
+                                seen |= SEEN_XREG | SEEN_MEM;
+                                EMIT3(0x89, 0x5d, 0xf0 - K*4);
+                                break;
+                        case BPF_S_LD_W_LEN: /* A = skb->len; */
+                                BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, len) != 4);
+                                if (is_imm8(offsetof(struct sk_buff, len)))
+                                        /* mov    off8(%rdi),%eax */
+                                        EMIT3(0x8b, 0x47, offsetof(struct sk_buff, len));
+                                else {
+                                        EMIT2(0x8b, 0x87);
+                                        EMIT(offsetof(struct sk_buff, len), 4);
+                                }
+                                break;
+                        case BPF_S_LDX_W_LEN: /* X = skb->len; */
+                                seen |= SEEN_XREG;
+                                if (is_imm8(offsetof(struct sk_buff, len)))
+                                        /* mov off8(%rdi),%ebx */
+                                        EMIT3(0x8b, 0x5f, offsetof(struct sk_buff, len));
+                                else {
+                                        EMIT2(0x8b, 0x9f);
+                                        EMIT(offsetof(struct sk_buff, len), 4);
+                                }
+                                break;
+                        case BPF_S_ANC_PROTOCOL: /* A = ntohs(skb->protocol); */
+                                BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, protocol) != 2);
+                                if (is_imm8(offsetof(struct sk_buff, protocol))) {
+                                        /* movzwl off8(%rdi),%eax */
+                                        EMIT4(0x0f, 0xb7, 0x47, offsetof(struct sk_buff, protocol));
+                                } else {
+                                        EMIT3(0x0f, 0xb7, 0x87); /* movzwl off32(%rdi),%eax */
+                                        EMIT(offsetof(struct sk_buff, protocol), 4);
+                                }
+                                EMIT2(0x86, 0xc4); /* ntohs() : xchg   %al,%ah */
+                                break;
+                        case BPF_S_ANC_IFINDEX:
+                                if (is_imm8(offsetof(struct sk_buff, dev))) {
+                                        /* movq off8(%rdi),%rax */
+                                        EMIT4(0x48, 0x8b, 0x47, offsetof(struct sk_buff, dev));
+                                } else {
+                                        EMIT3(0x48, 0x8b, 0x87); /* movq off32(%rdi),%rax */
+                                        EMIT(offsetof(struct sk_buff, dev), 4);
+                                }
+                                EMIT3(0x48, 0x85, 0xc0);        /* test %rax,%rax */
+                                EMIT_COND_JMP(X86_JE, cleanup_addr - (addrs[i] - 6));
+                                BUILD_BUG_ON(FIELD_SIZEOF(struct net_device, ifindex) != 4);
+                                EMIT2(0x8b, 0x80);      /* mov off32(%rax),%eax */
+                                EMIT(offsetof(struct net_device, ifindex), 4);
+                                break;
+                        case BPF_S_ANC_MARK:
+                                BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, mark) != 4);
+                                if (is_imm8(offsetof(struct sk_buff, mark))) {
+                                        /* mov off8(%rdi),%eax */
+                                        EMIT3(0x8b, 0x47, offsetof(struct sk_buff, mark));
+                                } else {
+                                        EMIT2(0x8b, 0x87);
+                                        EMIT(offsetof(struct sk_buff, mark), 4);
+                                }
+                                break;
+                        case BPF_S_ANC_RXHASH:
+                                BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, rxhash) != 4);
+                                if (is_imm8(offsetof(struct sk_buff, rxhash))) {
+                                        /* mov off8(%rdi),%eax */
+                                        EMIT3(0x8b, 0x47, offsetof(struct sk_buff, rxhash));
+                                } else {
+                                        EMIT2(0x8b, 0x87);
+                                        EMIT(offsetof(struct sk_buff, rxhash), 4);
+                                }
+                                break;
+                        case BPF_S_ANC_QUEUE:
+                                BUILD_BUG_ON(FIELD_SIZEOF(struct sk_buff, queue_mapping) != 2);
+                                if (is_imm8(offsetof(struct sk_buff, queue_mapping))) {
+                                        /* movzwl off8(%rdi),%eax */
+                                        EMIT4(0x0f, 0xb7, 0x47, offsetof(struct sk_buff, queue_mapping));
+                                } else {
+                                        EMIT3(0x0f, 0xb7, 0x87); /* movzwl off32(%rdi),%eax */
+                                        EMIT(offsetof(struct sk_buff, queue_mapping), 4);
+                                }
+                                break;
+                        case BPF_S_ANC_CPU:
+#ifdef CONFIG_SMP
+                                EMIT4(0x65, 0x8b, 0x04, 0x25); /* mov %gs:off32,%eax */
+                                EMIT((u32)(unsigned long)&cpu_number, 4); /* A = smp_processor_id(); */
+#else
+                                CLEAR_A();
+#endif
+                                break;
+                        case BPF_S_LD_W_ABS:
+                                func = sk_load_word;
+common_load:                    seen |= SEEN_DATAREF;
+                                if ((int)K < 0)
+                                        goto out;
+                                t_offset = func - (image + addrs[i]);
+                                EMIT1_off32(0xbe, K); /* mov imm32,%esi */
+                                EMIT1_off32(0xe8, t_offset); /* call */
+                                break;
+                        case BPF_S_LD_H_ABS:
+                                func = sk_load_half;
+                                goto common_load;
+                        case BPF_S_LD_B_ABS:
+                                func = sk_load_byte;
+                                goto common_load;
+                        case BPF_S_LDX_B_MSH:
+                                if ((int)K < 0) {
+                                        if (pc_ret0 != -1) {
+                                                EMIT_JMP(addrs[pc_ret0] - addrs[i]);
+                                                break;
+                                        }
+                                        CLEAR_A();
+                                        EMIT_JMP(cleanup_addr - addrs[i]);
+                                        break;
+                                }
+                                seen |= SEEN_DATAREF | SEEN_XREG;
+                                t_offset = sk_load_byte_msh - (image + addrs[i]);
+                                EMIT1_off32(0xbe, K);   /* mov imm32,%esi */
+                                EMIT1_off32(0xe8, t_offset); /* call sk_load_byte_msh */
+                                break;
+                        case BPF_S_LD_W_IND:
+                                func = sk_load_word_ind;
+common_load_ind:                seen |= SEEN_DATAREF | SEEN_XREG;
+                                t_offset = func - (image + addrs[i]);
+                                EMIT1_off32(0xbe, K);   /* mov imm32,%esi   */
+                                EMIT1_off32(0xe8, t_offset);    /* call sk_load_xxx_ind */
+                                break;
+                        case BPF_S_LD_H_IND:
+                                func = sk_load_half_ind;
+                                goto common_load_ind;
+                        case BPF_S_LD_B_IND:
+                                func = sk_load_byte_ind;
+                                goto common_load_ind;
+                        case BPF_S_JMP_JA:
+                                t_offset = addrs[i + K] - addrs[i];
+                                EMIT_JMP(t_offset);
+                                break;
+                        COND_SEL(BPF_S_JMP_JGT_K, X86_JA, X86_JBE);
+                        COND_SEL(BPF_S_JMP_JGE_K, X86_JAE, X86_JB);
+                        COND_SEL(BPF_S_JMP_JEQ_K, X86_JE, X86_JNE);
+                        COND_SEL(BPF_S_JMP_JSET_K,X86_JNE, X86_JE);
+                        COND_SEL(BPF_S_JMP_JGT_X, X86_JA, X86_JBE);
+                        COND_SEL(BPF_S_JMP_JGE_X, X86_JAE, X86_JB);
+                        COND_SEL(BPF_S_JMP_JEQ_X, X86_JE, X86_JNE);
+                        COND_SEL(BPF_S_JMP_JSET_X,X86_JNE, X86_JE);
+
+cond_branch:                    f_offset = addrs[i + filter[i].jf] - addrs[i];
+                                t_offset = addrs[i + filter[i].jt] - addrs[i];
+
+                                /* same targets, can avoid doing the test :) */
+                                if (filter[i].jt == filter[i].jf) {
+                                        EMIT_JMP(t_offset);
+                                        break;
+                                }
+
+                                switch (filter[i].code) {
+                                case BPF_S_JMP_JGT_X:
+                                case BPF_S_JMP_JGE_X:
+                                case BPF_S_JMP_JEQ_X:
+                                        seen |= SEEN_XREG;
+                                        EMIT2(0x39, 0xd8); /* cmp %ebx,%eax */
+                                        break;
+                                case BPF_S_JMP_JSET_X:
+                                        seen |= SEEN_XREG;
+                                        EMIT2(0x85, 0xd8); /* test %ebx,%eax */
+                                        break;
+                                case BPF_S_JMP_JEQ_K:
+                                        if (K == 0) {
+                                                EMIT2(0x85, 0xc0); /* test   %eax,%eax */
+                                                break;
+                                        }
+                                case BPF_S_JMP_JGT_K:
+                                case BPF_S_JMP_JGE_K:
+                                        if (K <= 127)
+                                                EMIT3(0x83, 0xf8, K); /* cmp imm8,%eax */
+                                        else
+                                                EMIT1_off32(0x3d, K); /* cmp imm32,%eax */
+                                        break;
+                                case BPF_S_JMP_JSET_K:
+                                        if (K <= 0xFF)
+                                                EMIT2(0xa8, K); /* test imm8,%al */
+                                        else if (!(K & 0xFFFF00FF))
+                                                EMIT3(0xf6, 0xc4, K >> 8); /* test imm8,%ah */
+                                        else if (K <= 0xFFFF) {
+                                                EMIT2(0x66, 0xa9); /* test imm16,%ax */
+                                                EMIT(K, 2);
+                                        } else {
+                                                EMIT1_off32(0xa9, K); /* test imm32,%eax */
+                                        }
+                                        break;
+                                }
+                                if (filter[i].jt != 0) {
+                                        if (filter[i].jf)
+                                                t_offset += is_near(f_offset) ? 2 : 6;
+                                        EMIT_COND_JMP(t_op, t_offset);
+                                        if (filter[i].jf)
+                                                EMIT_JMP(f_offset);
+                                        break;
+                                }
+                                EMIT_COND_JMP(f_op, f_offset);
+                                break;
+                        default:
+                                /* hmm, too complex filter, give up with jit compiler */
+                                goto out;
+                        }
+                        ilen = prog - temp;
+                        if (image) {
+                                if (unlikely(proglen + ilen > oldproglen)) {
+                                        pr_err("bpb_jit_compile fatal error\n");
+                                        kfree(addrs);
+                                        module_free(NULL, image);
+                                        return;
+                                }
+                                memcpy(image + proglen, temp, ilen);
+                        }
+                        proglen += ilen;
+                        addrs[i] = proglen;
+                        prog = temp;
+                }
+                /* last bpf instruction is always a RET :
+                 * use it to give the cleanup instruction(s) addr
+                 */
+                cleanup_addr = proglen - 1; /* ret */
+                if (seen)
+                        cleanup_addr -= 1; /* leaveq */
+                if (seen & SEEN_XREG)
+                        cleanup_addr -= 4; /* mov  -8(%rbp),%rbx */
+
+                if (image) {
+                        WARN_ON(proglen != oldproglen);
+                        break;
+                }
+                if (proglen == oldproglen) {
+                        image = module_alloc(max_t(unsigned int,
+                                                   proglen,
+                                                   sizeof(struct work_struct)));
+                        if (!image)
+                                goto out;
+                }
+                oldproglen = proglen;
+        }
+        if (bpf_jit_enable > 1)
+                pr_err("flen=%d proglen=%u pass=%d image=%p\n",
+                       flen, proglen, pass, image);
+
+        if (image) {
+                if (bpf_jit_enable > 1)
+                        print_hex_dump(KERN_ERR, "JIT code: ", DUMP_PREFIX_ADDRESS,
+                                       16, 1, image, proglen, false);
+
+                bpf_flush_icache(image, image + proglen);
+
+                fp->bpf_func = (void *)image;
+        }
+out:
+        kfree(addrs);
+        return;
+}
+
+static void jit_free_defer(struct work_struct *arg)
+{
+        module_free(NULL, arg);
+}
+
+/* run from softirq, we must use a work_struct to call
+ * module_free() from process context
+ */
+void bpf_jit_free(struct sk_filter *fp)
+{
+        if (fp->bpf_func != sk_run_filter) {
+                struct work_struct *work = (struct work_struct *)fp->bpf_func;
+
+                INIT_WORK(work, jit_free_defer);
+                schedule_work(work);
+        }
+}
diff --git a/arch/x86/oprofile/backtrace.c b/arch/x86/oprofile/backtrace.c
index 2d49d4e19a36..a5b64ab4cd6e 100644
--- a/arch/x86/oprofile/backtrace.c
+++ b/arch/x86/oprofile/backtrace.c
@@ -16,17 +16,6 @@
 #include <asm/stacktrace.h>
 #include <linux/compat.h>
 
-static void backtrace_warning_symbol(void *data, char *msg,
-                                     unsigned long symbol)
-{
-        /* Ignore warnings */
-}
-
-static void backtrace_warning(void *data, char *msg)
-{
-        /* Ignore warnings */
-}
-
 static int backtrace_stack(void *data, char *name)
 {
         /* Yes, we want all stacks */
@@ -42,8 +31,6 @@ static void backtrace_address(void *data, unsigned long addr, int reliable)
 }
 
 static struct stacktrace_ops backtrace_ops = {
-        .warning        = backtrace_warning,
-        .warning_symbol = backtrace_warning_symbol,
         .stack          = backtrace_stack,
         .address        = backtrace_address,
         .walk_stack     = print_context_stack,
diff --git a/arch/x86/pci/xen.c b/arch/x86/pci/xen.c
index e37b407a0ee8..8214724ce54d 100644
--- a/arch/x86/pci/xen.c
+++ b/arch/x86/pci/xen.c
@@ -108,7 +108,8 @@ static int xen_hvm_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
                 }
                 irq = xen_bind_pirq_msi_to_irq(dev, msidesc, pirq, 0,
                                                (type == PCI_CAP_ID_MSIX) ?
-                                               "msi-x" : "msi");
+                                               "msi-x" : "msi",
+                                               DOMID_SELF);
                 if (irq < 0)
                         goto error;
                 dev_dbg(&dev->dev,
@@ -148,7 +149,8 @@ static int xen_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
                 irq = xen_bind_pirq_msi_to_irq(dev, msidesc, v[i], 0,
                                                (type == PCI_CAP_ID_MSIX) ?
                                                "pcifront-msi-x" :
-                                               "pcifront-msi");
+                                               "pcifront-msi",
+                                                DOMID_SELF);
                 if (irq < 0)
                         goto free;
                 i++;
@@ -190,9 +192,16 @@ static int xen_initdom_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
 
         list_for_each_entry(msidesc, &dev->msi_list, list) {
                 struct physdev_map_pirq map_irq;
+                domid_t domid;
+
+                domid = ret = xen_find_device_domain_owner(dev);
+                /* N.B. Casting int's -ENODEV to uint16_t results in 0xFFED,
+                 * hence check ret value for < 0. */
+                if (ret < 0)
+                        domid = DOMID_SELF;
 
                 memset(&map_irq, 0, sizeof(map_irq));
-                map_irq.domid = DOMID_SELF;
+                map_irq.domid = domid;
                 map_irq.type = MAP_PIRQ_TYPE_MSI;
                 map_irq.index = -1;
                 map_irq.pirq = -1;
@@ -215,14 +224,16 @@ static int xen_initdom_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
 
                 ret = HYPERVISOR_physdev_op(PHYSDEVOP_map_pirq, &map_irq);
                 if (ret) {
-                        dev_warn(&dev->dev, "xen map irq failed %d\n", ret);
+                        dev_warn(&dev->dev, "xen map irq failed %d for %d domain\n",
+                                 ret, domid);
                         goto out;
                 }
 
                 ret = xen_bind_pirq_msi_to_irq(dev, msidesc,
                                                map_irq.pirq, map_irq.index,
                                                (type == PCI_CAP_ID_MSIX) ?
-                                               "msi-x" : "msi");
+                                               "msi-x" : "msi",
+                                                domid);
                 if (ret < 0)
                         goto out;
         }
@@ -461,3 +472,78 @@ void __init xen_setup_pirqs(void)
         }
 }
 #endif
+
+#ifdef CONFIG_XEN_DOM0
+struct xen_device_domain_owner {
+        domid_t domain;
+        struct pci_dev *dev;
+        struct list_head list;
+};
+
+static DEFINE_SPINLOCK(dev_domain_list_spinlock);
+static struct list_head dev_domain_list = LIST_HEAD_INIT(dev_domain_list);
+
+static struct xen_device_domain_owner *find_device(struct pci_dev *dev)
+{
+        struct xen_device_domain_owner *owner;
+
+        list_for_each_entry(owner, &dev_domain_list, list) {
+                if (owner->dev == dev)
+                        return owner;
+        }
+        return NULL;
+}
+
+int xen_find_device_domain_owner(struct pci_dev *dev)
+{
+        struct xen_device_domain_owner *owner;
+        int domain = -ENODEV;
+
+        spin_lock(&dev_domain_list_spinlock);
+        owner = find_device(dev);
+        if (owner)
+                domain = owner->domain;
+        spin_unlock(&dev_domain_list_spinlock);
+        return domain;
+}
+EXPORT_SYMBOL_GPL(xen_find_device_domain_owner);
+
+int xen_register_device_domain_owner(struct pci_dev *dev, uint16_t domain)
+{
+        struct xen_device_domain_owner *owner;
+
+        owner = kzalloc(sizeof(struct xen_device_domain_owner), GFP_KERNEL);
+        if (!owner)
+                return -ENODEV;
+
+        spin_lock(&dev_domain_list_spinlock);
+        if (find_device(dev)) {
+                spin_unlock(&dev_domain_list_spinlock);
+                kfree(owner);
+                return -EEXIST;
+        }
+        owner->domain = domain;
+        owner->dev = dev;
+        list_add_tail(&owner->list, &dev_domain_list);
+        spin_unlock(&dev_domain_list_spinlock);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(xen_register_device_domain_owner);
+
+int xen_unregister_device_domain_owner(struct pci_dev *dev)
+{
+        struct xen_device_domain_owner *owner;
+
+        spin_lock(&dev_domain_list_spinlock);
+        owner = find_device(dev);
+        if (!owner) {
+                spin_unlock(&dev_domain_list_spinlock);
+                return -ENODEV;
+        }
+        list_del(&owner->list);
+        spin_unlock(&dev_domain_list_spinlock);
+        kfree(owner);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(xen_unregister_device_domain_owner);
+#endif
diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index 0fe27d7c6258..b30aa26a8df2 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -145,17 +145,6 @@ static void virt_efi_reset_system(int reset_type,
                        data_size, data);
 }
 
-static efi_status_t virt_efi_set_virtual_address_map(
-        unsigned long memory_map_size,
-        unsigned long descriptor_size,
-        u32 descriptor_version,
-        efi_memory_desc_t *virtual_map)
-{
-        return efi_call_virt4(set_virtual_address_map,
-                              memory_map_size, descriptor_size,
-                              descriptor_version, virtual_map);
-}
-
 static efi_status_t __init phys_efi_set_virtual_address_map(
         unsigned long memory_map_size,
         unsigned long descriptor_size,
@@ -468,11 +457,25 @@ void __init efi_init(void)
 #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;
-        u64 addr, npages;
 
         /* Make EFI runtime service code area executable */
         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
@@ -481,10 +484,7 @@ static void __init runtime_code_page_mkexec(void)
                 if (md->type != EFI_RUNTIME_SERVICES_CODE)
                         continue;
 
-                addr = md->virt_addr;
-                npages = md->num_pages;
-                memrange_efi_to_native(&addr, &npages);
-                set_memory_x(addr, npages);
+                efi_set_executable(md, true);
         }
 }
 
@@ -498,13 +498,42 @@ static void __init runtime_code_page_mkexec(void)
  */
 void __init efi_enter_virtual_mode(void)
 {
-        efi_memory_desc_t *md;
+        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;
+        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))
@@ -541,15 +570,21 @@ void __init efi_enter_virtual_mode(void)
                         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 * memmap.nr_map,
+                memmap.desc_size * count,
                 memmap.desc_size,
                 memmap.desc_version,
-                memmap.phys_map);
+                (efi_memory_desc_t *)__pa(new_memmap));
 
         if (status != EFI_SUCCESS) {
                 printk(KERN_ALERT "Unable to switch EFI into virtual mode "
@@ -572,11 +607,12 @@ void __init efi_enter_virtual_mode(void)
         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 = virt_efi_set_virtual_address_map;
+        efi.set_virtual_address_map = NULL;
         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);
 }
 
 /*
diff --git a/arch/x86/platform/efi/efi_64.c b/arch/x86/platform/efi/efi_64.c
index ac0621a7ac3d..2649426a7905 100644
--- a/arch/x86/platform/efi/efi_64.c
+++ b/arch/x86/platform/efi/efi_64.c
@@ -41,22 +41,7 @@
 static pgd_t save_pgd __initdata;
 static unsigned long efi_flags __initdata;
 
-static void __init early_mapping_set_exec(unsigned long start,
-                                          unsigned long end,
-                                          int executable)
-{
-        unsigned long num_pages;
-
-        start &= PMD_MASK;
-        end = (end + PMD_SIZE - 1) & PMD_MASK;
-        num_pages = (end - start) >> PAGE_SHIFT;
-        if (executable)
-                set_memory_x((unsigned long)__va(start), num_pages);
-        else
-                set_memory_nx((unsigned long)__va(start), num_pages);
-}
-
-static void __init early_runtime_code_mapping_set_exec(int executable)
+static void __init early_code_mapping_set_exec(int executable)
 {
         efi_memory_desc_t *md;
         void *p;
@@ -67,11 +52,8 @@ static void __init early_runtime_code_mapping_set_exec(int executable)
         /* 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) {
-                        unsigned long end;
-                        end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
-                        early_mapping_set_exec(md->phys_addr, end, executable);
-                }
+                if (md->type == EFI_RUNTIME_SERVICES_CODE)
+                        efi_set_executable(md, executable);
         }
 }
 
@@ -79,7 +61,7 @@ void __init efi_call_phys_prelog(void)
 {
         unsigned long vaddress;
 
-        early_runtime_code_mapping_set_exec(1);
+        early_code_mapping_set_exec(1);
         local_irq_save(efi_flags);
         vaddress = (unsigned long)__va(0x0UL);
         save_pgd = *pgd_offset_k(0x0UL);
@@ -95,7 +77,7 @@ void __init efi_call_phys_epilog(void)
         set_pgd(pgd_offset_k(0x0UL), save_pgd);
         __flush_tlb_all();
         local_irq_restore(efi_flags);
-        early_runtime_code_mapping_set_exec(0);
+        early_code_mapping_set_exec(0);
 }
 
 void __iomem *__init efi_ioremap(unsigned long phys_addr, unsigned long size,
@@ -107,8 +89,10 @@ void __iomem *__init efi_ioremap(unsigned long phys_addr, unsigned long size,
                 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)
-                return NULL;
+        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);
 }
diff --git a/arch/x86/platform/mrst/mrst.c b/arch/x86/platform/mrst/mrst.c
index 275dbc19e2cf..7000e74b3087 100644
--- a/arch/x86/platform/mrst/mrst.c
+++ b/arch/x86/platform/mrst/mrst.c
@@ -194,7 +194,7 @@ static unsigned long __init mrst_calibrate_tsc(void)
         return 0;
 }
 
-void __init mrst_time_init(void)
+static void __init mrst_time_init(void)
 {
         sfi_table_parse(SFI_SIG_MTMR, NULL, NULL, sfi_parse_mtmr);
         switch (mrst_timer_options) {
@@ -216,7 +216,7 @@ void __init mrst_time_init(void)
         apbt_time_init();
 }
 
-void __cpuinit mrst_arch_setup(void)
+static void __cpuinit mrst_arch_setup(void)
 {
         if (boot_cpu_data.x86 == 6 && boot_cpu_data.x86_model == 0x27)
                 __mrst_cpu_chip = MRST_CPU_CHIP_PENWELL;
diff --git a/arch/x86/platform/olpc/Makefile b/arch/x86/platform/olpc/Makefile
index c2a8cab65e5d..81c5e2165c24 100644
--- a/arch/x86/platform/olpc/Makefile
+++ b/arch/x86/platform/olpc/Makefile
@@ -1,4 +1,2 @@
-obj-$(CONFIG_OLPC)              += olpc.o
+obj-$(CONFIG_OLPC)              += olpc.o olpc_ofw.o olpc_dt.o
 obj-$(CONFIG_OLPC_XO1)          += olpc-xo1.o
-obj-$(CONFIG_OLPC)              += olpc_ofw.o
-obj-$(CONFIG_OF_PROMTREE)       += olpc_dt.o
diff --git a/arch/x86/platform/olpc/olpc.c b/arch/x86/platform/olpc/olpc.c
index edaf3fe8dc5e..0060fd59ea00 100644
--- a/arch/x86/platform/olpc/olpc.c
+++ b/arch/x86/platform/olpc/olpc.c
@@ -18,6 +18,7 @@
 #include <linux/io.h>
 #include <linux/string.h>
 #include <linux/platform_device.h>
+#include <linux/of.h>
 
 #include <asm/geode.h>
 #include <asm/setup.h>
@@ -187,41 +188,43 @@ err:
 }
 EXPORT_SYMBOL_GPL(olpc_ec_cmd);
 
-static bool __init check_ofw_architecture(void)
+static bool __init check_ofw_architecture(struct device_node *root)
 {
-        size_t propsize;
-        char olpc_arch[5];
-        const void *args[] = { NULL, "architecture", olpc_arch, (void *)5 };
-        void *res[] = { &propsize };
+        const char *olpc_arch;
+        int propsize;
 
-        if (olpc_ofw("getprop", args, res)) {
-                printk(KERN_ERR "ofw: getprop call failed!\n");
-                return false;
-        }
+        olpc_arch = of_get_property(root, "architecture", &propsize);
         return propsize == 5 && strncmp("OLPC", olpc_arch, 5) == 0;
 }
 
-static u32 __init get_board_revision(void)
+static u32 __init get_board_revision(struct device_node *root)
 {
-        size_t propsize;
-        __be32 rev;
-        const void *args[] = { NULL, "board-revision-int", &rev, (void *)4 };
-        void *res[] = { &propsize };
-
-        if (olpc_ofw("getprop", args, res) || propsize != 4) {
-                printk(KERN_ERR "ofw: getprop call failed!\n");
-                return cpu_to_be32(0);
-        }
-        return be32_to_cpu(rev);
+        int propsize;
+        const __be32 *rev;
+
+        rev = of_get_property(root, "board-revision-int", &propsize);
+        if (propsize != 4)
+                return 0;
+
+        return be32_to_cpu(*rev);
 }
 
 static bool __init platform_detect(void)
 {
-        if (!check_ofw_architecture())
+        struct device_node *root = of_find_node_by_path("/");
+        bool success;
+
+        if (!root)
                 return false;
-        olpc_platform_info.flags |= OLPC_F_PRESENT;
-        olpc_platform_info.boardrev = get_board_revision();
-        return true;
+
+        success = check_ofw_architecture(root);
+        if (success) {
+                olpc_platform_info.boardrev = get_board_revision(root);
+                olpc_platform_info.flags |= OLPC_F_PRESENT;
+        }
+
+        of_node_put(root);
+        return success;
 }
 
 static int __init add_xo1_platform_devices(void)
diff --git a/arch/x86/platform/olpc/olpc_dt.c b/arch/x86/platform/olpc/olpc_dt.c
index 044bda5b3174..d39f63d017d2 100644
--- a/arch/x86/platform/olpc/olpc_dt.c
+++ b/arch/x86/platform/olpc/olpc_dt.c
@@ -19,7 +19,9 @@
 #include <linux/kernel.h>
 #include <linux/bootmem.h>
 #include <linux/of.h>
+#include <linux/of_platform.h>
 #include <linux/of_pdt.h>
+#include <asm/olpc.h>
 #include <asm/olpc_ofw.h>
 
 static phandle __init olpc_dt_getsibling(phandle node)
@@ -180,3 +182,20 @@ void __init olpc_dt_build_devicetree(void)
         pr_info("PROM DT: Built device tree with %u bytes of memory.\n",
                         prom_early_allocated);
 }
+
+/* A list of DT node/bus matches that we want to expose as platform devices */
+static struct of_device_id __initdata of_ids[] = {
+        { .compatible = "olpc,xo1-battery" },
+        { .compatible = "olpc,xo1-dcon" },
+        { .compatible = "olpc,xo1-rtc" },
+        {},
+};
+
+static int __init olpc_create_platform_devices(void)
+{
+        if (machine_is_olpc())
+                return of_platform_bus_probe(NULL, of_ids, NULL);
+        else
+                return 0;
+}
+device_initcall(olpc_create_platform_devices);
diff --git a/arch/x86/platform/uv/tlb_uv.c b/arch/x86/platform/uv/tlb_uv.c
index 7cb6424317f6..c58e0ea39ef5 100644
--- a/arch/x86/platform/uv/tlb_uv.c
+++ b/arch/x86/platform/uv/tlb_uv.c
@@ -699,16 +699,17 @@ const struct cpumask *uv_flush_tlb_others(const struct cpumask *cpumask,
                                           struct mm_struct *mm,
                                           unsigned long va, unsigned int cpu)
 {
-        int tcpu;
-        int uvhub;
         int locals = 0;
         int remotes = 0;
         int hubs = 0;
+        int tcpu;
+        int tpnode;
         struct bau_desc *bau_desc;
         struct cpumask *flush_mask;
         struct ptc_stats *stat;
         struct bau_control *bcp;
         struct bau_control *tbcp;
+        struct hub_and_pnode *hpp;
 
         /* kernel was booted 'nobau' */
         if (nobau)
@@ -750,11 +751,18 @@ const struct cpumask *uv_flush_tlb_others(const struct cpumask *cpumask,
         bau_desc += UV_ITEMS_PER_DESCRIPTOR * bcp->uvhub_cpu;
         bau_uvhubs_clear(&bau_desc->distribution, UV_DISTRIBUTION_SIZE);
 
-        /* cpu statistics */
         for_each_cpu(tcpu, flush_mask) {
-                uvhub = uv_cpu_to_blade_id(tcpu);
-                bau_uvhub_set(uvhub, &bau_desc->distribution);
-                if (uvhub == bcp->uvhub)
+                /*
+                 * The distribution vector is a bit map of pnodes, relative
+                 * to the partition base pnode (and the partition base nasid
+                 * in the header).
+                 * Translate cpu to pnode and hub using an array stored
+                 * in local memory.
+                 */
+                hpp = &bcp->socket_master->target_hub_and_pnode[tcpu];
+                tpnode = hpp->pnode - bcp->partition_base_pnode;
+                bau_uvhub_set(tpnode, &bau_desc->distribution);
+                if (hpp->uvhub == bcp->uvhub)
                         locals++;
                 else
                         remotes++;
@@ -855,7 +863,7 @@ void uv_bau_message_interrupt(struct pt_regs *regs)
  * an interrupt, but causes an error message to be returned to
  * the sender.
  */
-static void uv_enable_timeouts(void)
+static void __init uv_enable_timeouts(void)
 {
         int uvhub;
         int nuvhubs;
@@ -1326,10 +1334,10 @@ static int __init uv_ptc_init(void)
 }
 
 /*
- * initialize the sending side's sending buffers
+ * Initialize the sending side's sending buffers.
  */
 static void
-uv_activation_descriptor_init(int node, int pnode)
+uv_activation_descriptor_init(int node, int pnode, int base_pnode)
 {
         int i;
         int cpu;
@@ -1352,11 +1360,11 @@ uv_activation_descriptor_init(int node, int pnode)
         n = pa >> uv_nshift;
         m = pa & uv_mmask;
 
+        /* the 14-bit pnode */
         uv_write_global_mmr64(pnode, UVH_LB_BAU_SB_DESCRIPTOR_BASE,
                               (n << UV_DESC_BASE_PNODE_SHIFT | m));
-
         /*
-         * initializing all 8 (UV_ITEMS_PER_DESCRIPTOR) descriptors for each
+         * Initializing all 8 (UV_ITEMS_PER_DESCRIPTOR) descriptors for each
          * cpu even though we only use the first one; one descriptor can
          * describe a broadcast to 256 uv hubs.
          */
@@ -1365,12 +1373,13 @@ uv_activation_descriptor_init(int node, int pnode)
                 memset(bd2, 0, sizeof(struct bau_desc));
                 bd2->header.sw_ack_flag = 1;
                 /*
-                 * base_dest_nodeid is the nasid of the first uvhub
-                 * in the partition. The bit map will indicate uvhub numbers,
-                 * which are 0-N in a partition. Pnodes are unique system-wide.
+                 * The base_dest_nasid set in the message header is the nasid
+                 * of the first uvhub in the partition. The bit map will
+                 * indicate destination pnode numbers relative to that base.
+                 * They may not be consecutive if nasid striding is being used.
                  */
-                bd2->header.base_dest_nodeid = UV_PNODE_TO_NASID(uv_partition_base_pnode);
-                bd2->header.dest_subnodeid = 0x10; /* the LB */
+                bd2->header.base_dest_nasid = UV_PNODE_TO_NASID(base_pnode);
+                bd2->header.dest_subnodeid = UV_LB_SUBNODEID;
                 bd2->header.command = UV_NET_ENDPOINT_INTD;
                 bd2->header.int_both = 1;
                 /*
@@ -1442,7 +1451,7 @@ uv_payload_queue_init(int node, int pnode)
 /*
  * Initialization of each UV hub's structures
  */
-static void __init uv_init_uvhub(int uvhub, int vector)
+static void __init uv_init_uvhub(int uvhub, int vector, int base_pnode)
 {
         int node;
         int pnode;
@@ -1450,11 +1459,11 @@ static void __init uv_init_uvhub(int uvhub, int vector)
 
         node = uvhub_to_first_node(uvhub);
         pnode = uv_blade_to_pnode(uvhub);
-        uv_activation_descriptor_init(node, pnode);
+        uv_activation_descriptor_init(node, pnode, base_pnode);
         uv_payload_queue_init(node, pnode);
         /*
-         * the below initialization can't be in firmware because the
-         * messaging IRQ will be determined by the OS
+         * The below initialization can't be in firmware because the
+         * messaging IRQ will be determined by the OS.
          */
         apicid = uvhub_to_first_apicid(uvhub) | uv_apicid_hibits;
         uv_write_global_mmr64(pnode, UVH_BAU_DATA_CONFIG,
@@ -1491,10 +1500,11 @@ calculate_destination_timeout(void)
 /*
  * initialize the bau_control structure for each cpu
  */
-static int __init uv_init_per_cpu(int nuvhubs)
+static int __init uv_init_per_cpu(int nuvhubs, int base_part_pnode)
 {
         int i;
         int cpu;
+        int tcpu;
         int pnode;
         int uvhub;
         int have_hmaster;
@@ -1528,6 +1538,15 @@ static int __init uv_init_per_cpu(int nuvhubs)
                 bcp = &per_cpu(bau_control, cpu);
                 memset(bcp, 0, sizeof(struct bau_control));
                 pnode = uv_cpu_hub_info(cpu)->pnode;
+                if ((pnode - base_part_pnode) >= UV_DISTRIBUTION_SIZE) {
+                        printk(KERN_EMERG
+                                "cpu %d pnode %d-%d beyond %d; BAU disabled\n",
+                                cpu, pnode, base_part_pnode,
+                                UV_DISTRIBUTION_SIZE);
+                        return 1;
+                }
+                bcp->osnode = cpu_to_node(cpu);
+                bcp->partition_base_pnode = uv_partition_base_pnode;
                 uvhub = uv_cpu_hub_info(cpu)->numa_blade_id;
                 *(uvhub_mask + (uvhub/8)) |= (1 << (uvhub%8));
                 bdp = &uvhub_descs[uvhub];
@@ -1536,7 +1555,7 @@ static int __init uv_init_per_cpu(int nuvhubs)
                 bdp->pnode = pnode;
                 /* kludge: 'assuming' one node per socket, and assuming that
                    disabling a socket just leaves a gap in node numbers */
-                socket = (cpu_to_node(cpu) & 1);
+                socket = bcp->osnode & 1;
                 bdp->socket_mask |= (1 << socket);
                 sdp = &bdp->socket[socket];
                 sdp->cpu_number[sdp->num_cpus] = cpu;
@@ -1585,6 +1604,20 @@ static int __init uv_init_per_cpu(int nuvhubs)
 nextsocket:
                         socket++;
                         socket_mask = (socket_mask >> 1);
+                        /* each socket gets a local array of pnodes/hubs */
+                        bcp = smaster;
+                        bcp->target_hub_and_pnode = kmalloc_node(
+                                sizeof(struct hub_and_pnode) *
+                                num_possible_cpus(), GFP_KERNEL, bcp->osnode);
+                        memset(bcp->target_hub_and_pnode, 0,
+                                sizeof(struct hub_and_pnode) *
+                                num_possible_cpus());
+                        for_each_present_cpu(tcpu) {
+                                bcp->target_hub_and_pnode[tcpu].pnode =
+                                        uv_cpu_hub_info(tcpu)->pnode;
+                                bcp->target_hub_and_pnode[tcpu].uvhub =
+                                        uv_cpu_hub_info(tcpu)->numa_blade_id;
+                        }
                 }
         }
         kfree(uvhub_descs);
@@ -1637,21 +1670,22 @@ static int __init uv_bau_init(void)
         spin_lock_init(&disable_lock);
         congested_cycles = microsec_2_cycles(congested_response_us);
 
-        if (uv_init_per_cpu(nuvhubs)) {
-                nobau = 1;
-                return 0;
-        }
-
         uv_partition_base_pnode = 0x7fffffff;
-        for (uvhub = 0; uvhub < nuvhubs; uvhub++)
+        for (uvhub = 0; uvhub < nuvhubs; uvhub++) {
                 if (uv_blade_nr_possible_cpus(uvhub) &&
                         (uv_blade_to_pnode(uvhub) < uv_partition_base_pnode))
                         uv_partition_base_pnode = uv_blade_to_pnode(uvhub);
+        }
+
+        if (uv_init_per_cpu(nuvhubs, uv_partition_base_pnode)) {
+                nobau = 1;
+                return 0;
+        }
 
         vector = UV_BAU_MESSAGE;
         for_each_possible_blade(uvhub)
                 if (uv_blade_nr_possible_cpus(uvhub))
-                        uv_init_uvhub(uvhub, vector);
+                        uv_init_uvhub(uvhub, vector, uv_partition_base_pnode);
 
         uv_enable_timeouts();
         alloc_intr_gate(vector, uv_bau_message_intr1);
diff --git a/arch/x86/platform/uv/uv_time.c b/arch/x86/platform/uv/uv_time.c
index 9daf5d1af9f1..0eb90184515f 100644
--- a/arch/x86/platform/uv/uv_time.c
+++ b/arch/x86/platform/uv/uv_time.c
@@ -40,7 +40,6 @@ static struct clocksource clocksource_uv = {
         .rating         = 400,
         .read           = uv_read_rtc,
         .mask           = (cycle_t)UVH_RTC_REAL_TIME_CLOCK_MASK,
-        .shift          = 10,
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
@@ -372,14 +371,11 @@ static __init int uv_rtc_setup_clock(void)
         if (!is_uv_system())
                 return -ENODEV;
 
-        clocksource_uv.mult = clocksource_hz2mult(sn_rtc_cycles_per_second,
-                                clocksource_uv.shift);
-
         /* If single blade, prefer tsc */
         if (uv_num_possible_blades() == 1)
                 clocksource_uv.rating = 250;
 
-        rc = clocksource_register(&clocksource_uv);
+        rc = clocksource_register_hz(&clocksource_uv, sn_rtc_cycles_per_second);
         if (rc)
                 printk(KERN_INFO "UV RTC clocksource failed rc %d\n", rc);
         else
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index e3c6a06cf725..dd7b88f2ec7a 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -235,7 +235,7 @@ static void xen_cpuid(unsigned int *ax, unsigned int *bx,
         *dx &= maskedx;
 }
 
-static __init void xen_init_cpuid_mask(void)
+static void __init xen_init_cpuid_mask(void)
 {
         unsigned int ax, bx, cx, dx;
         unsigned int xsave_mask;
@@ -400,7 +400,7 @@ static void xen_load_gdt(const struct desc_ptr *dtr)
 /*
  * load_gdt for early boot, when the gdt is only mapped once
  */
-static __init void xen_load_gdt_boot(const struct desc_ptr *dtr)
+static void __init xen_load_gdt_boot(const struct desc_ptr *dtr)
 {
         unsigned long va = dtr->address;
         unsigned int size = dtr->size + 1;
@@ -662,7 +662,7 @@ static void xen_write_gdt_entry(struct desc_struct *dt, int entry,
  * Version of write_gdt_entry for use at early boot-time needed to
  * update an entry as simply as possible.
  */
-static __init void xen_write_gdt_entry_boot(struct desc_struct *dt, int entry,
+static void __init xen_write_gdt_entry_boot(struct desc_struct *dt, int entry,
                                             const void *desc, int type)
 {
         switch (type) {
@@ -933,18 +933,18 @@ static unsigned xen_patch(u8 type, u16 clobbers, void *insnbuf,
         return ret;
 }
 
-static const struct pv_info xen_info __initdata = {
+static const struct pv_info xen_info __initconst = {
         .paravirt_enabled = 1,
         .shared_kernel_pmd = 0,
 
         .name = "Xen",
 };
 
-static const struct pv_init_ops xen_init_ops __initdata = {
+static const struct pv_init_ops xen_init_ops __initconst = {
         .patch = xen_patch,
 };
 
-static const struct pv_cpu_ops xen_cpu_ops __initdata = {
+static const struct pv_cpu_ops xen_cpu_ops __initconst = {
         .cpuid = xen_cpuid,
 
         .set_debugreg = xen_set_debugreg,
@@ -1004,7 +1004,7 @@ static const struct pv_cpu_ops xen_cpu_ops __initdata = {
         .end_context_switch = xen_end_context_switch,
 };
 
-static const struct pv_apic_ops xen_apic_ops __initdata = {
+static const struct pv_apic_ops xen_apic_ops __initconst = {
 #ifdef CONFIG_X86_LOCAL_APIC
         .startup_ipi_hook = paravirt_nop,
 #endif
@@ -1055,7 +1055,7 @@ int xen_panic_handler_init(void)
         return 0;
 }
 
-static const struct machine_ops __initdata xen_machine_ops = {
+static const struct machine_ops xen_machine_ops __initconst = {
         .restart = xen_restart,
         .halt = xen_machine_halt,
         .power_off = xen_machine_halt,
@@ -1332,7 +1332,7 @@ static int __cpuinit xen_hvm_cpu_notify(struct notifier_block *self,
         return NOTIFY_OK;
 }
 
-static struct notifier_block __cpuinitdata xen_hvm_cpu_notifier = {
+static struct notifier_block xen_hvm_cpu_notifier __cpuinitdata = {
         .notifier_call  = xen_hvm_cpu_notify,
 };
 
@@ -1381,7 +1381,7 @@ bool xen_hvm_need_lapic(void)
 }
 EXPORT_SYMBOL_GPL(xen_hvm_need_lapic);
 
-const __refconst struct hypervisor_x86 x86_hyper_xen_hvm = {
+const struct hypervisor_x86 x86_hyper_xen_hvm __refconst = {
         .name                   = "Xen HVM",
         .detect                 = xen_hvm_platform,
         .init_platform          = xen_hvm_guest_init,
diff --git a/arch/x86/xen/irq.c b/arch/x86/xen/irq.c
index 6a6fe8939645..8bbb465b6f0a 100644
--- a/arch/x86/xen/irq.c
+++ b/arch/x86/xen/irq.c
@@ -113,7 +113,7 @@ static void xen_halt(void)
                 xen_safe_halt();
 }
 
-static const struct pv_irq_ops xen_irq_ops __initdata = {
+static const struct pv_irq_ops xen_irq_ops __initconst = {
         .save_fl = PV_CALLEE_SAVE(xen_save_fl),
         .restore_fl = PV_CALLEE_SAVE(xen_restore_fl),
         .irq_disable = PV_CALLEE_SAVE(xen_irq_disable),
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
index 0684f3c74d53..02d752460371 100644
--- a/arch/x86/xen/mmu.c
+++ b/arch/x86/xen/mmu.c
@@ -1054,7 +1054,7 @@ void xen_mm_pin_all(void)
  * that's before we have page structures to store the bits.  So do all
  * the book-keeping now.
  */
-static __init int xen_mark_pinned(struct mm_struct *mm, struct page *page,
+static int __init xen_mark_pinned(struct mm_struct *mm, struct page *page,
                                   enum pt_level level)
 {
         SetPagePinned(page);
@@ -1187,7 +1187,7 @@ static void drop_other_mm_ref(void *info)
 
         active_mm = percpu_read(cpu_tlbstate.active_mm);
 
-        if (active_mm == mm)
+        if (active_mm == mm && percpu_read(cpu_tlbstate.state) != TLBSTATE_OK)
                 leave_mm(smp_processor_id());
 
         /* If this cpu still has a stale cr3 reference, then make sure
@@ -1271,7 +1271,7 @@ void xen_exit_mmap(struct mm_struct *mm)
         spin_unlock(&mm->page_table_lock);
 }
 
-static __init void xen_pagetable_setup_start(pgd_t *base)
+static void __init xen_pagetable_setup_start(pgd_t *base)
 {
 }
 
@@ -1291,7 +1291,7 @@ static __init void xen_mapping_pagetable_reserve(u64 start, u64 end)
 
 static void xen_post_allocator_init(void);
 
-static __init void xen_pagetable_setup_done(pgd_t *base)
+static void __init xen_pagetable_setup_done(pgd_t *base)
 {
         xen_setup_shared_info();
         xen_post_allocator_init();
@@ -1488,7 +1488,7 @@ static void xen_pgd_free(struct mm_struct *mm, pgd_t *pgd)
 }
 
 #ifdef CONFIG_X86_32
-static __init pte_t mask_rw_pte(pte_t *ptep, pte_t pte)
+static pte_t __init mask_rw_pte(pte_t *ptep, pte_t pte)
 {
         /* If there's an existing pte, then don't allow _PAGE_RW to be set */
         if (pte_val_ma(*ptep) & _PAGE_PRESENT)
@@ -1498,7 +1498,7 @@ static __init pte_t mask_rw_pte(pte_t *ptep, pte_t pte)
         return pte;
 }
 #else /* CONFIG_X86_64 */
-static __init pte_t mask_rw_pte(pte_t *ptep, pte_t pte)
+static pte_t __init mask_rw_pte(pte_t *ptep, pte_t pte)
 {
         unsigned long pfn = pte_pfn(pte);
 
@@ -1519,7 +1519,7 @@ static __init pte_t mask_rw_pte(pte_t *ptep, pte_t pte)
 
 /* Init-time set_pte while constructing initial pagetables, which
    doesn't allow RO pagetable pages to be remapped RW */
-static __init void xen_set_pte_init(pte_t *ptep, pte_t pte)
+static void __init xen_set_pte_init(pte_t *ptep, pte_t pte)
 {
         pte = mask_rw_pte(ptep, pte);
 
@@ -1537,7 +1537,7 @@ static void pin_pagetable_pfn(unsigned cmd, unsigned long pfn)
 
 /* Early in boot, while setting up the initial pagetable, assume
    everything is pinned. */
-static __init void xen_alloc_pte_init(struct mm_struct *mm, unsigned long pfn)
+static void __init xen_alloc_pte_init(struct mm_struct *mm, unsigned long pfn)
 {
 #ifdef CONFIG_FLATMEM
         BUG_ON(mem_map);        /* should only be used early */
@@ -1547,7 +1547,7 @@ static __init void xen_alloc_pte_init(struct mm_struct *mm, unsigned long pfn)
 }
 
 /* Used for pmd and pud */
-static __init void xen_alloc_pmd_init(struct mm_struct *mm, unsigned long pfn)
+static void __init xen_alloc_pmd_init(struct mm_struct *mm, unsigned long pfn)
 {
 #ifdef CONFIG_FLATMEM
         BUG_ON(mem_map);        /* should only be used early */
@@ -1557,13 +1557,13 @@ static __init void xen_alloc_pmd_init(struct mm_struct *mm, unsigned long pfn)
 
 /* Early release_pte assumes that all pts are pinned, since there's
    only init_mm and anything attached to that is pinned. */
-static __init void xen_release_pte_init(unsigned long pfn)
+static void __init xen_release_pte_init(unsigned long pfn)
 {
         pin_pagetable_pfn(MMUEXT_UNPIN_TABLE, pfn);
         make_lowmem_page_readwrite(__va(PFN_PHYS(pfn)));
 }
 
-static __init void xen_release_pmd_init(unsigned long pfn)
+static void __init xen_release_pmd_init(unsigned long pfn)
 {
         make_lowmem_page_readwrite(__va(PFN_PHYS(pfn)));
 }
@@ -1689,7 +1689,7 @@ static void set_page_prot(void *addr, pgprot_t prot)
                 BUG();
 }
 
-static __init void xen_map_identity_early(pmd_t *pmd, unsigned long max_pfn)
+static void __init xen_map_identity_early(pmd_t *pmd, unsigned long max_pfn)
 {
         unsigned pmdidx, pteidx;
         unsigned ident_pte;
@@ -1772,7 +1772,7 @@ static void convert_pfn_mfn(void *v)
  * of the physical mapping once some sort of allocator has been set
  * up.
  */
-__init pgd_t *xen_setup_kernel_pagetable(pgd_t *pgd,
+pgd_t * __init xen_setup_kernel_pagetable(pgd_t *pgd,
                                          unsigned long max_pfn)
 {
         pud_t *l3;
@@ -1843,7 +1843,7 @@ __init pgd_t *xen_setup_kernel_pagetable(pgd_t *pgd,
 static RESERVE_BRK_ARRAY(pmd_t, initial_kernel_pmd, PTRS_PER_PMD);
 static RESERVE_BRK_ARRAY(pmd_t, swapper_kernel_pmd, PTRS_PER_PMD);
 
-static __init void xen_write_cr3_init(unsigned long cr3)
+static void __init xen_write_cr3_init(unsigned long cr3)
 {
         unsigned long pfn = PFN_DOWN(__pa(swapper_pg_dir));
 
@@ -1880,7 +1880,7 @@ static __init void xen_write_cr3_init(unsigned long cr3)
         pv_mmu_ops.write_cr3 = &xen_write_cr3;
 }
 
-__init pgd_t *xen_setup_kernel_pagetable(pgd_t *pgd,
+pgd_t * __init xen_setup_kernel_pagetable(pgd_t *pgd,
                                          unsigned long max_pfn)
 {
         pmd_t *kernel_pmd;
@@ -1986,7 +1986,7 @@ static void xen_set_fixmap(unsigned idx, phys_addr_t phys, pgprot_t prot)
 #endif
 }
 
-__init void xen_ident_map_ISA(void)
+void __init xen_ident_map_ISA(void)
 {
         unsigned long pa;
 
@@ -2009,7 +2009,7 @@ __init void xen_ident_map_ISA(void)
         xen_flush_tlb();
 }
 
-static __init void xen_post_allocator_init(void)
+static void __init xen_post_allocator_init(void)
 {
 #ifdef CONFIG_XEN_DEBUG
         pv_mmu_ops.make_pte = PV_CALLEE_SAVE(xen_make_pte_debug);
@@ -2046,7 +2046,7 @@ static void xen_leave_lazy_mmu(void)
         preempt_enable();
 }
 
-static const struct pv_mmu_ops xen_mmu_ops __initdata = {
+static const struct pv_mmu_ops xen_mmu_ops __initconst = {
         .read_cr2 = xen_read_cr2,
         .write_cr2 = xen_write_cr2,
 
diff --git a/arch/x86/xen/p2m.c b/arch/x86/xen/p2m.c
index 141eb0de8b06..58efeb9d5440 100644
--- a/arch/x86/xen/p2m.c
+++ b/arch/x86/xen/p2m.c
@@ -522,11 +522,20 @@ static bool __init __early_alloc_p2m(unsigned long pfn)
         /* Boundary cross-over for the edges: */
         if (idx) {
                 unsigned long *p2m = extend_brk(PAGE_SIZE, PAGE_SIZE);
+                unsigned long *mid_mfn_p;
 
                 p2m_init(p2m);
 
                 p2m_top[topidx][mididx] = p2m;
 
+                /* For save/restore we need to MFN of the P2M saved */
+                
+                mid_mfn_p = p2m_top_mfn_p[topidx];
+                WARN(mid_mfn_p[mididx] != virt_to_mfn(p2m_missing),
+                        "P2M_TOP_P[%d][%d] != MFN of p2m_missing!\n",
+                        topidx, mididx);
+                mid_mfn_p[mididx] = virt_to_mfn(p2m);
+
         }
         return idx != 0;
 }
@@ -549,12 +558,29 @@ unsigned long __init set_phys_range_identity(unsigned long pfn_s,
                 pfn += P2M_MID_PER_PAGE * P2M_PER_PAGE)
         {
                 unsigned topidx = p2m_top_index(pfn);
-                if (p2m_top[topidx] == p2m_mid_missing) {
-                        unsigned long **mid = extend_brk(PAGE_SIZE, PAGE_SIZE);
+                unsigned long *mid_mfn_p;
+                unsigned long **mid;
+
+                mid = p2m_top[topidx];
+                mid_mfn_p = p2m_top_mfn_p[topidx];
+                if (mid == p2m_mid_missing) {
+                        mid = extend_brk(PAGE_SIZE, PAGE_SIZE);
 
                         p2m_mid_init(mid);
 
                         p2m_top[topidx] = mid;
+
+                        BUG_ON(mid_mfn_p != p2m_mid_missing_mfn);
+                }
+                /* And the save/restore P2M tables.. */
+                if (mid_mfn_p == p2m_mid_missing_mfn) {
+                        mid_mfn_p = extend_brk(PAGE_SIZE, PAGE_SIZE);
+                        p2m_mid_mfn_init(mid_mfn_p);
+
+                        p2m_top_mfn_p[topidx] = mid_mfn_p;
+                        p2m_top_mfn[topidx] = virt_to_mfn(mid_mfn_p);
+                        /* Note: we don't set mid_mfn_p[midix] here,
+                         * look in __early_alloc_p2m */
                 }
         }
 
@@ -650,7 +676,7 @@ static unsigned long mfn_hash(unsigned long mfn)
 }
 
 /* Add an MFN override for a particular page */
-int m2p_add_override(unsigned long mfn, struct page *page)
+int m2p_add_override(unsigned long mfn, struct page *page, bool clear_pte)
 {
         unsigned long flags;
         unsigned long pfn;
@@ -662,7 +688,6 @@ int m2p_add_override(unsigned long mfn, struct page *page)
         if (!PageHighMem(page)) {
                 address = (unsigned long)__va(pfn << PAGE_SHIFT);
                 ptep = lookup_address(address, &level);
-
                 if (WARN(ptep == NULL || level != PG_LEVEL_4K,
                                         "m2p_add_override: pfn %lx not mapped", pfn))
                         return -EINVAL;
@@ -674,18 +699,17 @@ int m2p_add_override(unsigned long mfn, struct page *page)
         if (unlikely(!set_phys_to_machine(pfn, FOREIGN_FRAME(mfn))))
                 return -ENOMEM;
 
-        if (!PageHighMem(page))
+        if (clear_pte && !PageHighMem(page))
                 /* Just zap old mapping for now */
                 pte_clear(&init_mm, address, ptep);
-
         spin_lock_irqsave(&m2p_override_lock, flags);
         list_add(&page->lru,  &m2p_overrides[mfn_hash(mfn)]);
         spin_unlock_irqrestore(&m2p_override_lock, flags);
 
         return 0;
 }
-
-int m2p_remove_override(struct page *page)
+EXPORT_SYMBOL_GPL(m2p_add_override);
+int m2p_remove_override(struct page *page, bool clear_pte)
 {
         unsigned long flags;
         unsigned long mfn;
@@ -713,7 +737,7 @@ int m2p_remove_override(struct page *page)
         spin_unlock_irqrestore(&m2p_override_lock, flags);
         set_phys_to_machine(pfn, page->index);
 
-        if (!PageHighMem(page))
+        if (clear_pte && !PageHighMem(page))
                 set_pte_at(&init_mm, address, ptep,
                                 pfn_pte(pfn, PAGE_KERNEL));
                 /* No tlb flush necessary because the caller already
@@ -721,6 +745,7 @@ int m2p_remove_override(struct page *page)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(m2p_remove_override);
 
 struct page *m2p_find_override(unsigned long mfn)
 {
diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
index 90bac0aac3a5..be1a464f6d66 100644
--- a/arch/x86/xen/setup.c
+++ b/arch/x86/xen/setup.c
@@ -50,7 +50,7 @@ phys_addr_t xen_extra_mem_start, xen_extra_mem_size;
  */
 #define EXTRA_MEM_RATIO         (10)
 
-static __init void xen_add_extra_mem(unsigned long pages)
+static void __init xen_add_extra_mem(unsigned long pages)
 {
         unsigned long pfn;
 
@@ -166,7 +166,7 @@ static unsigned long __init xen_set_identity(const struct e820entry *list,
                 if (last > end)
                         continue;
 
-                if (entry->type == E820_RAM) {
+                if ((entry->type == E820_RAM) || (entry->type == E820_UNUSABLE)) {
                         if (start > start_pci)
                                 identity += set_phys_range_identity(
                                                 PFN_UP(start_pci), PFN_DOWN(start));
@@ -227,7 +227,11 @@ char * __init xen_memory_setup(void)
 
         memcpy(map_raw, map, sizeof(map));
         e820.nr_map = 0;
+#ifdef CONFIG_X86_32
+        xen_extra_mem_start = mem_end;
+#else
         xen_extra_mem_start = max((1ULL << 32), mem_end);
+#endif
         for (i = 0; i < memmap.nr_entries; i++) {
                 unsigned long long end;
 
@@ -336,7 +340,7 @@ static void __init fiddle_vdso(void)
 #endif
 }
 
-static __cpuinit int register_callback(unsigned type, const void *func)
+static int __cpuinit register_callback(unsigned type, const void *func)
 {
         struct callback_register callback = {
                 .type = type,
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index 30612441ed99..41038c01de40 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -46,18 +46,17 @@ static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id);
 static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id);
 
 /*
- * Reschedule call back. Nothing to do,
- * all the work is done automatically when
- * we return from the interrupt.
+ * Reschedule call back.
  */
 static irqreturn_t xen_reschedule_interrupt(int irq, void *dev_id)
 {
         inc_irq_stat(irq_resched_count);
+        scheduler_ipi();
 
         return IRQ_HANDLED;
 }
 
-static __cpuinit void cpu_bringup(void)
+static void __cpuinit cpu_bringup(void)
 {
         int cpu = smp_processor_id();
 
@@ -85,7 +84,7 @@ static __cpuinit void cpu_bringup(void)
         wmb();                  /* make sure everything is out */
 }
 
-static __cpuinit void cpu_bringup_and_idle(void)
+static void __cpuinit cpu_bringup_and_idle(void)
 {
         cpu_bringup();
         cpu_idle();
@@ -242,7 +241,7 @@ static void __init xen_smp_prepare_cpus(unsigned int max_cpus)
         }
 }
 
-static __cpuinit int
+static int __cpuinit
 cpu_initialize_context(unsigned int cpu, struct task_struct *idle)
 {
         struct vcpu_guest_context *ctxt;
@@ -486,7 +485,7 @@ static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static const struct smp_ops xen_smp_ops __initdata = {
+static const struct smp_ops xen_smp_ops __initconst = {
         .smp_prepare_boot_cpu = xen_smp_prepare_boot_cpu,
         .smp_prepare_cpus = xen_smp_prepare_cpus,
         .smp_cpus_done = xen_smp_cpus_done,
diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index 2e2d370a47b1..5158c505bef9 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -26,8 +26,6 @@
 
 #include "xen-ops.h"
 
-#define XEN_SHIFT 22
-
 /* Xen may fire a timer up to this many ns early */
 #define TIMER_SLOP      100000
 #define NS_PER_TICK     (1000000000LL / HZ)
@@ -211,8 +209,6 @@ static struct clocksource xen_clocksource __read_mostly = {
         .rating = 400,
         .read = xen_clocksource_get_cycles,
         .mask = ~0,
-        .mult = 1<<XEN_SHIFT,           /* time directly in nanoseconds */
-        .shift = XEN_SHIFT,
         .flags = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
@@ -439,16 +435,16 @@ void xen_timer_resume(void)
         }
 }
 
-static const struct pv_time_ops xen_time_ops __initdata = {
+static const struct pv_time_ops xen_time_ops __initconst = {
         .sched_clock = xen_clocksource_read,
 };
 
-static __init void xen_time_init(void)
+static void __init xen_time_init(void)
 {
         int cpu = smp_processor_id();
         struct timespec tp;
 
-        clocksource_register(&xen_clocksource);
+        clocksource_register_hz(&xen_clocksource, NSEC_PER_SEC);
 
         if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL) == 0) {
                 /* Successfully turned off 100Hz tick, so we have the
@@ -468,7 +464,7 @@ static __init void xen_time_init(void)
         xen_setup_cpu_clockevents();
 }
 
-__init void xen_init_time_ops(void)
+void __init xen_init_time_ops(void)
 {
         pv_time_ops = xen_time_ops;
 
@@ -490,7 +486,7 @@ static void xen_hvm_setup_cpu_clockevents(void)
         xen_setup_cpu_clockevents();
 }
 
-__init void xen_hvm_init_time_ops(void)
+void __init xen_hvm_init_time_ops(void)
 {
         /* vector callback is needed otherwise we cannot receive interrupts
          * on cpu > 0 and at this point we don't know how many cpus are
diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h
index 3112f55638c4..97dfdc8757b3 100644
--- a/arch/x86/xen/xen-ops.h
+++ b/arch/x86/xen/xen-ops.h
@@ -74,7 +74,7 @@ static inline void xen_hvm_smp_init(void) {}
 
 #ifdef CONFIG_PARAVIRT_SPINLOCKS
 void __init xen_init_spinlocks(void);
-__cpuinit void xen_init_lock_cpu(int cpu);
+void __cpuinit xen_init_lock_cpu(int cpu);
 void xen_uninit_lock_cpu(int cpu);
 #else
 static inline void xen_init_spinlocks(void)