25 files changed, 882 insertions, 185 deletions

diff --git a/arch/x86/platform/efi/efi-bgrt.c b/arch/x86/platform/efi/efi-bgrt.c
index 7145ec63c520..f15103dff4b4 100644
--- a/arch/x86/platform/efi/efi-bgrt.c
+++ b/arch/x86/platform/efi/efi-bgrt.c
@@ -42,14 +42,15 @@ void __init efi_bgrt_init(void)
 
         if (bgrt_tab->header.length < sizeof(*bgrt_tab))
                 return;
-        if (bgrt_tab->version != 1)
+        if (bgrt_tab->version != 1 || bgrt_tab->status != 1)
                 return;
         if (bgrt_tab->image_type != 0 || !bgrt_tab->image_address)
                 return;
 
         image = efi_lookup_mapped_addr(bgrt_tab->image_address);
         if (!image) {
-                image = ioremap(bgrt_tab->image_address, sizeof(bmp_header));
+                image = early_memremap(bgrt_tab->image_address,
+                                       sizeof(bmp_header));
                 ioremapped = true;
                 if (!image)
                         return;
@@ -57,7 +58,7 @@ void __init efi_bgrt_init(void)
 
         memcpy_fromio(&bmp_header, image, sizeof(bmp_header));
         if (ioremapped)
-                iounmap(image);
+                early_iounmap(image, sizeof(bmp_header));
         bgrt_image_size = bmp_header.size;
 
         bgrt_image = kmalloc(bgrt_image_size, GFP_KERNEL);
@@ -65,7 +66,8 @@ void __init efi_bgrt_init(void)
                 return;
 
         if (ioremapped) {
-                image = ioremap(bgrt_tab->image_address, bmp_header.size);
+                image = early_memremap(bgrt_tab->image_address,
+                                       bmp_header.size);
                 if (!image) {
                         kfree(bgrt_image);
                         bgrt_image = NULL;
@@ -75,5 +77,5 @@ void __init efi_bgrt_init(void)
 
         memcpy_fromio(bgrt_image, image, bgrt_image_size);
         if (ioremapped)
-                iounmap(image);
+                early_iounmap(image, bmp_header.size);
 }
diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index cceb813044ef..b97acecf3fd9 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -12,6 +12,8 @@
  *      Bibo Mao <bibo.mao@intel.com>
  *      Chandramouli Narayanan <mouli@linux.intel.com>
  *      Huang Ying <ying.huang@intel.com>
+ * Copyright (C) 2013 SuSE Labs
+ *      Borislav Petkov <bp@suse.de> - runtime services VA mapping
  *
  * Copied from efi_32.c to eliminate the duplicated code between EFI
  * 32/64 support code. --ying 2007-10-26
@@ -50,8 +52,9 @@
 #include <asm/tlbflush.h>
 #include <asm/x86_init.h>
 #include <asm/rtc.h>
+#include <asm/uv/uv.h>
 
-#define EFI_DEBUG       1
+#define EFI_DEBUG
 
 #define EFI_MIN_RESERVE 5120
 
@@ -74,6 +77,8 @@ static __initdata efi_config_table_type_t arch_tables[] = {
         {NULL_GUID, NULL, NULL},
 };
 
+u64 efi_setup;          /* efi setup_data physical address */
+
 /*
  * Returns 1 if 'facility' is enabled, 0 otherwise.
  */
@@ -110,7 +115,6 @@ static int __init setup_storage_paranoia(char *arg)
 }
 early_param("efi_no_storage_paranoia", setup_storage_paranoia);
 
-
 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
 {
         unsigned long flags;
@@ -398,9 +402,9 @@ int __init efi_memblock_x86_reserve_range(void)
         return 0;
 }
 
-#if EFI_DEBUG
 static void __init print_efi_memmap(void)
 {
+#ifdef EFI_DEBUG
         efi_memory_desc_t *md;
         void *p;
         int i;
@@ -415,8 +419,8 @@ static void __init print_efi_memmap(void)
                         md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
                         (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
         }
-}
 #endif  /*  EFI_DEBUG  */
+}
 
 void __init efi_reserve_boot_services(void)
 {
@@ -436,7 +440,7 @@ void __init efi_reserve_boot_services(void)
                  * - Not within any part of the kernel
                  * - Not the bios reserved area
                 */
-                if ((start+size >= __pa_symbol(_text)
+                if ((start + size > __pa_symbol(_text)
                                 && start <= __pa_symbol(_end)) ||
                         !e820_all_mapped(start, start+size, E820_RAM) ||
                         memblock_is_region_reserved(start, size)) {
@@ -489,18 +493,27 @@ static int __init efi_systab_init(void *phys)
 {
         if (efi_enabled(EFI_64BIT)) {
                 efi_system_table_64_t *systab64;
+                struct efi_setup_data *data = NULL;
                 u64 tmp = 0;
 
+                if (efi_setup) {
+                        data = early_memremap(efi_setup, sizeof(*data));
+                        if (!data)
+                                return -ENOMEM;
+                }
                 systab64 = early_ioremap((unsigned long)phys,
                                          sizeof(*systab64));
                 if (systab64 == NULL) {
                         pr_err("Couldn't map the system table!\n");
+                        if (data)
+                                early_iounmap(data, sizeof(*data));
                         return -ENOMEM;
                 }
 
                 efi_systab.hdr = systab64->hdr;
-                efi_systab.fw_vendor = systab64->fw_vendor;
-                tmp |= systab64->fw_vendor;
+                efi_systab.fw_vendor = data ? (unsigned long)data->fw_vendor :
+                                              systab64->fw_vendor;
+                tmp |= data ? data->fw_vendor : systab64->fw_vendor;
                 efi_systab.fw_revision = systab64->fw_revision;
                 efi_systab.con_in_handle = systab64->con_in_handle;
                 tmp |= systab64->con_in_handle;
@@ -514,15 +527,20 @@ static int __init efi_systab_init(void *phys)
                 tmp |= systab64->stderr_handle;
                 efi_systab.stderr = systab64->stderr;
                 tmp |= systab64->stderr;
-                efi_systab.runtime = (void *)(unsigned long)systab64->runtime;
-                tmp |= systab64->runtime;
+                efi_systab.runtime = data ?
+                                     (void *)(unsigned long)data->runtime :
+                                     (void *)(unsigned long)systab64->runtime;
+                tmp |= data ? data->runtime : systab64->runtime;
                 efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
                 tmp |= systab64->boottime;
                 efi_systab.nr_tables = systab64->nr_tables;
-                efi_systab.tables = systab64->tables;
-                tmp |= systab64->tables;
+                efi_systab.tables = data ? (unsigned long)data->tables :
+                                           systab64->tables;
+                tmp |= data ? data->tables : systab64->tables;
 
                 early_iounmap(systab64, sizeof(*systab64));
+                if (data)
+                        early_iounmap(data, sizeof(*data));
 #ifdef CONFIG_X86_32
                 if (tmp >> 32) {
                         pr_err("EFI data located above 4GB, disabling EFI.\n");
@@ -626,6 +644,62 @@ static int __init efi_memmap_init(void)
         return 0;
 }
 
+/*
+ * A number of config table entries get remapped to virtual addresses
+ * after entering EFI virtual mode. However, the kexec kernel requires
+ * their physical addresses therefore we pass them via setup_data and
+ * correct those entries to their respective physical addresses here.
+ *
+ * Currently only handles smbios which is necessary for some firmware
+ * implementation.
+ */
+static int __init efi_reuse_config(u64 tables, int nr_tables)
+{
+        int i, sz, ret = 0;
+        void *p, *tablep;
+        struct efi_setup_data *data;
+
+        if (!efi_setup)
+                return 0;
+
+        if (!efi_enabled(EFI_64BIT))
+                return 0;
+
+        data = early_memremap(efi_setup, sizeof(*data));
+        if (!data) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        if (!data->smbios)
+                goto out_memremap;
+
+        sz = sizeof(efi_config_table_64_t);
+
+        p = tablep = early_memremap(tables, nr_tables * sz);
+        if (!p) {
+                pr_err("Could not map Configuration table!\n");
+                ret = -ENOMEM;
+                goto out_memremap;
+        }
+
+        for (i = 0; i < efi.systab->nr_tables; i++) {
+                efi_guid_t guid;
+
+                guid = ((efi_config_table_64_t *)p)->guid;
+
+                if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID))
+                        ((efi_config_table_64_t *)p)->table = data->smbios;
+                p += sz;
+        }
+        early_iounmap(tablep, nr_tables * sz);
+
+out_memremap:
+        early_iounmap(data, sizeof(*data));
+out:
+        return ret;
+}
+
 void __init efi_init(void)
 {
         efi_char16_t *c16;
@@ -651,6 +725,10 @@ void __init efi_init(void)
 
         set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility);
 
+        efi.config_table = (unsigned long)efi.systab->tables;
+        efi.fw_vendor    = (unsigned long)efi.systab->fw_vendor;
+        efi.runtime      = (unsigned long)efi.systab->runtime;
+
         /*
          * Show what we know for posterity
          */
@@ -667,6 +745,9 @@ void __init efi_init(void)
                 efi.systab->hdr.revision >> 16,
                 efi.systab->hdr.revision & 0xffff, vendor);
 
+        if (efi_reuse_config(efi.systab->tables, efi.systab->nr_tables))
+                return;
+
         if (efi_config_init(arch_tables))
                 return;
 
@@ -684,15 +765,12 @@ void __init efi_init(void)
                         return;
                 set_bit(EFI_RUNTIME_SERVICES, &x86_efi_facility);
         }
-
         if (efi_memmap_init())
                 return;
 
         set_bit(EFI_MEMMAP, &x86_efi_facility);
 
-#if EFI_DEBUG
         print_efi_memmap();
-#endif
 }
 
 void __init efi_late_init(void)
@@ -715,7 +793,7 @@ void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
                 set_memory_nx(addr, npages);
 }
 
-static void __init runtime_code_page_mkexec(void)
+void __init runtime_code_page_mkexec(void)
 {
         efi_memory_desc_t *md;
         void *p;
@@ -741,36 +819,38 @@ void efi_memory_uc(u64 addr, unsigned long size)
         set_memory_uc(addr, npages);
 }
 
-/*
- * This function will switch the EFI runtime services to virtual mode.
- * Essentially, look through the EFI memmap and map every region that
- * has the runtime attribute bit set in its memory descriptor and update
- * that memory descriptor with the virtual address obtained from ioremap().
- * This enables the runtime services to be called without having to
- * thunk back into physical mode for every invocation.
- */
-void __init efi_enter_virtual_mode(void)
+void __init old_map_region(efi_memory_desc_t *md)
 {
-        efi_memory_desc_t *md, *prev_md = NULL;
-        efi_status_t status;
+        u64 start_pfn, end_pfn, end;
         unsigned long size;
-        u64 end, systab, start_pfn, end_pfn;
-        void *p, *va, *new_memmap = NULL;
-        int count = 0;
+        void *va;
 
-        efi.systab = NULL;
+        start_pfn = PFN_DOWN(md->phys_addr);
+        size      = md->num_pages << PAGE_SHIFT;
+        end       = md->phys_addr + size;
+        end_pfn   = PFN_UP(end);
 
-        /*
-         * We don't do virtual mode, since we don't do runtime services, on
-         * non-native EFI
-         */
+        if (pfn_range_is_mapped(start_pfn, end_pfn)) {
+                va = __va(md->phys_addr);
 
-        if (!efi_is_native()) {
-                efi_unmap_memmap();
-                return;
-        }
+                if (!(md->attribute & EFI_MEMORY_WB))
+                        efi_memory_uc((u64)(unsigned long)va, size);
+        } else
+                va = efi_ioremap(md->phys_addr, size,
+                                 md->type, md->attribute);
+
+        md->virt_addr = (u64) (unsigned long) va;
+        if (!va)
+                pr_err("ioremap of 0x%llX failed!\n",
+                       (unsigned long long)md->phys_addr);
+}
+
+/* Merge contiguous regions of the same type and attribute */
+static void __init efi_merge_regions(void)
+{
+        void *p;
+        efi_memory_desc_t *md, *prev_md = 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;
@@ -796,6 +876,77 @@ void __init efi_enter_virtual_mode(void)
                 }
                 prev_md = md;
         }
+}
+
+static void __init get_systab_virt_addr(efi_memory_desc_t *md)
+{
+        unsigned long size;
+        u64 end, systab;
+
+        size = md->num_pages << EFI_PAGE_SHIFT;
+        end = md->phys_addr + size;
+        systab = (u64)(unsigned long)efi_phys.systab;
+        if (md->phys_addr <= systab && systab < end) {
+                systab += md->virt_addr - md->phys_addr;
+                efi.systab = (efi_system_table_t *)(unsigned long)systab;
+        }
+}
+
+static int __init save_runtime_map(void)
+{
+        efi_memory_desc_t *md;
+        void *tmp, *p, *q = NULL;
+        int count = 0;
+
+        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
+                md = p;
+
+                if (!(md->attribute & EFI_MEMORY_RUNTIME) ||
+                    (md->type == EFI_BOOT_SERVICES_CODE) ||
+                    (md->type == EFI_BOOT_SERVICES_DATA))
+                        continue;
+                tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL);
+                if (!tmp)
+                        goto out;
+                q = tmp;
+
+                memcpy(q + count * memmap.desc_size, md, memmap.desc_size);
+                count++;
+        }
+
+        efi_runtime_map_setup(q, count, memmap.desc_size);
+
+        return 0;
+out:
+        kfree(q);
+        return -ENOMEM;
+}
+
+/*
+ * Map efi regions which were passed via setup_data. The virt_addr is a fixed
+ * addr which was used in first kernel of a kexec boot.
+ */
+static void __init efi_map_regions_fixed(void)
+{
+        void *p;
+        efi_memory_desc_t *md;
+
+        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
+                md = p;
+                efi_map_region_fixed(md); /* FIXME: add error handling */
+                get_systab_virt_addr(md);
+        }
+
+}
+
+/*
+ * Map efi memory ranges for runtime serivce and update new_memmap with virtual
+ * addresses.
+ */
+static void * __init efi_map_regions(int *count)
+{
+        efi_memory_desc_t *md;
+        void *p, *tmp, *new_memmap = NULL;
 
         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
                 md = p;
@@ -807,53 +958,95 @@ void __init efi_enter_virtual_mode(void)
                                 continue;
                 }
 
-                size = md->num_pages << EFI_PAGE_SHIFT;
-                end = md->phys_addr + size;
+                efi_map_region(md);
+                get_systab_virt_addr(md);
 
-                start_pfn = PFN_DOWN(md->phys_addr);
-                end_pfn = PFN_UP(end);
-                if (pfn_range_is_mapped(start_pfn, end_pfn)) {
-                        va = __va(md->phys_addr);
+                tmp = krealloc(new_memmap, (*count + 1) * memmap.desc_size,
+                               GFP_KERNEL);
+                if (!tmp)
+                        goto out;
+                new_memmap = tmp;
+                memcpy(new_memmap + (*count * memmap.desc_size), md,
+                       memmap.desc_size);
+                (*count)++;
+        }
 
-                        if (!(md->attribute & EFI_MEMORY_WB))
-                                efi_memory_uc((u64)(unsigned long)va, size);
-                } else
-                        va = efi_ioremap(md->phys_addr, size,
-                                         md->type, md->attribute);
+        return new_memmap;
+out:
+        kfree(new_memmap);
+        return NULL;
+}
 
-                md->virt_addr = (u64) (unsigned long) va;
+/*
+ * This function will switch the EFI runtime services to virtual mode.
+ * Essentially, we look through the EFI memmap and map every region that
+ * has the runtime attribute bit set in its memory descriptor into the
+ * ->trampoline_pgd page table using a top-down VA allocation scheme.
+ *
+ * The old method which used to update that memory descriptor with the
+ * virtual address obtained from ioremap() is still supported when the
+ * kernel is booted with efi=old_map on its command line. Same old
+ * method enabled the runtime services to be called without having to
+ * thunk back into physical mode for every invocation.
+ *
+ * The new method does a pagetable switch in a preemption-safe manner
+ * so that we're in a different address space when calling a runtime
+ * function. For function arguments passing we do copy the PGDs of the
+ * kernel page table into ->trampoline_pgd prior to each call.
+ *
+ * Specially for kexec boot, efi runtime maps in previous kernel should
+ * be passed in via setup_data. In that case runtime ranges will be mapped
+ * to the same virtual addresses as the first kernel.
+ */
+void __init efi_enter_virtual_mode(void)
+{
+        efi_status_t status;
+        void *new_memmap = NULL;
+        int err, count = 0;
 
-                if (!va) {
-                        pr_err("ioremap of 0x%llX failed!\n",
-                               (unsigned long long)md->phys_addr);
-                        continue;
-                }
+        efi.systab = NULL;
+
+        /*
+         * We don't do virtual mode, since we don't do runtime services, on
+         * non-native EFI
+         */
+        if (!efi_is_native()) {
+                efi_unmap_memmap();
+                return;
+        }
 
-                systab = (u64) (unsigned long) efi_phys.systab;
-                if (md->phys_addr <= systab && systab < end) {
-                        systab += md->virt_addr - md->phys_addr;
-                        efi.systab = (efi_system_table_t *) (unsigned long) systab;
+        if (efi_setup) {
+                efi_map_regions_fixed();
+        } else {
+                efi_merge_regions();
+                new_memmap = efi_map_regions(&count);
+                if (!new_memmap) {
+                        pr_err("Error reallocating memory, EFI runtime non-functional!\n");
+                        return;
                 }
-                new_memmap = krealloc(new_memmap,
-                                      (count + 1) * memmap.desc_size,
-                                      GFP_KERNEL);
-                memcpy(new_memmap + (count * memmap.desc_size), md,
-                       memmap.desc_size);
-                count++;
         }
 
+        err = save_runtime_map();
+        if (err)
+                pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
+
         BUG_ON(!efi.systab);
 
-        status = phys_efi_set_virtual_address_map(
-                memmap.desc_size * count,
-                memmap.desc_size,
-                memmap.desc_version,
-                (efi_memory_desc_t *)__pa(new_memmap));
+        efi_setup_page_tables();
+        efi_sync_low_kernel_mappings();
 
-        if (status != EFI_SUCCESS) {
-                pr_alert("Unable to switch EFI into virtual mode "
-                         "(status=%lx)!\n", status);
-                panic("EFI call to SetVirtualAddressMap() failed!");
+        if (!efi_setup) {
+                status = phys_efi_set_virtual_address_map(
+                        memmap.desc_size * count,
+                        memmap.desc_size,
+                        memmap.desc_version,
+                        (efi_memory_desc_t *)__pa(new_memmap));
+
+                if (status != EFI_SUCCESS) {
+                        pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n",
+                                 status);
+                        panic("EFI call to SetVirtualAddressMap() failed!");
+                }
         }
 
         /*
@@ -876,8 +1069,8 @@ void __init efi_enter_virtual_mode(void)
         efi.query_variable_info = virt_efi_query_variable_info;
         efi.update_capsule = virt_efi_update_capsule;
         efi.query_capsule_caps = virt_efi_query_capsule_caps;
-        if (__supported_pte_mask & _PAGE_NX)
-                runtime_code_page_mkexec();
+
+        efi_runtime_mkexec();
 
         kfree(new_memmap);
 
@@ -1006,3 +1199,34 @@ efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
         return EFI_SUCCESS;
 }
 EXPORT_SYMBOL_GPL(efi_query_variable_store);
+
+static int __init parse_efi_cmdline(char *str)
+{
+        if (*str == '=')
+                str++;
+
+        if (!strncmp(str, "old_map", 7))
+                set_bit(EFI_OLD_MEMMAP, &x86_efi_facility);
+
+        return 0;
+}
+early_param("efi", parse_efi_cmdline);
+
+void __init efi_apply_memmap_quirks(void)
+{
+        /*
+         * Once setup is done earlier, unmap the EFI memory map on mismatched
+         * firmware/kernel architectures since there is no support for runtime
+         * services.
+         */
+        if (!efi_is_native()) {
+                pr_info("efi: Setup done, disabling due to 32/64-bit mismatch\n");
+                efi_unmap_memmap();
+        }
+
+        /*
+         * UV doesn't support the new EFI pagetable mapping yet.
+         */
+        if (is_uv_system())
+                set_bit(EFI_OLD_MEMMAP, &x86_efi_facility);
+}
diff --git a/arch/x86/platform/efi/efi_32.c b/arch/x86/platform/efi/efi_32.c
index 40e446941dd7..0b74cdf7f816 100644
--- a/arch/x86/platform/efi/efi_32.c
+++ b/arch/x86/platform/efi/efi_32.c
@@ -37,9 +37,19 @@
  * claim EFI runtime service handler exclusively and to duplicate a memory in
  * low memory space say 0 - 3G.
  */
-
 static unsigned long efi_rt_eflags;
 
+void efi_sync_low_kernel_mappings(void) {}
+void efi_setup_page_tables(void) {}
+
+void __init efi_map_region(efi_memory_desc_t *md)
+{
+        old_map_region(md);
+}
+
+void __init efi_map_region_fixed(efi_memory_desc_t *md) {}
+void __init parse_efi_setup(u64 phys_addr, u32 data_len) {}
+
 void efi_call_phys_prelog(void)
 {
         struct desc_ptr gdt_descr;
@@ -67,3 +77,9 @@ void efi_call_phys_epilog(void)
 
         local_irq_restore(efi_rt_eflags);
 }
+
+void __init efi_runtime_mkexec(void)
+{
+        if (__supported_pte_mask & _PAGE_NX)
+                runtime_code_page_mkexec();
+}
diff --git a/arch/x86/platform/efi/efi_64.c b/arch/x86/platform/efi/efi_64.c
index 39a0e7f1f0a3..0c2a234fef1e 100644
--- a/arch/x86/platform/efi/efi_64.c
+++ b/arch/x86/platform/efi/efi_64.c
@@ -38,10 +38,28 @@
 #include <asm/efi.h>
 #include <asm/cacheflush.h>
 #include <asm/fixmap.h>
+#include <asm/realmode.h>
 
 static pgd_t *save_pgd __initdata;
 static unsigned long efi_flags __initdata;
 
+/*
+ * We allocate runtime services regions bottom-up, starting from -4G, i.e.
+ * 0xffff_ffff_0000_0000 and limit EFI VA mapping space to 64G.
+ */
+static u64 efi_va       = -4 * (1UL << 30);
+#define EFI_VA_END      (-68 * (1UL << 30))
+
+/*
+ * Scratch space used for switching the pagetable in the EFI stub
+ */
+struct efi_scratch {
+        u64 r15;
+        u64 prev_cr3;
+        pgd_t *efi_pgt;
+        bool use_pgd;
+};
+
 static void __init early_code_mapping_set_exec(int executable)
 {
         efi_memory_desc_t *md;
@@ -65,6 +83,9 @@ void __init efi_call_phys_prelog(void)
         int pgd;
         int n_pgds;
 
+        if (!efi_enabled(EFI_OLD_MEMMAP))
+                return;
+
         early_code_mapping_set_exec(1);
         local_irq_save(efi_flags);
 
@@ -86,6 +107,10 @@ void __init efi_call_phys_epilog(void)
          */
         int pgd;
         int n_pgds = DIV_ROUND_UP((max_pfn << PAGE_SHIFT) , PGDIR_SIZE);
+
+        if (!efi_enabled(EFI_OLD_MEMMAP))
+                return;
+
         for (pgd = 0; pgd < n_pgds; pgd++)
                 set_pgd(pgd_offset_k(pgd * PGDIR_SIZE), save_pgd[pgd]);
         kfree(save_pgd);
@@ -94,6 +119,96 @@ void __init efi_call_phys_epilog(void)
         early_code_mapping_set_exec(0);
 }
 
+/*
+ * Add low kernel mappings for passing arguments to EFI functions.
+ */
+void efi_sync_low_kernel_mappings(void)
+{
+        unsigned num_pgds;
+        pgd_t *pgd = (pgd_t *)__va(real_mode_header->trampoline_pgd);
+
+        if (efi_enabled(EFI_OLD_MEMMAP))
+                return;
+
+        num_pgds = pgd_index(MODULES_END - 1) - pgd_index(PAGE_OFFSET);
+
+        memcpy(pgd + pgd_index(PAGE_OFFSET),
+                init_mm.pgd + pgd_index(PAGE_OFFSET),
+                sizeof(pgd_t) * num_pgds);
+}
+
+void efi_setup_page_tables(void)
+{
+        efi_scratch.efi_pgt = (pgd_t *)(unsigned long)real_mode_header->trampoline_pgd;
+
+        if (!efi_enabled(EFI_OLD_MEMMAP))
+                efi_scratch.use_pgd = true;
+}
+
+static void __init __map_region(efi_memory_desc_t *md, u64 va)
+{
+        pgd_t *pgd = (pgd_t *)__va(real_mode_header->trampoline_pgd);
+        unsigned long pf = 0;
+
+        if (!(md->attribute & EFI_MEMORY_WB))
+                pf |= _PAGE_PCD;
+
+        if (kernel_map_pages_in_pgd(pgd, md->phys_addr, va, md->num_pages, pf))
+                pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n",
+                           md->phys_addr, va);
+}
+
+void __init efi_map_region(efi_memory_desc_t *md)
+{
+        unsigned long size = md->num_pages << PAGE_SHIFT;
+        u64 pa = md->phys_addr;
+
+        if (efi_enabled(EFI_OLD_MEMMAP))
+                return old_map_region(md);
+
+        /*
+         * Make sure the 1:1 mappings are present as a catch-all for b0rked
+         * firmware which doesn't update all internal pointers after switching
+         * to virtual mode and would otherwise crap on us.
+         */
+        __map_region(md, md->phys_addr);
+
+        efi_va -= size;
+
+        /* Is PA 2M-aligned? */
+        if (!(pa & (PMD_SIZE - 1))) {
+                efi_va &= PMD_MASK;
+        } else {
+                u64 pa_offset = pa & (PMD_SIZE - 1);
+                u64 prev_va = efi_va;
+
+                /* get us the same offset within this 2M page */
+                efi_va = (efi_va & PMD_MASK) + pa_offset;
+
+                if (efi_va > prev_va)
+                        efi_va -= PMD_SIZE;
+        }
+
+        if (efi_va < EFI_VA_END) {
+                pr_warn(FW_WARN "VA address range overflow!\n");
+                return;
+        }
+
+        /* Do the VA map */
+        __map_region(md, efi_va);
+        md->virt_addr = efi_va;
+}
+
+/*
+ * kexec kernel will use efi_map_region_fixed to map efi runtime memory ranges.
+ * md->virt_addr is the original virtual address which had been mapped in kexec
+ * 1st kernel.
+ */
+void __init efi_map_region_fixed(efi_memory_desc_t *md)
+{
+        __map_region(md, md->virt_addr);
+}
+
 void __iomem *__init efi_ioremap(unsigned long phys_addr, unsigned long size,
                                  u32 type, u64 attribute)
 {
@@ -113,3 +228,17 @@ void __iomem *__init efi_ioremap(unsigned long phys_addr, unsigned long size,
 
         return (void __iomem *)__va(phys_addr);
 }
+
+void __init parse_efi_setup(u64 phys_addr, u32 data_len)
+{
+        efi_setup = phys_addr + sizeof(struct setup_data);
+}
+
+void __init efi_runtime_mkexec(void)
+{
+        if (!efi_enabled(EFI_OLD_MEMMAP))
+                return;
+
+        if (__supported_pte_mask & _PAGE_NX)
+                runtime_code_page_mkexec();
+}
diff --git a/arch/x86/platform/efi/efi_stub_64.S b/arch/x86/platform/efi/efi_stub_64.S
index 4c07ccab8146..88073b140298 100644
--- a/arch/x86/platform/efi/efi_stub_64.S
+++ b/arch/x86/platform/efi/efi_stub_64.S
@@ -34,10 +34,47 @@
         mov %rsi, %cr0;                 \
         mov (%rsp), %rsp
 
+        /* stolen from gcc */
+        .macro FLUSH_TLB_ALL
+        movq %r15, efi_scratch(%rip)
+        movq %r14, efi_scratch+8(%rip)
+        movq %cr4, %r15
+        movq %r15, %r14
+        andb $0x7f, %r14b
+        movq %r14, %cr4
+        movq %r15, %cr4
+        movq efi_scratch+8(%rip), %r14
+        movq efi_scratch(%rip), %r15
+        .endm
+
+        .macro SWITCH_PGT
+        cmpb $0, efi_scratch+24(%rip)
+        je 1f
+        movq %r15, efi_scratch(%rip)            # r15
+        # save previous CR3
+        movq %cr3, %r15
+        movq %r15, efi_scratch+8(%rip)          # prev_cr3
+        movq efi_scratch+16(%rip), %r15         # EFI pgt
+        movq %r15, %cr3
+        1:
+        .endm
+
+        .macro RESTORE_PGT
+        cmpb $0, efi_scratch+24(%rip)
+        je 2f
+        movq efi_scratch+8(%rip), %r15
+        movq %r15, %cr3
+        movq efi_scratch(%rip), %r15
+        FLUSH_TLB_ALL
+        2:
+        .endm
+
 ENTRY(efi_call0)
         SAVE_XMM
         subq $32, %rsp
+        SWITCH_PGT
         call *%rdi
+        RESTORE_PGT
         addq $32, %rsp
         RESTORE_XMM
         ret
@@ -47,7 +84,9 @@ ENTRY(efi_call1)
         SAVE_XMM
         subq $32, %rsp
         mov  %rsi, %rcx
+        SWITCH_PGT
         call *%rdi
+        RESTORE_PGT
         addq $32, %rsp
         RESTORE_XMM
         ret
@@ -57,7 +96,9 @@ ENTRY(efi_call2)
         SAVE_XMM
         subq $32, %rsp
         mov  %rsi, %rcx
+        SWITCH_PGT
         call *%rdi
+        RESTORE_PGT
         addq $32, %rsp
         RESTORE_XMM
         ret
@@ -68,7 +109,9 @@ ENTRY(efi_call3)
         subq $32, %rsp
         mov  %rcx, %r8
         mov  %rsi, %rcx
+        SWITCH_PGT
         call *%rdi
+        RESTORE_PGT
         addq $32, %rsp
         RESTORE_XMM
         ret
@@ -80,7 +123,9 @@ ENTRY(efi_call4)
         mov %r8, %r9
         mov %rcx, %r8
         mov %rsi, %rcx
+        SWITCH_PGT
         call *%rdi
+        RESTORE_PGT
         addq $32, %rsp
         RESTORE_XMM
         ret
@@ -93,7 +138,9 @@ ENTRY(efi_call5)
         mov %r8, %r9
         mov %rcx, %r8
         mov %rsi, %rcx
+        SWITCH_PGT
         call *%rdi
+        RESTORE_PGT
         addq $48, %rsp
         RESTORE_XMM
         ret
@@ -109,8 +156,15 @@ ENTRY(efi_call6)
         mov %r8, %r9
         mov %rcx, %r8
         mov %rsi, %rcx
+        SWITCH_PGT
         call *%rdi
+        RESTORE_PGT
         addq $48, %rsp
         RESTORE_XMM
         ret
 ENDPROC(efi_call6)
+
+        .data
+ENTRY(efi_scratch)
+        .fill 3,8,0
+        .byte 0
diff --git a/arch/x86/platform/intel-mid/Makefile b/arch/x86/platform/intel-mid/Makefile
index 01cc29ea5ff7..0a8ee703b9fa 100644
--- a/arch/x86/platform/intel-mid/Makefile
+++ b/arch/x86/platform/intel-mid/Makefile
@@ -1,6 +1,6 @@
-obj-$(CONFIG_X86_INTEL_MID) += intel-mid.o
-obj-$(CONFIG_X86_INTEL_MID) += intel_mid_vrtc.o
+obj-$(CONFIG_X86_INTEL_MID) += intel-mid.o intel_mid_vrtc.o mfld.o mrfl.o
 obj-$(CONFIG_EARLY_PRINTK_INTEL_MID) += early_printk_intel_mid.o
+
 # SFI specific code
 ifdef CONFIG_X86_INTEL_MID
 obj-$(CONFIG_SFI) += sfi.o device_libs/
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_emc1403.c b/arch/x86/platform/intel-mid/device_libs/platform_emc1403.c
index 0d942c1d26d5..69a783689d21 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_emc1403.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_emc1403.c
@@ -22,7 +22,9 @@ static void __init *emc1403_platform_data(void *info)
         int intr = get_gpio_by_name("thermal_int");
         int intr2nd = get_gpio_by_name("thermal_alert");
 
-        if (intr == -1 || intr2nd == -1)
+        if (intr < 0)
+                return NULL;
+        if (intr2nd < 0)
                 return NULL;
 
         i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_gpio_keys.c b/arch/x86/platform/intel-mid/device_libs/platform_gpio_keys.c
index a013a4834bbe..dccae6b0413f 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_gpio_keys.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_gpio_keys.c
@@ -66,7 +66,7 @@ static int __init pb_keys_init(void)
                 gb[i].gpio = get_gpio_by_name(gb[i].desc);
                 pr_debug("info[%2d]: name = %s, gpio = %d\n", i, gb[i].desc,
                                         gb[i].gpio);
-                if (gb[i].gpio == -1)
+                if (gb[i].gpio < 0)
                         continue;
 
                 if (i != good)
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_ipc.h b/arch/x86/platform/intel-mid/device_libs/platform_ipc.h
index 8f568dd79605..79bb09d4f718 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_ipc.h
+++ b/arch/x86/platform/intel-mid/device_libs/platform_ipc.h
@@ -12,6 +12,7 @@
 #ifndef _PLATFORM_IPC_H_
 #define _PLATFORM_IPC_H_
 
-extern void __init ipc_device_handler(struct sfi_device_table_entry *pentry,
-                        struct devs_id *dev) __attribute__((weak));
+void __init
+ipc_device_handler(struct sfi_device_table_entry *pentry, struct devs_id *dev);
+
 #endif
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_lis331.c b/arch/x86/platform/intel-mid/device_libs/platform_lis331.c
index 15278c11f714..54226de7541a 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_lis331.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_lis331.c
@@ -21,7 +21,9 @@ static void __init *lis331dl_platform_data(void *info)
         int intr = get_gpio_by_name("accel_int");
         int intr2nd = get_gpio_by_name("accel_2");
 
-        if (intr == -1 || intr2nd == -1)
+        if (intr < 0)
+                return NULL;
+        if (intr2nd < 0)
                 return NULL;
 
         i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_max7315.c b/arch/x86/platform/intel-mid/device_libs/platform_max7315.c
index 94ade10024ae..2c8acbc1e9ad 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_max7315.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_max7315.c
@@ -48,7 +48,7 @@ static void __init *max7315_platform_data(void *info)
         gpio_base = get_gpio_by_name(base_pin_name);
         intr = get_gpio_by_name(intr_pin_name);
 
-        if (gpio_base == -1)
+        if (gpio_base < 0)
                 return NULL;
         max7315->gpio_base = gpio_base;
         if (intr != -1) {
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_mpu3050.c b/arch/x86/platform/intel-mid/device_libs/platform_mpu3050.c
index dd28d63c84fb..cfe9a47a1e87 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_mpu3050.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_mpu3050.c
@@ -19,7 +19,7 @@ static void *mpu3050_platform_data(void *info)
         struct i2c_board_info *i2c_info = info;
         int intr = get_gpio_by_name("mpu3050_int");
 
-        if (intr == -1)
+        if (intr < 0)
                 return NULL;
 
         i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_msic.h b/arch/x86/platform/intel-mid/device_libs/platform_msic.h
index 917eb56d77da..b7be1d041da2 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_msic.h
+++ b/arch/x86/platform/intel-mid/device_libs/platform_msic.h
@@ -14,6 +14,6 @@
 
 extern struct intel_msic_platform_data msic_pdata;
 
-extern void *msic_generic_platform_data(void *info,
-                        enum intel_msic_block block) __attribute__((weak));
+void *msic_generic_platform_data(void *info, enum intel_msic_block block);
+
 #endif
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_pmic_gpio.c b/arch/x86/platform/intel-mid/device_libs/platform_pmic_gpio.c
index d87182a09263..65c2a9a19db4 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_pmic_gpio.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_pmic_gpio.c
@@ -26,7 +26,7 @@ static void __init *pmic_gpio_platform_data(void *info)
         static struct intel_pmic_gpio_platform_data pmic_gpio_pdata;
         int gpio_base = get_gpio_by_name("pmic_gpio_base");
 
-        if (gpio_base == -1)
+        if (gpio_base < 0)
                 gpio_base = 64;
         pmic_gpio_pdata.gpio_base = gpio_base;
         pmic_gpio_pdata.irq_base = gpio_base + INTEL_MID_IRQ_OFFSET;
diff --git a/arch/x86/platform/intel-mid/device_libs/platform_tca6416.c b/arch/x86/platform/intel-mid/device_libs/platform_tca6416.c
index 22881c9a6737..33be0b3be6e1 100644
--- a/arch/x86/platform/intel-mid/device_libs/platform_tca6416.c
+++ b/arch/x86/platform/intel-mid/device_libs/platform_tca6416.c
@@ -34,10 +34,10 @@ static void *tca6416_platform_data(void *info)
         gpio_base = get_gpio_by_name(base_pin_name);
         intr = get_gpio_by_name(intr_pin_name);
 
-        if (gpio_base == -1)
+        if (gpio_base < 0)
                 return NULL;
         tca6416.gpio_base = gpio_base;
-        if (intr != -1) {
+        if (intr >= 0) {
                 i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
                 tca6416.irq_base = gpio_base + INTEL_MID_IRQ_OFFSET;
         } else {
diff --git a/arch/x86/platform/intel-mid/early_printk_intel_mid.c b/arch/x86/platform/intel-mid/early_printk_intel_mid.c
index 4f702f554f6e..e0bd082a80e0 100644
--- a/arch/x86/platform/intel-mid/early_printk_intel_mid.c
+++ b/arch/x86/platform/intel-mid/early_printk_intel_mid.c
@@ -22,7 +22,6 @@
 #include <linux/console.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
-#include <linux/init.h>
 #include <linux/io.h>
 
 #include <asm/fixmap.h>
diff --git a/arch/x86/platform/intel-mid/intel-mid.c b/arch/x86/platform/intel-mid/intel-mid.c
index f90e290f689f..1bbedc4b0f88 100644
--- a/arch/x86/platform/intel-mid/intel-mid.c
+++ b/arch/x86/platform/intel-mid/intel-mid.c
@@ -35,6 +35,8 @@
 #include <asm/apb_timer.h>
 #include <asm/reboot.h>
 
+#include "intel_mid_weak_decls.h"
+
 /*
  * the clockevent devices on Moorestown/Medfield can be APBT or LAPIC clock,
  * cmdline option x86_intel_mid_timer can be used to override the configuration
@@ -58,12 +60,16 @@
 
 enum intel_mid_timer_options intel_mid_timer_options;
 
+/* intel_mid_ops to store sub arch ops */
+struct intel_mid_ops *intel_mid_ops;
+/* getter function for sub arch ops*/
+static void *(*get_intel_mid_ops[])(void) = INTEL_MID_OPS_INIT;
 enum intel_mid_cpu_type __intel_mid_cpu_chip;
 EXPORT_SYMBOL_GPL(__intel_mid_cpu_chip);
 
 static void intel_mid_power_off(void)
 {
-}
+};
 
 static void intel_mid_reboot(void)
 {
@@ -72,32 +78,6 @@ static void intel_mid_reboot(void)
 
 static unsigned long __init intel_mid_calibrate_tsc(void)
 {
-        unsigned long fast_calibrate;
-        u32 lo, hi, ratio, fsb;
-
-        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
-        pr_debug("IA32 perf status is 0x%x, 0x%0x\n", lo, hi);
-        ratio = (hi >> 8) & 0x1f;
-        pr_debug("ratio is %d\n", ratio);
-        if (!ratio) {
-                pr_err("read a zero ratio, should be incorrect!\n");
-                pr_err("force tsc ratio to 16 ...\n");
-                ratio = 16;
-        }
-        rdmsr(MSR_FSB_FREQ, lo, hi);
-        if ((lo & 0x7) == 0x7)
-                fsb = PENWELL_FSB_FREQ_83SKU;
-        else
-                fsb = PENWELL_FSB_FREQ_100SKU;
-        fast_calibrate = ratio * fsb;
-        pr_debug("read penwell tsc %lu khz\n", fast_calibrate);
-        lapic_timer_frequency = fsb * 1000 / HZ;
-        /* mark tsc clocksource as reliable */
-        set_cpu_cap(&boot_cpu_data, X86_FEATURE_TSC_RELIABLE);
-
-        if (fast_calibrate)
-                return fast_calibrate;
-
         return 0;
 }
 
@@ -125,13 +105,37 @@ static void __init intel_mid_time_init(void)
 
 static void intel_mid_arch_setup(void)
 {
-        if (boot_cpu_data.x86 == 6 && boot_cpu_data.x86_model == 0x27)
-                __intel_mid_cpu_chip = INTEL_MID_CPU_CHIP_PENWELL;
-        else {
+        if (boot_cpu_data.x86 != 6) {
                 pr_err("Unknown Intel MID CPU (%d:%d), default to Penwell\n",
                         boot_cpu_data.x86, boot_cpu_data.x86_model);
                 __intel_mid_cpu_chip = INTEL_MID_CPU_CHIP_PENWELL;
+                goto out;
         }
+
+        switch (boot_cpu_data.x86_model) {
+        case 0x35:
+                __intel_mid_cpu_chip = INTEL_MID_CPU_CHIP_CLOVERVIEW;
+                break;
+        case 0x3C:
+        case 0x4A:
+                __intel_mid_cpu_chip = INTEL_MID_CPU_CHIP_TANGIER;
+                break;
+        case 0x27:
+        default:
+                __intel_mid_cpu_chip = INTEL_MID_CPU_CHIP_PENWELL;
+                break;
+        }
+
+        if (__intel_mid_cpu_chip < MAX_CPU_OPS(get_intel_mid_ops))
+                intel_mid_ops = get_intel_mid_ops[__intel_mid_cpu_chip]();
+        else {
+                intel_mid_ops = get_intel_mid_ops[INTEL_MID_CPU_CHIP_PENWELL]();
+                pr_info("ARCH: Uknown SoC, assuming PENWELL!\n");
+        }
+
+out:
+        if (intel_mid_ops->arch_setup)
+                intel_mid_ops->arch_setup();
 }
 
 /* MID systems don't have i8042 controller */
diff --git a/arch/x86/platform/intel-mid/intel_mid_weak_decls.h b/arch/x86/platform/intel-mid/intel_mid_weak_decls.h
new file mode 100644
index 000000000000..46aa25c8ce06
--- /dev/null
+++ b/arch/x86/platform/intel-mid/intel_mid_weak_decls.h
@@ -0,0 +1,19 @@
+/*
+ * intel_mid_weak_decls.h: Weak declarations of intel-mid.c
+ *
+ * (C) Copyright 2013 Intel Corporation
+ *
+ * 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.
+ */
+
+
+/* __attribute__((weak)) makes these declarations overridable */
+/* For every CPU addition a new get_<cpuname>_ops interface needs
+ * to be added.
+ */
+extern void *get_penwell_ops(void) __attribute__((weak));
+extern void *get_cloverview_ops(void) __attribute__((weak));
+extern void *get_tangier_ops(void) __attribute__((weak));
diff --git a/arch/x86/platform/intel-mid/mfld.c b/arch/x86/platform/intel-mid/mfld.c
new file mode 100644
index 000000000000..23381d2174ae
--- /dev/null
+++ b/arch/x86/platform/intel-mid/mfld.c
@@ -0,0 +1,75 @@
+/*
+ * mfld.c: Intel Medfield platform setup code
+ *
+ * (C) Copyright 2013 Intel Corporation
+ *
+ * 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/init.h>
+
+#include <asm/apic.h>
+#include <asm/intel-mid.h>
+#include <asm/intel_mid_vrtc.h>
+
+#include "intel_mid_weak_decls.h"
+
+static void penwell_arch_setup(void);
+/* penwell arch ops */
+static struct intel_mid_ops penwell_ops = {
+        .arch_setup = penwell_arch_setup,
+};
+
+static void mfld_power_off(void)
+{
+}
+
+static unsigned long __init mfld_calibrate_tsc(void)
+{
+        unsigned long fast_calibrate;
+        u32 lo, hi, ratio, fsb;
+
+        rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
+        pr_debug("IA32 perf status is 0x%x, 0x%0x\n", lo, hi);
+        ratio = (hi >> 8) & 0x1f;
+        pr_debug("ratio is %d\n", ratio);
+        if (!ratio) {
+                pr_err("read a zero ratio, should be incorrect!\n");
+                pr_err("force tsc ratio to 16 ...\n");
+                ratio = 16;
+        }
+        rdmsr(MSR_FSB_FREQ, lo, hi);
+        if ((lo & 0x7) == 0x7)
+                fsb = FSB_FREQ_83SKU;
+        else
+                fsb = FSB_FREQ_100SKU;
+        fast_calibrate = ratio * fsb;
+        pr_debug("read penwell tsc %lu khz\n", fast_calibrate);
+        lapic_timer_frequency = fsb * 1000 / HZ;
+        /* mark tsc clocksource as reliable */
+        set_cpu_cap(&boot_cpu_data, X86_FEATURE_TSC_RELIABLE);
+
+        if (fast_calibrate)
+                return fast_calibrate;
+
+        return 0;
+}
+
+static void __init penwell_arch_setup(void)
+{
+        x86_platform.calibrate_tsc = mfld_calibrate_tsc;
+        pm_power_off = mfld_power_off;
+}
+
+void *get_penwell_ops(void)
+{
+        return &penwell_ops;
+}
+
+void *get_cloverview_ops(void)
+{
+        return &penwell_ops;
+}
diff --git a/arch/x86/platform/intel-mid/mrfl.c b/arch/x86/platform/intel-mid/mrfl.c
new file mode 100644
index 000000000000..aaca91753d32
--- /dev/null
+++ b/arch/x86/platform/intel-mid/mrfl.c
@@ -0,0 +1,103 @@
+/*
+ * mrfl.c: Intel Merrifield platform specific setup code
+ *
+ * (C) Copyright 2013 Intel Corporation
+ *
+ * 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/init.h>
+
+#include <asm/apic.h>
+#include <asm/intel-mid.h>
+
+#include "intel_mid_weak_decls.h"
+
+static unsigned long __init tangier_calibrate_tsc(void)
+{
+        unsigned long fast_calibrate;
+        u32 lo, hi, ratio, fsb, bus_freq;
+
+        /* *********************** */
+        /* Compute TSC:Ratio * FSB */
+        /* *********************** */
+
+        /* Compute Ratio */
+        rdmsr(MSR_PLATFORM_INFO, lo, hi);
+        pr_debug("IA32 PLATFORM_INFO is 0x%x : %x\n", hi, lo);
+
+        ratio = (lo >> 8) & 0xFF;
+        pr_debug("ratio is %d\n", ratio);
+        if (!ratio) {
+                pr_err("Read a zero ratio, force tsc ratio to 4 ...\n");
+                ratio = 4;
+        }
+
+        /* Compute FSB */
+        rdmsr(MSR_FSB_FREQ, lo, hi);
+        pr_debug("Actual FSB frequency detected by SOC 0x%x : %x\n",
+                        hi, lo);
+
+        bus_freq = lo & 0x7;
+        pr_debug("bus_freq = 0x%x\n", bus_freq);
+
+        if (bus_freq == 0)
+                fsb = FSB_FREQ_100SKU;
+        else if (bus_freq == 1)
+                fsb = FSB_FREQ_100SKU;
+        else if (bus_freq == 2)
+                fsb = FSB_FREQ_133SKU;
+        else if (bus_freq == 3)
+                fsb = FSB_FREQ_167SKU;
+        else if (bus_freq == 4)
+                fsb = FSB_FREQ_83SKU;
+        else if (bus_freq == 5)
+                fsb = FSB_FREQ_400SKU;
+        else if (bus_freq == 6)
+                fsb = FSB_FREQ_267SKU;
+        else if (bus_freq == 7)
+                fsb = FSB_FREQ_333SKU;
+        else {
+                BUG();
+                pr_err("Invalid bus_freq! Setting to minimal value!\n");
+                fsb = FSB_FREQ_100SKU;
+        }
+
+        /* TSC = FSB Freq * Resolved HFM Ratio */
+        fast_calibrate = ratio * fsb;
+        pr_debug("calculate tangier tsc %lu KHz\n", fast_calibrate);
+
+        /* ************************************ */
+        /* Calculate Local APIC Timer Frequency */
+        /* ************************************ */
+        lapic_timer_frequency = (fsb * 1000) / HZ;
+
+        pr_debug("Setting lapic_timer_frequency = %d\n",
+                        lapic_timer_frequency);
+
+        /* mark tsc clocksource as reliable */
+        set_cpu_cap(&boot_cpu_data, X86_FEATURE_TSC_RELIABLE);
+
+        if (fast_calibrate)
+                return fast_calibrate;
+
+        return 0;
+}
+
+static void __init tangier_arch_setup(void)
+{
+        x86_platform.calibrate_tsc = tangier_calibrate_tsc;
+}
+
+/* tangier arch ops */
+static struct intel_mid_ops tangier_ops = {
+        .arch_setup = tangier_arch_setup,
+};
+
+void *get_tangier_ops(void)
+{
+        return &tangier_ops;
+}
diff --git a/arch/x86/platform/intel-mid/sfi.c b/arch/x86/platform/intel-mid/sfi.c
index c84c1ca396bf..994c40bd7cb7 100644
--- a/arch/x86/platform/intel-mid/sfi.c
+++ b/arch/x86/platform/intel-mid/sfi.c
@@ -224,7 +224,7 @@ int get_gpio_by_name(const char *name)
                 if (!strncmp(name, pentry->pin_name, SFI_NAME_LEN))
                         return pentry->pin_no;
         }
-        return -1;
+        return -EINVAL;
 }
 
 void __init intel_scu_device_register(struct platform_device *pdev)
@@ -250,7 +250,7 @@ static void __init intel_scu_spi_device_register(struct spi_board_info *sdev)
                         sdev->modalias);
                 return;
         }
-        memcpy(new_dev, sdev, sizeof(*sdev));
+        *new_dev = *sdev;
 
         spi_devs[spi_next_dev++] = new_dev;
 }
@@ -271,7 +271,7 @@ static void __init intel_scu_i2c_device_register(int bus,
                         idev->type);
                 return;
         }
-        memcpy(new_dev, idev, sizeof(*idev));
+        *new_dev = *idev;
 
         i2c_bus[i2c_next_dev] = bus;
         i2c_devs[i2c_next_dev++] = new_dev;
@@ -337,6 +337,8 @@ static void __init sfi_handle_ipc_dev(struct sfi_device_table_entry *pentry,
         pr_debug("IPC bus, name = %16.16s, irq = 0x%2x\n",
                 pentry->name, pentry->irq);
         pdata = intel_mid_sfi_get_pdata(dev, pentry);
+        if (IS_ERR(pdata))
+                return;
 
         pdev = platform_device_alloc(pentry->name, 0);
         if (pdev == NULL) {
@@ -370,6 +372,8 @@ static void __init sfi_handle_spi_dev(struct sfi_device_table_entry *pentry,
                 spi_info.chip_select);
 
         pdata = intel_mid_sfi_get_pdata(dev, &spi_info);
+        if (IS_ERR(pdata))
+                return;
 
         spi_info.platform_data = pdata;
         if (dev->delay)
@@ -395,6 +399,8 @@ static void __init sfi_handle_i2c_dev(struct sfi_device_table_entry *pentry,
                 i2c_info.addr);
         pdata = intel_mid_sfi_get_pdata(dev, &i2c_info);
         i2c_info.platform_data = pdata;
+        if (IS_ERR(pdata))
+                return;
 
         if (dev->delay)
                 intel_scu_i2c_device_register(pentry->host_num, &i2c_info);
@@ -443,13 +449,35 @@ static int __init sfi_parse_devs(struct sfi_table_header *table)
                          * so we have to enable them one by one here
                          */
                         ioapic = mp_find_ioapic(irq);
-                        irq_attr.ioapic = ioapic;
-                        irq_attr.ioapic_pin = irq;
-                        irq_attr.trigger = 1;
-                        irq_attr.polarity = 1;
-                        io_apic_set_pci_routing(NULL, irq, &irq_attr);
-                } else
+                        if (ioapic >= 0) {
+                                irq_attr.ioapic = ioapic;
+                                irq_attr.ioapic_pin = irq;
+                                irq_attr.trigger = 1;
+                                if (intel_mid_identify_cpu() ==
+                                                INTEL_MID_CPU_CHIP_TANGIER) {
+                                        if (!strncmp(pentry->name,
+                                                        "r69001-ts-i2c", 13))
+                                                /* active low */
+                                                irq_attr.polarity = 1;
+                                        else if (!strncmp(pentry->name,
+                                                        "synaptics_3202", 14))
+                                                /* active low */
+                                                irq_attr.polarity = 1;
+                                        else if (irq == 41)
+                                                /* fast_int_1 */
+                                                irq_attr.polarity = 1;
+                                        else
+                                                /* active high */
+                                                irq_attr.polarity = 0;
+                                } else {
+                                        /* PNW and CLV go with active low */
+                                        irq_attr.polarity = 1;
+                                }
+                                io_apic_set_pci_routing(NULL, irq, &irq_attr);
+                        }
+                } else {
                         irq = 0; /* No irq */
+                }
 
                 dev = get_device_id(pentry->type, pentry->name);
 
diff --git a/arch/x86/platform/iris/iris.c b/arch/x86/platform/iris/iris.c
index e6cb80f620af..4d171e8640ef 100644
--- a/arch/x86/platform/iris/iris.c
+++ b/arch/x86/platform/iris/iris.c
@@ -27,7 +27,6 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/delay.h>
-#include <linux/init.h>
 #include <linux/pm.h>
 #include <asm/io.h>
 
diff --git a/arch/x86/platform/olpc/olpc-xo15-sci.c b/arch/x86/platform/olpc/olpc-xo15-sci.c
index 649a12befba9..08e350e757dc 100644
--- a/arch/x86/platform/olpc/olpc-xo15-sci.c
+++ b/arch/x86/platform/olpc/olpc-xo15-sci.c
@@ -15,8 +15,7 @@
 #include <linux/power_supply.h>
 #include <linux/olpc-ec.h>
 
-#include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
+#include <linux/acpi.h>
 #include <asm/olpc.h>
 
 #define DRV_NAME                        "olpc-xo15-sci"
diff --git a/arch/x86/platform/uv/tlb_uv.c b/arch/x86/platform/uv/tlb_uv.c
index efe4d7220397..dfe605ac1bcd 100644
--- a/arch/x86/platform/uv/tlb_uv.c
+++ b/arch/x86/platform/uv/tlb_uv.c
@@ -433,15 +433,49 @@ static void reset_with_ipi(struct pnmask *distribution, struct bau_control *bcp)
         return;
 }
 
-static inline unsigned long cycles_2_us(unsigned long long cyc)
+/*
+ * Not to be confused with cycles_2_ns() from tsc.c; this gives a relative
+ * number, not an absolute. It converts a duration in cycles to a duration in
+ * ns.
+ */
+static inline unsigned long long cycles_2_ns(unsigned long long cyc)
 {
+        struct cyc2ns_data *data = cyc2ns_read_begin();
         unsigned long long ns;
-        unsigned long us;
-        int cpu = smp_processor_id();
 
-        ns =  (cyc * per_cpu(cyc2ns, cpu)) >> CYC2NS_SCALE_FACTOR;
-        us = ns / 1000;
-        return us;
+        ns = mul_u64_u32_shr(cyc, data->cyc2ns_mul, data->cyc2ns_shift);
+
+        cyc2ns_read_end(data);
+        return ns;
+}
+
+/*
+ * The reverse of the above; converts a duration in ns to a duration in cycles.
+ */ 
+static inline unsigned long long ns_2_cycles(unsigned long long ns)
+{
+        struct cyc2ns_data *data = cyc2ns_read_begin();
+        unsigned long long cyc;
+
+        cyc = (ns << data->cyc2ns_shift) / data->cyc2ns_mul;
+
+        cyc2ns_read_end(data);
+        return cyc;
+}
+
+static inline unsigned long cycles_2_us(unsigned long long cyc)
+{
+        return cycles_2_ns(cyc) / NSEC_PER_USEC;
+}
+
+static inline cycles_t sec_2_cycles(unsigned long sec)
+{
+        return ns_2_cycles(sec * NSEC_PER_SEC);
+}
+
+static inline unsigned long long usec_2_cycles(unsigned long usec)
+{
+        return ns_2_cycles(usec * NSEC_PER_USEC);
 }
 
 /*
@@ -668,16 +702,6 @@ static int wait_completion(struct bau_desc *bau_desc,
                                                                 bcp, try);
 }
 
-static inline cycles_t sec_2_cycles(unsigned long sec)
-{
-        unsigned long ns;
-        cycles_t cyc;
-
-        ns = sec * 1000000000;
-        cyc = (ns << CYC2NS_SCALE_FACTOR)/(per_cpu(cyc2ns, smp_processor_id()));
-        return cyc;
-}
-
 /*
  * Our retries are blocked by all destination sw ack resources being
  * in use, and a timeout is pending. In that case hardware immediately
@@ -1327,16 +1351,6 @@ static void ptc_seq_stop(struct seq_file *file, void *data)
 {
 }
 
-static inline unsigned long long usec_2_cycles(unsigned long microsec)
-{
-        unsigned long ns;
-        unsigned long long cyc;
-
-        ns = microsec * 1000;
-        cyc = (ns << CYC2NS_SCALE_FACTOR)/(per_cpu(cyc2ns, smp_processor_id()));
-        return cyc;
-}
-
 /*
  * Display the statistics thru /proc/sgi_uv/ptc_statistics
  * 'data' points to the cpu number
diff --git a/arch/x86/platform/uv/uv_nmi.c b/arch/x86/platform/uv/uv_nmi.c
index 8eeccba73130..be27da60dc8f 100644
--- a/arch/x86/platform/uv/uv_nmi.c
+++ b/arch/x86/platform/uv/uv_nmi.c
@@ -74,7 +74,6 @@ static atomic_t	uv_in_nmi;
 static atomic_t uv_nmi_cpu = ATOMIC_INIT(-1);
 static atomic_t uv_nmi_cpus_in_nmi = ATOMIC_INIT(-1);
 static atomic_t uv_nmi_slave_continue;
-static atomic_t uv_nmi_kexec_failed;
 static cpumask_var_t uv_nmi_cpu_mask;
 
 /* Values for uv_nmi_slave_continue */
@@ -149,7 +148,8 @@ module_param_named(retry_count, uv_nmi_retry_count, int, 0644);
  *  "dump"      - dump process stack for each cpu
  *  "ips"       - dump IP info for each cpu
  *  "kdump"     - do crash dump
- *  "kdb"       - enter KDB/KGDB (default)
+ *  "kdb"       - enter KDB (default)
+ *  "kgdb"      - enter KGDB
  */
 static char uv_nmi_action[8] = "kdb";
 module_param_string(action, uv_nmi_action, sizeof(uv_nmi_action), 0644);
@@ -504,6 +504,7 @@ static void uv_nmi_touch_watchdogs(void)
 }
 
 #if defined(CONFIG_KEXEC)
+static atomic_t uv_nmi_kexec_failed;
 static void uv_nmi_kdump(int cpu, int master, struct pt_regs *regs)
 {
         /* Call crash to dump system state */
@@ -537,18 +538,45 @@ static inline void uv_nmi_kdump(int cpu, int master, struct pt_regs *regs)
 }
 #endif /* !CONFIG_KEXEC */
 
+#ifdef CONFIG_KGDB
 #ifdef CONFIG_KGDB_KDB
-/* Call KDB from NMI handler */
-static void uv_call_kdb(int cpu, struct pt_regs *regs, int master)
+static inline int uv_nmi_kdb_reason(void)
 {
-        int ret;
+        return KDB_REASON_SYSTEM_NMI;
+}
+#else /* !CONFIG_KGDB_KDB */
+static inline int uv_nmi_kdb_reason(void)
+{
+        /* Insure user is expecting to attach gdb remote */
+        if (uv_nmi_action_is("kgdb"))
+                return 0;
+
+        pr_err("UV: NMI error: KDB is not enabled in this kernel\n");
+        return -1;
+}
+#endif /* CONFIG_KGDB_KDB */
 
+/*
+ * Call KGDB/KDB from NMI handler
+ *
+ * Note that if both KGDB and KDB are configured, then the action of 'kgdb' or
+ * 'kdb' has no affect on which is used.  See the KGDB documention for further
+ * information.
+ */
+static void uv_call_kgdb_kdb(int cpu, struct pt_regs *regs, int master)
+{
         if (master) {
+                int reason = uv_nmi_kdb_reason();
+                int ret;
+
+                if (reason < 0)
+                        return;
+
                 /* call KGDB NMI handler as MASTER */
-                ret = kgdb_nmicallin(cpu, X86_TRAP_NMI, regs,
-                                        &uv_nmi_slave_continue);
+                ret = kgdb_nmicallin(cpu, X86_TRAP_NMI, regs, reason,
+                                &uv_nmi_slave_continue);
                 if (ret) {
-                        pr_alert("KDB returned error, is kgdboc set?\n");
+                        pr_alert("KGDB returned error, is kgdboc set?\n");
                         atomic_set(&uv_nmi_slave_continue, SLAVE_EXIT);
                 }
         } else {
@@ -567,12 +595,12 @@ static void uv_call_kdb(int cpu, struct pt_regs *regs, int master)
         uv_nmi_sync_exit(master);
 }
 
-#else /* !CONFIG_KGDB_KDB */
-static inline void uv_call_kdb(int cpu, struct pt_regs *regs, int master)
+#else /* !CONFIG_KGDB */
+static inline void uv_call_kgdb_kdb(int cpu, struct pt_regs *regs, int master)
 {
-        pr_err("UV: NMI error: KGDB/KDB is not enabled in this kernel\n");
+        pr_err("UV: NMI error: KGDB is not enabled in this kernel\n");
 }
-#endif /* !CONFIG_KGDB_KDB */
+#endif /* !CONFIG_KGDB */
 
 /*
  * UV NMI handler
@@ -606,9 +634,9 @@ int uv_handle_nmi(unsigned int reason, struct pt_regs *regs)
         if (uv_nmi_action_is("ips") || uv_nmi_action_is("dump"))
                 uv_nmi_dump_state(cpu, regs, master);
 
-        /* Call KDB if enabled */
-        else if (uv_nmi_action_is("kdb"))
-                uv_call_kdb(cpu, regs, master);
+        /* Call KGDB/KDB if enabled */
+        else if (uv_nmi_action_is("kdb") || uv_nmi_action_is("kgdb"))
+                uv_call_kgdb_kdb(cpu, regs, master);
 
         /* Clear per_cpu "in nmi" flag */
         atomic_set(&uv_cpu_nmi.state, UV_NMI_STATE_OUT);
@@ -634,7 +662,7 @@ int uv_handle_nmi(unsigned int reason, struct pt_regs *regs)
 /*
  * NMI handler for pulling in CPUs when perf events are grabbing our NMI
  */
-int uv_handle_nmi_ping(unsigned int reason, struct pt_regs *regs)
+static int uv_handle_nmi_ping(unsigned int reason, struct pt_regs *regs)
 {
         int ret;
 
@@ -651,7 +679,7 @@ int uv_handle_nmi_ping(unsigned int reason, struct pt_regs *regs)
         return ret;
 }
 
-void uv_register_nmi_notifier(void)
+static void uv_register_nmi_notifier(void)
 {
         if (register_nmi_handler(NMI_UNKNOWN, uv_handle_nmi, 0, "uv"))
                 pr_warn("UV: NMI handler failed to register\n");
@@ -695,6 +723,5 @@ void uv_nmi_setup(void)
                 uv_hub_nmi_per(cpu) = uv_hub_nmi_list[nid];
         }
         BUG_ON(!alloc_cpumask_var(&uv_nmi_cpu_mask, GFP_KERNEL));
+        uv_register_nmi_notifier();
 }
-
-