Merge tag 'omap-for-v3.11/board-signed' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap into next/boards

From Tony Lindgren:

Minor board changes for v3.11 merge window. These are
tapering down finally as we're getting closer to making
omap2+ DT only.

* tag 'omap-for-v3.11/board-signed' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap:
  ARM: omap2plus_defconfig: enable USB_PHY and NOP_USB_XCEIV
  ARM: OMAP1: nokia770: enable Tahvo
  ARM: OMAP3EVM: Marking omap3_evm_display_init() with CONFIG_BROKEN
  arm: omap: board-overo: reset GPIO for SMSC911x

Signed-off-by: Arnd Bergmann <arnd@arndb.de>

18 files changed, 183 insertions, 214 deletions

diff --git a/arch/x86/boot/compressed/eboot.c b/arch/x86/boot/compressed/eboot.c
index 35ee62fccf98..c205035a6b96 100644
--- a/arch/x86/boot/compressed/eboot.c
+++ b/arch/x86/boot/compressed/eboot.c
@@ -251,51 +251,6 @@ static void find_bits(unsigned long mask, u8 *pos, u8 *size)
         *size = len;
 }
 
-static efi_status_t setup_efi_vars(struct boot_params *params)
-{
-        struct setup_data *data;
-        struct efi_var_bootdata *efidata;
-        u64 store_size, remaining_size, var_size;
-        efi_status_t status;
-
-        if (sys_table->runtime->hdr.revision < EFI_2_00_SYSTEM_TABLE_REVISION)
-                return EFI_UNSUPPORTED;
-
-        data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
-
-        while (data && data->next)
-                data = (struct setup_data *)(unsigned long)data->next;
-
-        status = efi_call_phys4((void *)sys_table->runtime->query_variable_info,
-                                EFI_VARIABLE_NON_VOLATILE |
-                                EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                EFI_VARIABLE_RUNTIME_ACCESS, &store_size,
-                                &remaining_size, &var_size);
-
-        if (status != EFI_SUCCESS)
-                return status;
-
-        status = efi_call_phys3(sys_table->boottime->allocate_pool,
-                                EFI_LOADER_DATA, sizeof(*efidata), &efidata);
-
-        if (status != EFI_SUCCESS)
-                return status;
-
-        efidata->data.type = SETUP_EFI_VARS;
-        efidata->data.len = sizeof(struct efi_var_bootdata) -
-                sizeof(struct setup_data);
-        efidata->data.next = 0;
-        efidata->store_size = store_size;
-        efidata->remaining_size = remaining_size;
-        efidata->max_var_size = var_size;
-
-        if (data)
-                data->next = (unsigned long)efidata;
-        else
-                params->hdr.setup_data = (unsigned long)efidata;
-
-}
-
 static efi_status_t setup_efi_pci(struct boot_params *params)
 {
         efi_pci_io_protocol *pci;
@@ -1202,8 +1157,6 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
 
         setup_graphics(boot_params);
 
-        setup_efi_vars(boot_params);
-
         setup_efi_pci(boot_params);
 
         status = efi_call_phys3(sys_table->boottime->allocate_pool,
diff --git a/arch/x86/crypto/crc32-pclmul_asm.S b/arch/x86/crypto/crc32-pclmul_asm.S
index 94c27df8a549..f247304299a2 100644
--- a/arch/x86/crypto/crc32-pclmul_asm.S
+++ b/arch/x86/crypto/crc32-pclmul_asm.S
@@ -240,7 +240,7 @@ fold_64:
         pand    %xmm3, %xmm1
         PCLMULQDQ 0x00, CONSTANT, %xmm1
         pxor    %xmm2, %xmm1
-        pextrd  $0x01, %xmm1, %eax
+        PEXTRD  0x01, %xmm1, %eax
 
         ret
 ENDPROC(crc32_pclmul_le_16)
diff --git a/arch/x86/crypto/sha256-avx-asm.S b/arch/x86/crypto/sha256-avx-asm.S
index 56610c4bf31b..642f15687a0a 100644
--- a/arch/x86/crypto/sha256-avx-asm.S
+++ b/arch/x86/crypto/sha256-avx-asm.S
@@ -118,7 +118,7 @@ y2 = %r15d
 
 _INP_END_SIZE = 8
 _INP_SIZE = 8
-_XFER_SIZE = 8
+_XFER_SIZE = 16
 _XMM_SAVE_SIZE = 0
 
 _INP_END = 0
diff --git a/arch/x86/crypto/sha256-ssse3-asm.S b/arch/x86/crypto/sha256-ssse3-asm.S
index 98d3c391da81..f833b74d902b 100644
--- a/arch/x86/crypto/sha256-ssse3-asm.S
+++ b/arch/x86/crypto/sha256-ssse3-asm.S
@@ -111,7 +111,7 @@ y2 = %r15d
 
 _INP_END_SIZE = 8
 _INP_SIZE = 8
-_XFER_SIZE = 8
+_XFER_SIZE = 16
 _XMM_SAVE_SIZE = 0
 
 _INP_END = 0
diff --git a/arch/x86/include/asm/efi.h b/arch/x86/include/asm/efi.h
index 2fb5d5884e23..60c89f30c727 100644
--- a/arch/x86/include/asm/efi.h
+++ b/arch/x86/include/asm/efi.h
@@ -102,13 +102,6 @@ extern void efi_call_phys_epilog(void);
 extern void efi_unmap_memmap(void);
 extern void efi_memory_uc(u64 addr, unsigned long size);
 
-struct efi_var_bootdata {
-        struct setup_data data;
-        u64 store_size;
-        u64 remaining_size;
-        u64 max_var_size;
-};
-
 #ifdef CONFIG_EFI
 
 static inline bool efi_is_native(void)
diff --git a/arch/x86/include/asm/inst.h b/arch/x86/include/asm/inst.h
index 280bf7fb6aba..3e115273ed88 100644
--- a/arch/x86/include/asm/inst.h
+++ b/arch/x86/include/asm/inst.h
@@ -9,12 +9,68 @@
 
 #define REG_NUM_INVALID         100
 
-#define REG_TYPE_R64            0
-#define REG_TYPE_XMM            1
+#define REG_TYPE_R32            0
+#define REG_TYPE_R64            1
+#define REG_TYPE_XMM            2
 #define REG_TYPE_INVALID        100
 
+        .macro R32_NUM opd r32
+        \opd = REG_NUM_INVALID
+        .ifc \r32,%eax
+        \opd = 0
+        .endif
+        .ifc \r32,%ecx
+        \opd = 1
+        .endif
+        .ifc \r32,%edx
+        \opd = 2
+        .endif
+        .ifc \r32,%ebx
+        \opd = 3
+        .endif
+        .ifc \r32,%esp
+        \opd = 4
+        .endif
+        .ifc \r32,%ebp
+        \opd = 5
+        .endif
+        .ifc \r32,%esi
+        \opd = 6
+        .endif
+        .ifc \r32,%edi
+        \opd = 7
+        .endif
+#ifdef CONFIG_X86_64
+        .ifc \r32,%r8d
+        \opd = 8
+        .endif
+        .ifc \r32,%r9d
+        \opd = 9
+        .endif
+        .ifc \r32,%r10d
+        \opd = 10
+        .endif
+        .ifc \r32,%r11d
+        \opd = 11
+        .endif
+        .ifc \r32,%r12d
+        \opd = 12
+        .endif
+        .ifc \r32,%r13d
+        \opd = 13
+        .endif
+        .ifc \r32,%r14d
+        \opd = 14
+        .endif
+        .ifc \r32,%r15d
+        \opd = 15
+        .endif
+#endif
+        .endm
+
         .macro R64_NUM opd r64
         \opd = REG_NUM_INVALID
+#ifdef CONFIG_X86_64
         .ifc \r64,%rax
         \opd = 0
         .endif
@@ -63,6 +119,7 @@
         .ifc \r64,%r15
         \opd = 15
         .endif
+#endif
         .endm
 
         .macro XMM_NUM opd xmm
@@ -118,10 +175,13 @@
         .endm
 
         .macro REG_TYPE type reg
+        R32_NUM reg_type_r32 \reg
         R64_NUM reg_type_r64 \reg
         XMM_NUM reg_type_xmm \reg
         .if reg_type_r64 <> REG_NUM_INVALID
         \type = REG_TYPE_R64
+        .elseif reg_type_r32 <> REG_NUM_INVALID
+        \type = REG_TYPE_R32
         .elseif reg_type_xmm <> REG_NUM_INVALID
         \type = REG_TYPE_XMM
         .else
@@ -162,6 +222,16 @@
         .byte \imm8
         .endm
 
+        .macro PEXTRD imm8 xmm gpr
+        R32_NUM extrd_opd1 \gpr
+        XMM_NUM extrd_opd2 \xmm
+        PFX_OPD_SIZE
+        PFX_REX extrd_opd1 extrd_opd2
+        .byte 0x0f, 0x3a, 0x16
+        MODRM 0xc0 extrd_opd1 extrd_opd2
+        .byte \imm8
+        .endm
+
         .macro AESKEYGENASSIST rcon xmm1 xmm2
         XMM_NUM aeskeygen_opd1 \xmm1
         XMM_NUM aeskeygen_opd2 \xmm2
diff --git a/arch/x86/include/uapi/asm/bootparam.h b/arch/x86/include/uapi/asm/bootparam.h
index 08744242b8d2..c15ddaf90710 100644
--- a/arch/x86/include/uapi/asm/bootparam.h
+++ b/arch/x86/include/uapi/asm/bootparam.h
@@ -6,7 +6,6 @@
 #define SETUP_E820_EXT                  1
 #define SETUP_DTB                       2
 #define SETUP_PCI                       3
-#define SETUP_EFI_VARS                  4
 
 /* ram_size flags */
 #define RAMDISK_IMAGE_START_MASK        0x07FF
diff --git a/arch/x86/kernel/head_64.S b/arch/x86/kernel/head_64.S
index 08f7e8039099..321d65ebaffe 100644
--- a/arch/x86/kernel/head_64.S
+++ b/arch/x86/kernel/head_64.S
@@ -115,8 +115,10 @@ startup_64:
         movq    %rdi, %rax
         shrq    $PUD_SHIFT, %rax
         andl    $(PTRS_PER_PUD-1), %eax
-        movq    %rdx, (4096+0)(%rbx,%rax,8)
-        movq    %rdx, (4096+8)(%rbx,%rax,8)
+        movq    %rdx, 4096(%rbx,%rax,8)
+        incl    %eax
+        andl    $(PTRS_PER_PUD-1), %eax
+        movq    %rdx, 4096(%rbx,%rax,8)
 
         addq    $8192, %rbx
         movq    %rdi, %rax
diff --git a/arch/x86/kernel/i387.c b/arch/x86/kernel/i387.c
index 245a71db401a..cb339097b9ea 100644
--- a/arch/x86/kernel/i387.c
+++ b/arch/x86/kernel/i387.c
@@ -22,23 +22,19 @@
 /*
  * Were we in an interrupt that interrupted kernel mode?
  *
- * For now, with eagerfpu we will return interrupted kernel FPU
- * state as not-idle. TBD: Ideally we can change the return value
- * to something like __thread_has_fpu(current). But we need to
- * be careful of doing __thread_clear_has_fpu() before saving
- * the FPU etc for supporting nested uses etc. For now, take
- * the simple route!
- *
  * On others, we can do a kernel_fpu_begin/end() pair *ONLY* if that
  * pair does nothing at all: the thread must not have fpu (so
  * that we don't try to save the FPU state), and TS must
  * be set (so that the clts/stts pair does nothing that is
  * visible in the interrupted kernel thread).
+ *
+ * Except for the eagerfpu case when we return 1 unless we've already
+ * been eager and saved the state in kernel_fpu_begin().
  */
 static inline bool interrupted_kernel_fpu_idle(void)
 {
         if (use_eager_fpu())
-                return 0;
+                return __thread_has_fpu(current);
 
         return !__thread_has_fpu(current) &&
                 (read_cr0() & X86_CR0_TS);
@@ -78,8 +74,8 @@ void __kernel_fpu_begin(void)
         struct task_struct *me = current;
 
         if (__thread_has_fpu(me)) {
-                __save_init_fpu(me);
                 __thread_clear_has_fpu(me);
+                __save_init_fpu(me);
                 /* We do 'stts()' in __kernel_fpu_end() */
         } else if (!use_eager_fpu()) {
                 this_cpu_write(fpu_owner_task, NULL);
diff --git a/arch/x86/kernel/relocate_kernel_64.S b/arch/x86/kernel/relocate_kernel_64.S
index 7a6f3b3be3cf..f2bb9c96720a 100644
--- a/arch/x86/kernel/relocate_kernel_64.S
+++ b/arch/x86/kernel/relocate_kernel_64.S
@@ -160,7 +160,7 @@ identity_mapped:
         xorq    %rbp, %rbp
         xorq    %r8,  %r8
         xorq    %r9,  %r9
-        xorq    %r10, %r9
+        xorq    %r10, %r10
         xorq    %r11, %r11
         xorq    %r12, %r12
         xorq    %r13, %r13
diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index 8db0010ed150..5953dcea752d 100644
--- a/arch/x86/kvm/emulate.c
+++ b/arch/x86/kvm/emulate.c
@@ -1240,9 +1240,12 @@ static int decode_modrm(struct x86_emulate_ctxt *ctxt,
         ctxt->modrm_seg = VCPU_SREG_DS;
 
         if (ctxt->modrm_mod == 3) {
+                int highbyte_regs = ctxt->rex_prefix == 0;
+
                 op->type = OP_REG;
                 op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes;
-                op->addr.reg = decode_register(ctxt, ctxt->modrm_rm, ctxt->d & ByteOp);
+                op->addr.reg = decode_register(ctxt, ctxt->modrm_rm,
+                                               highbyte_regs && (ctxt->d & ByteOp));
                 if (ctxt->d & Sse) {
                         op->type = OP_XMM;
                         op->bytes = 16;
@@ -3997,7 +4000,8 @@ static const struct opcode twobyte_table[256] = {
         DI(ImplicitOps | Priv, invd), DI(ImplicitOps | Priv, wbinvd), N, N,
         N, D(ImplicitOps | ModRM), N, N,
         /* 0x10 - 0x1F */
-        N, N, N, N, N, N, N, N, D(ImplicitOps | ModRM), N, N, N, N, N, N, N,
+        N, N, N, N, N, N, N, N,
+        D(ImplicitOps | ModRM), N, N, N, N, N, N, D(ImplicitOps | ModRM),
         /* 0x20 - 0x2F */
         DIP(ModRM | DstMem | Priv | Op3264, cr_read, check_cr_read),
         DIP(ModRM | DstMem | Priv | Op3264, dr_read, check_dr_read),
@@ -4836,6 +4840,7 @@ twobyte_insn:
         case 0x08:              /* invd */
         case 0x0d:              /* GrpP (prefetch) */
         case 0x18:              /* Grp16 (prefetch/nop) */
+        case 0x1f:              /* nop */
                 break;
         case 0x20: /* mov cr, reg */
                 ctxt->dst.val = ops->get_cr(ctxt, ctxt->modrm_reg);
diff --git a/arch/x86/kvm/lapic.c b/arch/x86/kvm/lapic.c
index e1adbb4aca75..0eee2c8b64d1 100644
--- a/arch/x86/kvm/lapic.c
+++ b/arch/x86/kvm/lapic.c
@@ -1861,11 +1861,14 @@ void kvm_apic_accept_events(struct kvm_vcpu *vcpu)
 {
         struct kvm_lapic *apic = vcpu->arch.apic;
         unsigned int sipi_vector;
+        unsigned long pe;
 
-        if (!kvm_vcpu_has_lapic(vcpu))
+        if (!kvm_vcpu_has_lapic(vcpu) || !apic->pending_events)
                 return;
 
-        if (test_and_clear_bit(KVM_APIC_INIT, &apic->pending_events)) {
+        pe = xchg(&apic->pending_events, 0);
+
+        if (test_bit(KVM_APIC_INIT, &pe)) {
                 kvm_lapic_reset(vcpu);
                 kvm_vcpu_reset(vcpu);
                 if (kvm_vcpu_is_bsp(apic->vcpu))
@@ -1873,7 +1876,7 @@ void kvm_apic_accept_events(struct kvm_vcpu *vcpu)
                 else
                         vcpu->arch.mp_state = KVM_MP_STATE_INIT_RECEIVED;
         }
-        if (test_and_clear_bit(KVM_APIC_SIPI, &apic->pending_events) &&
+        if (test_bit(KVM_APIC_SIPI, &pe) &&
             vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
                 /* evaluate pending_events before reading the vector */
                 smp_rmb();
diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c
index eaac1743def7..1f34e9219775 100644
--- a/arch/x86/mm/init.c
+++ b/arch/x86/mm/init.c
@@ -277,6 +277,9 @@ static int __meminit split_mem_range(struct map_range *mr, int nr_range,
         end_pfn = limit_pfn;
         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);
 
+        if (!after_bootmem)
+                adjust_range_page_size_mask(mr, nr_range);
+
         /* try to merge same page size and continuous */
         for (i = 0; nr_range > 1 && i < nr_range - 1; i++) {
                 unsigned long old_start;
@@ -291,9 +294,6 @@ static int __meminit split_mem_range(struct map_range *mr, int nr_range,
                 nr_range--;
         }
 
-        if (!after_bootmem)
-                adjust_range_page_size_mask(mr, nr_range);
-
         for (i = 0; i < nr_range; i++)
                 printk(KERN_DEBUG " [mem %#010lx-%#010lx] page %s\n",
                                 mr[i].start, mr[i].end - 1,
diff --git a/arch/x86/pci/common.c b/arch/x86/pci/common.c
index 305c68b8d538..981c2dbd72cc 100644
--- a/arch/x86/pci/common.c
+++ b/arch/x86/pci/common.c
@@ -628,7 +628,9 @@ int pcibios_add_device(struct pci_dev *dev)
 
         pa_data = boot_params.hdr.setup_data;
         while (pa_data) {
-                data = phys_to_virt(pa_data);
+                data = ioremap(pa_data, sizeof(*rom));
+                if (!data)
+                        return -ENOMEM;
 
                 if (data->type == SETUP_PCI) {
                         rom = (struct pci_setup_rom *)data;
@@ -645,6 +647,7 @@ int pcibios_add_device(struct pci_dev *dev)
                         }
                 }
                 pa_data = data->next;
+                iounmap(data);
         }
         return 0;
 }
diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index 55856b2310d3..5ae2eb09419e 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -42,7 +42,6 @@
 #include <linux/io.h>
 #include <linux/reboot.h>
 #include <linux/bcd.h>
-#include <linux/ucs2_string.h>
 
 #include <asm/setup.h>
 #include <asm/efi.h>
@@ -54,12 +53,12 @@
 
 #define EFI_DEBUG       1
 
-/*
- * There's some additional metadata associated with each
- * variable. Intel's reference implementation is 60 bytes - bump that
- * to account for potential alignment constraints
- */
-#define VAR_METADATA_SIZE 64
+#define EFI_MIN_RESERVE 5120
+
+#define EFI_DUMMY_GUID \
+        EFI_GUID(0x4424ac57, 0xbe4b, 0x47dd, 0x9e, 0x97, 0xed, 0x50, 0xf0, 0x9f, 0x92, 0xa9)
+
+static efi_char16_t efi_dummy_name[6] = { 'D', 'U', 'M', 'M', 'Y', 0 };
 
 struct efi __read_mostly efi = {
         .mps        = EFI_INVALID_TABLE_ADDR,
@@ -79,13 +78,6 @@ struct efi_memory_map memmap;
 static struct efi efi_phys __initdata;
 static efi_system_table_t efi_systab __initdata;
 
-static u64 efi_var_store_size;
-static u64 efi_var_remaining_size;
-static u64 efi_var_max_var_size;
-static u64 boot_used_size;
-static u64 boot_var_size;
-static u64 active_size;
-
 unsigned long x86_efi_facility;
 
 /*
@@ -188,53 +180,8 @@ static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
                                                efi_char16_t *name,
                                                efi_guid_t *vendor)
 {
-        efi_status_t status;
-        static bool finished = false;
-        static u64 var_size;
-
-        status = efi_call_virt3(get_next_variable,
-                                name_size, name, vendor);
-
-        if (status == EFI_NOT_FOUND) {
-                finished = true;
-                if (var_size < boot_used_size) {
-                        boot_var_size = boot_used_size - var_size;
-                        active_size += boot_var_size;
-                } else {
-                        printk(KERN_WARNING FW_BUG  "efi: Inconsistent initial sizes\n");
-                }
-        }
-
-        if (boot_used_size && !finished) {
-                unsigned long size;
-                u32 attr;
-                efi_status_t s;
-                void *tmp;
-
-                s = virt_efi_get_variable(name, vendor, &attr, &size, NULL);
-
-                if (s != EFI_BUFFER_TOO_SMALL || !size)
-                        return status;
-
-                tmp = kmalloc(size, GFP_ATOMIC);
-
-                if (!tmp)
-                        return status;
-
-                s = virt_efi_get_variable(name, vendor, &attr, &size, tmp);
-
-                if (s == EFI_SUCCESS && (attr & EFI_VARIABLE_NON_VOLATILE)) {
-                        var_size += size;
-                        var_size += ucs2_strsize(name, 1024);
-                        active_size += size;
-                        active_size += VAR_METADATA_SIZE;
-                        active_size += ucs2_strsize(name, 1024);
-                }
-
-                kfree(tmp);
-        }
-
-        return status;
+        return efi_call_virt3(get_next_variable,
+                              name_size, name, vendor);
 }
 
 static efi_status_t virt_efi_set_variable(efi_char16_t *name,
@@ -243,34 +190,9 @@ static efi_status_t virt_efi_set_variable(efi_char16_t *name,
                                           unsigned long data_size,
                                           void *data)
 {
-        efi_status_t status;
-        u32 orig_attr = 0;
-        unsigned long orig_size = 0;
-
-        status = virt_efi_get_variable(name, vendor, &orig_attr, &orig_size,
-                                       NULL);
-
-        if (status != EFI_BUFFER_TOO_SMALL)
-                orig_size = 0;
-
-        status = efi_call_virt5(set_variable,
-                                name, vendor, attr,
-                                data_size, data);
-
-        if (status == EFI_SUCCESS) {
-                if (orig_size) {
-                        active_size -= orig_size;
-                        active_size -= ucs2_strsize(name, 1024);
-                        active_size -= VAR_METADATA_SIZE;
-                }
-                if (data_size) {
-                        active_size += data_size;
-                        active_size += ucs2_strsize(name, 1024);
-                        active_size += VAR_METADATA_SIZE;
-                }
-        }
-
-        return status;
+        return efi_call_virt5(set_variable,
+                              name, vendor, attr,
+                              data_size, data);
 }
 
 static efi_status_t virt_efi_query_variable_info(u32 attr,
@@ -786,9 +708,6 @@ void __init efi_init(void)
         char vendor[100] = "unknown";
         int i = 0;
         void *tmp;
-        struct setup_data *data;
-        struct efi_var_bootdata *efi_var_data;
-        u64 pa_data;
 
 #ifdef CONFIG_X86_32
         if (boot_params.efi_info.efi_systab_hi ||
@@ -806,22 +725,6 @@ void __init efi_init(void)
         if (efi_systab_init(efi_phys.systab))
                 return;
 
-        pa_data = boot_params.hdr.setup_data;
-        while (pa_data) {
-                data = early_ioremap(pa_data, sizeof(*efi_var_data));
-                if (data->type == SETUP_EFI_VARS) {
-                        efi_var_data = (struct efi_var_bootdata *)data;
-
-                        efi_var_store_size = efi_var_data->store_size;
-                        efi_var_remaining_size = efi_var_data->remaining_size;
-                        efi_var_max_var_size = efi_var_data->max_var_size;
-                }
-                pa_data = data->next;
-                early_iounmap(data, sizeof(*efi_var_data));
-        }
-
-        boot_used_size = efi_var_store_size - efi_var_remaining_size;
-
         set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility);
 
         /*
@@ -1085,6 +988,13 @@ void __init efi_enter_virtual_mode(void)
                 runtime_code_page_mkexec();
 
         kfree(new_memmap);
+
+        /* clean DUMMY object */
+        efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
+                         EFI_VARIABLE_NON_VOLATILE |
+                         EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                         EFI_VARIABLE_RUNTIME_ACCESS,
+                         0, NULL);
 }
 
 /*
@@ -1136,33 +1046,65 @@ efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
         efi_status_t status;
         u64 storage_size, remaining_size, max_size;
 
+        if (!(attributes & EFI_VARIABLE_NON_VOLATILE))
+                return 0;
+
         status = efi.query_variable_info(attributes, &storage_size,
                                          &remaining_size, &max_size);
         if (status != EFI_SUCCESS)
                 return status;
 
-        if (!max_size && remaining_size > size)
-                printk_once(KERN_ERR FW_BUG "Broken EFI implementation"
-                            " is returning MaxVariableSize=0\n");
         /*
          * Some firmware implementations refuse to boot if there's insufficient
          * space in the variable store. We account for that by refusing the
          * write if permitting it would reduce the available space to under
-         * 50%. However, some firmware won't reclaim variable space until
-         * after the used (not merely the actively used) space drops below
-         * a threshold. We can approximate that case with the value calculated
-         * above. If both the firmware and our calculations indicate that the
-         * available space would drop below 50%, refuse the write.
+         * 5KB. This figure was provided by Samsung, so should be safe.
          */
+        if ((remaining_size - size < EFI_MIN_RESERVE) &&
+                !efi_no_storage_paranoia) {
+
+                /*
+                 * Triggering garbage collection may require that the firmware
+                 * generate a real EFI_OUT_OF_RESOURCES error. We can force
+                 * that by attempting to use more space than is available.
+                 */
+                unsigned long dummy_size = remaining_size + 1024;
+                void *dummy = kmalloc(dummy_size, GFP_ATOMIC);
+
+                status = efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
+                                          EFI_VARIABLE_NON_VOLATILE |
+                                          EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                                          EFI_VARIABLE_RUNTIME_ACCESS,
+                                          dummy_size, dummy);
+
+                if (status == EFI_SUCCESS) {
+                        /*
+                         * This should have failed, so if it didn't make sure
+                         * that we delete it...
+                         */
+                        efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
+                                         EFI_VARIABLE_NON_VOLATILE |
+                                         EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                                         EFI_VARIABLE_RUNTIME_ACCESS,
+                                         0, dummy);
+                }
 
-        if (!storage_size || size > remaining_size ||
-            (max_size && size > max_size))
-                return EFI_OUT_OF_RESOURCES;
+                /*
+                 * The runtime code may now have triggered a garbage collection
+                 * run, so check the variable info again
+                 */
+                status = efi.query_variable_info(attributes, &storage_size,
+                                                 &remaining_size, &max_size);
 
-        if (!efi_no_storage_paranoia &&
-            ((active_size + size + VAR_METADATA_SIZE > storage_size / 2) &&
-             (remaining_size - size < storage_size / 2)))
-                return EFI_OUT_OF_RESOURCES;
+                if (status != EFI_SUCCESS)
+                        return status;
+
+                /*
+                 * There still isn't enough room, so return an error
+                 */
+                if (remaining_size - size < EFI_MIN_RESERVE)
+                        return EFI_OUT_OF_RESOURCES;
+        }
 
         return EFI_SUCCESS;
 }
diff --git a/arch/x86/tools/relocs.c b/arch/x86/tools/relocs.c
index 590be1090892..f7bab68a4b83 100644
--- a/arch/x86/tools/relocs.c
+++ b/arch/x86/tools/relocs.c
@@ -42,9 +42,6 @@ static const char * const sym_regex_kernel[S_NSYMTYPES] = {
         "^(xen_irq_disable_direct_reloc$|"
         "xen_save_fl_direct_reloc$|"
         "VDSO|"
-#if ELF_BITS == 64
-        "__vvar_page|"
-#endif
         "__crc_)",
 
 /*
@@ -72,6 +69,7 @@ static const char * const sym_regex_kernel[S_NSYMTYPES] = {
         "__per_cpu_load|"
         "init_per_cpu__.*|"
         "__end_rodata_hpage_align|"
+        "__vvar_page|"
 #endif
         "_end)$"
 };
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index 8ff37995d54e..d99cae8147d1 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -17,6 +17,7 @@
 #include <linux/slab.h>
 #include <linux/smp.h>
 #include <linux/irq_work.h>
+#include <linux/tick.h>
 
 #include <asm/paravirt.h>
 #include <asm/desc.h>
@@ -447,6 +448,13 @@ static void __cpuinit xen_play_dead(void) /* used only with HOTPLUG_CPU */
         play_dead_common();
         HYPERVISOR_vcpu_op(VCPUOP_down, smp_processor_id(), NULL);
         cpu_bringup();
+        /*
+         * commit 4b0c0f294 (tick: Cleanup NOHZ per cpu data on cpu down)
+         * clears certain data that the cpu_idle loop (which called us
+         * and that we return from) expects. The only way to get that
+         * data back is to call:
+         */
+        tick_nohz_idle_enter();
 }
 
 #else /* !CONFIG_HOTPLUG_CPU */
@@ -576,24 +584,22 @@ void xen_send_IPI_mask_allbutself(const struct cpumask *mask,
 {
         unsigned cpu;
         unsigned int this_cpu = smp_processor_id();
+        int xen_vector = xen_map_vector(vector);
 
-        if (!(num_online_cpus() > 1))
+        if (!(num_online_cpus() > 1) || (xen_vector < 0))
                 return;
 
         for_each_cpu_and(cpu, mask, cpu_online_mask) {
                 if (this_cpu == cpu)
                         continue;
 
-                xen_smp_send_call_function_single_ipi(cpu);
+                xen_send_IPI_one(cpu, xen_vector);
         }
 }
 
 void xen_send_IPI_allbutself(int vector)
 {
-        int xen_vector = xen_map_vector(vector);
-
-        if (xen_vector >= 0)
-                xen_send_IPI_mask_allbutself(cpu_online_mask, xen_vector);
+        xen_send_IPI_mask_allbutself(cpu_online_mask, vector);
 }
 
 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id)
diff --git a/arch/x86/xen/smp.h b/arch/x86/xen/smp.h
index 8981a76d081a..c7c2d89efd76 100644
--- a/arch/x86/xen/smp.h
+++ b/arch/x86/xen/smp.h
@@ -5,7 +5,6 @@ extern void xen_send_IPI_mask(const struct cpumask *mask,
 extern void xen_send_IPI_mask_allbutself(const struct cpumask *mask,
                                 int vector);
 extern void xen_send_IPI_allbutself(int vector);
-extern void physflat_send_IPI_allbutself(int vector);
 extern void xen_send_IPI_all(int vector);
 extern void xen_send_IPI_self(int vector);