Merge branch 'sched/urgent' into sched/core

Merge in the current fixes branch, we are going to apply dependent patches.

Signed-off-by: Ingo Molnar <mingo@kernel.org>

169 files changed, 2199 insertions, 2076 deletions

diff --git a/arch/alpha/Kconfig b/arch/alpha/Kconfig
index d5b9b5e645cc..9944dedee5b1 100644
--- a/arch/alpha/Kconfig
+++ b/arch/alpha/Kconfig
@@ -18,6 +18,8 @@ config ALPHA
         select ARCH_HAVE_NMI_SAFE_CMPXCHG
         select GENERIC_SMP_IDLE_THREAD
         select GENERIC_CMOS_UPDATE
+        select GENERIC_STRNCPY_FROM_USER
+        select GENERIC_STRNLEN_USER
         help
           The Alpha is a 64-bit general-purpose processor designed and
           marketed by the Digital Equipment Corporation of blessed memory,
diff --git a/arch/alpha/include/asm/atomic.h b/arch/alpha/include/asm/atomic.h
index 3bb7ffeae3bc..c2cbe4fc391c 100644
--- a/arch/alpha/include/asm/atomic.h
+++ b/arch/alpha/include/asm/atomic.h
@@ -14,8 +14,8 @@
  */
 
 
-#define ATOMIC_INIT(i)          ( (atomic_t) { (i) } )
-#define ATOMIC64_INIT(i)        ( (atomic64_t) { (i) } )
+#define ATOMIC_INIT(i)          { (i) }
+#define ATOMIC64_INIT(i)        { (i) }
 
 #define atomic_read(v)          (*(volatile int *)&(v)->counter)
 #define atomic64_read(v)        (*(volatile long *)&(v)->counter)
diff --git a/arch/alpha/include/asm/fpu.h b/arch/alpha/include/asm/fpu.h
index db00f7885faa..e477bcd5b94a 100644
--- a/arch/alpha/include/asm/fpu.h
+++ b/arch/alpha/include/asm/fpu.h
@@ -1,7 +1,9 @@
 #ifndef __ASM_ALPHA_FPU_H
 #define __ASM_ALPHA_FPU_H
 
+#ifdef __KERNEL__
 #include <asm/special_insns.h>
+#endif
 
 /*
  * Alpha floating-point control register defines:
diff --git a/arch/alpha/include/asm/ptrace.h b/arch/alpha/include/asm/ptrace.h
index fd698a174f26..b87755a19554 100644
--- a/arch/alpha/include/asm/ptrace.h
+++ b/arch/alpha/include/asm/ptrace.h
@@ -76,7 +76,10 @@ struct switch_stack {
 #define task_pt_regs(task) \
   ((struct pt_regs *) (task_stack_page(task) + 2*PAGE_SIZE) - 1)
 
-#define force_successful_syscall_return() (task_pt_regs(current)->r0 = 0)
+#define current_pt_regs() \
+  ((struct pt_regs *) ((char *)current_thread_info() + 2*PAGE_SIZE) - 1)
+
+#define force_successful_syscall_return() (current_pt_regs()->r0 = 0)
 
 #endif
 
diff --git a/arch/alpha/include/asm/socket.h b/arch/alpha/include/asm/socket.h
index dcb221a4b5be..7d2f75be932e 100644
--- a/arch/alpha/include/asm/socket.h
+++ b/arch/alpha/include/asm/socket.h
@@ -76,9 +76,11 @@
 /* Instruct lower device to use last 4-bytes of skb data as FCS */
 #define SO_NOFCS                43
 
+#ifdef __KERNEL__
 /* O_NONBLOCK clashes with the bits used for socket types.  Therefore we
  * have to define SOCK_NONBLOCK to a different value here.
  */
 #define SOCK_NONBLOCK   0x40000000
+#endif /* __KERNEL__ */
 
 #endif /* _ASM_SOCKET_H */
diff --git a/arch/alpha/include/asm/uaccess.h b/arch/alpha/include/asm/uaccess.h
index b49ec2f8d6e3..766fdfde2b7a 100644
--- a/arch/alpha/include/asm/uaccess.h
+++ b/arch/alpha/include/asm/uaccess.h
@@ -433,36 +433,12 @@ clear_user(void __user *to, long len)
 #undef __module_address
 #undef __module_call
 
-/* Returns: -EFAULT if exception before terminator, N if the entire
-   buffer filled, else strlen.  */
+#define user_addr_max() \
+        (segment_eq(get_fs(), USER_DS) ? TASK_SIZE : ~0UL)
 
-extern long __strncpy_from_user(char *__to, const char __user *__from, long __to_len);
-
-extern inline long
-strncpy_from_user(char *to, const char __user *from, long n)
-{
-        long ret = -EFAULT;
-        if (__access_ok((unsigned long)from, 0, get_fs()))
-                ret = __strncpy_from_user(to, from, n);
-        return ret;
-}
-
-/* Returns: 0 if bad, string length+1 (memory size) of string if ok */
-extern long __strlen_user(const char __user *);
-
-extern inline long strlen_user(const char __user *str)
-{
-        return access_ok(VERIFY_READ,str,0) ? __strlen_user(str) : 0;
-}
-
-/* Returns: 0 if exception before NUL or reaching the supplied limit (N),
- * a value greater than N if the limit would be exceeded, else strlen.  */
-extern long __strnlen_user(const char __user *, long);
-
-extern inline long strnlen_user(const char __user *str, long n)
-{
-        return access_ok(VERIFY_READ,str,0) ? __strnlen_user(str, n) : 0;
-}
+extern long strncpy_from_user(char *dest, const char __user *src, long count);
+extern __must_check long strlen_user(const char __user *str);
+extern __must_check long strnlen_user(const char __user *str, long n);
 
 /*
  * About the exception table:
diff --git a/arch/alpha/include/asm/unistd.h b/arch/alpha/include/asm/unistd.h
index 633b23b0664a..a31a78eac9b9 100644
--- a/arch/alpha/include/asm/unistd.h
+++ b/arch/alpha/include/asm/unistd.h
@@ -465,10 +465,12 @@
 #define __NR_setns                      501
 #define __NR_accept4                    502
 #define __NR_sendmmsg                   503
+#define __NR_process_vm_readv           504
+#define __NR_process_vm_writev          505
 
 #ifdef __KERNEL__
 
-#define NR_SYSCALLS                     504
+#define NR_SYSCALLS                     506
 
 #define __ARCH_WANT_OLD_READDIR
 #define __ARCH_WANT_STAT64
diff --git a/arch/alpha/include/asm/word-at-a-time.h b/arch/alpha/include/asm/word-at-a-time.h
new file mode 100644
index 000000000000..6b340d0f1521
--- /dev/null
+++ b/arch/alpha/include/asm/word-at-a-time.h
@@ -0,0 +1,55 @@
+#ifndef _ASM_WORD_AT_A_TIME_H
+#define _ASM_WORD_AT_A_TIME_H
+
+#include <asm/compiler.h>
+
+/*
+ * word-at-a-time interface for Alpha.
+ */
+
+/*
+ * We do not use the word_at_a_time struct on Alpha, but it needs to be
+ * implemented to humour the generic code.
+ */
+struct word_at_a_time {
+        const unsigned long unused;
+};
+
+#define WORD_AT_A_TIME_CONSTANTS { 0 }
+
+/* Return nonzero if val has a zero */
+static inline unsigned long has_zero(unsigned long val, unsigned long *bits, const struct word_at_a_time *c)
+{
+        unsigned long zero_locations = __kernel_cmpbge(0, val);
+        *bits = zero_locations;
+        return zero_locations;
+}
+
+static inline unsigned long prep_zero_mask(unsigned long val, unsigned long bits, const struct word_at_a_time *c)
+{
+        return bits;
+}
+
+#define create_zero_mask(bits) (bits)
+
+static inline unsigned long find_zero(unsigned long bits)
+{
+#if defined(CONFIG_ALPHA_EV6) && defined(CONFIG_ALPHA_EV67)
+        /* Simple if have CIX instructions */
+        return __kernel_cttz(bits);
+#else
+        unsigned long t1, t2, t3;
+        /* Retain lowest set bit only */
+        bits &= -bits;
+        /* Binary search for lowest set bit */
+        t1 = bits & 0xf0;
+        t2 = bits & 0xcc;
+        t3 = bits & 0xaa;
+        if (t1) t1 = 4;
+        if (t2) t2 = 2;
+        if (t3) t3 = 1;
+        return t1 + t2 + t3;
+#endif
+}
+
+#endif /* _ASM_WORD_AT_A_TIME_H */
diff --git a/arch/alpha/kernel/alpha_ksyms.c b/arch/alpha/kernel/alpha_ksyms.c
index d96e742d4dc2..15fa821d09cd 100644
--- a/arch/alpha/kernel/alpha_ksyms.c
+++ b/arch/alpha/kernel/alpha_ksyms.c
@@ -52,7 +52,6 @@ EXPORT_SYMBOL(alpha_write_fp_reg_s);
 
 /* entry.S */
 EXPORT_SYMBOL(kernel_thread);
-EXPORT_SYMBOL(kernel_execve);
 
 /* Networking helper routines. */
 EXPORT_SYMBOL(csum_tcpudp_magic);
@@ -74,8 +73,6 @@ EXPORT_SYMBOL(alpha_fp_emul);
  */
 EXPORT_SYMBOL(__copy_user);
 EXPORT_SYMBOL(__do_clear_user);
-EXPORT_SYMBOL(__strncpy_from_user);
-EXPORT_SYMBOL(__strnlen_user);
 
 /* 
  * SMP-specific symbols.
diff --git a/arch/alpha/kernel/entry.S b/arch/alpha/kernel/entry.S
index 6d159cee5f2f..ec0da0567ab5 100644
--- a/arch/alpha/kernel/entry.S
+++ b/arch/alpha/kernel/entry.S
@@ -663,58 +663,6 @@ kernel_thread:
         br      ret_to_kernel
 .end kernel_thread
 
-/*
- * kernel_execve(path, argv, envp)
- */
-        .align  4
-        .globl  kernel_execve
-        .ent    kernel_execve
-kernel_execve:
-        /* We can be called from a module.  */
-        ldgp    $gp, 0($27)
-        lda     $sp, -(32+SIZEOF_PT_REGS+8)($sp)
-        .frame  $sp, 32+SIZEOF_PT_REGS+8, $26, 0
-        stq     $26, 0($sp)
-        stq     $16, 8($sp)
-        stq     $17, 16($sp)
-        stq     $18, 24($sp)
-        .prologue 1
-
-        lda     $16, 32($sp)
-        lda     $17, 0
-        lda     $18, SIZEOF_PT_REGS
-        bsr     $26, memset             !samegp
-
-        /* Avoid the HAE being gratuitously wrong, which would cause us
-           to do the whole turn off interrupts thing and restore it.  */
-        ldq     $2, alpha_mv+HAE_CACHE
-        stq     $2, 152+32($sp)
-
-        ldq     $16, 8($sp)
-        ldq     $17, 16($sp)
-        ldq     $18, 24($sp)
-        lda     $19, 32($sp)
-        bsr     $26, do_execve          !samegp
-
-        ldq     $26, 0($sp)
-        bne     $0, 1f                  /* error! */
-
-        /* Move the temporary pt_regs struct from its current location
-           to the top of the kernel stack frame.  See copy_thread for
-           details for a normal process.  */
-        lda     $16, 0x4000 - SIZEOF_PT_REGS($8)
-        lda     $17, 32($sp)
-        lda     $18, SIZEOF_PT_REGS
-        bsr     $26, memmove            !samegp
-
-        /* Take that over as our new stack frame and visit userland!  */
-        lda     $sp, 0x4000 - SIZEOF_PT_REGS($8)
-        br      $31, ret_from_sys_call
-
-1:      lda     $sp, 32+SIZEOF_PT_REGS+8($sp)
-        ret
-.end kernel_execve
-
 
 /*
  * Special system calls.  Most of these are special in that they either
@@ -797,115 +745,6 @@ sys_rt_sigreturn:
 .end sys_rt_sigreturn
 
         .align  4
-        .globl  sys_sethae
-        .ent    sys_sethae
-sys_sethae:
-        .prologue 0
-        stq     $16, 152($sp)
-        ret
-.end sys_sethae
-
-        .align  4
-        .globl  osf_getpriority
-        .ent    osf_getpriority
-osf_getpriority:
-        lda     $sp, -16($sp)
-        stq     $26, 0($sp)
-        .prologue 0
-
-        jsr     $26, sys_getpriority
-
-        ldq     $26, 0($sp)
-        blt     $0, 1f
-
-        /* Return value is the unbiased priority, i.e. 20 - prio.
-           This does result in negative return values, so signal
-           no error by writing into the R0 slot.  */
-        lda     $1, 20
-        stq     $31, 16($sp)
-        subl    $1, $0, $0
-        unop
-
-1:      lda     $sp, 16($sp)
-        ret
-.end osf_getpriority
-
-        .align  4
-        .globl  sys_getxuid
-        .ent    sys_getxuid
-sys_getxuid:
-        .prologue 0
-        ldq     $2, TI_TASK($8)
-        ldq     $3, TASK_CRED($2)
-        ldl     $0, CRED_UID($3)
-        ldl     $1, CRED_EUID($3)
-        stq     $1, 80($sp)
-        ret
-.end sys_getxuid
-
-        .align  4
-        .globl  sys_getxgid
-        .ent    sys_getxgid
-sys_getxgid:
-        .prologue 0
-        ldq     $2, TI_TASK($8)
-        ldq     $3, TASK_CRED($2)
-        ldl     $0, CRED_GID($3)
-        ldl     $1, CRED_EGID($3)
-        stq     $1, 80($sp)
-        ret
-.end sys_getxgid
-
-        .align  4
-        .globl  sys_getxpid
-        .ent    sys_getxpid
-sys_getxpid:
-        .prologue 0
-        ldq     $2, TI_TASK($8)
-
-        /* See linux/kernel/timer.c sys_getppid for discussion
-           about this loop.  */
-        ldq     $3, TASK_GROUP_LEADER($2)
-        ldq     $4, TASK_REAL_PARENT($3)
-        ldl     $0, TASK_TGID($2)
-1:      ldl     $1, TASK_TGID($4)
-#ifdef CONFIG_SMP
-        mov     $4, $5
-        mb
-        ldq     $3, TASK_GROUP_LEADER($2)
-        ldq     $4, TASK_REAL_PARENT($3)
-        cmpeq   $4, $5, $5
-        beq     $5, 1b
-#endif
-        stq     $1, 80($sp)
-        ret
-.end sys_getxpid
-
-        .align  4
-        .globl  sys_alpha_pipe
-        .ent    sys_alpha_pipe
-sys_alpha_pipe:
-        lda     $sp, -16($sp)
-        stq     $26, 0($sp)
-        .prologue 0
-
-        mov     $31, $17
-        lda     $16, 8($sp)
-        jsr     $26, do_pipe_flags
-
-        ldq     $26, 0($sp)
-        bne     $0, 1f
-
-        /* The return values are in $0 and $20.  */
-        ldl     $1, 12($sp)
-        ldl     $0, 8($sp)
-
-        stq     $1, 80+16($sp)
-1:      lda     $sp, 16($sp)
-        ret
-.end sys_alpha_pipe
-
-        .align  4
         .globl  sys_execve
         .ent    sys_execve
 sys_execve:
diff --git a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c
index 98a103621af6..bc1acdda7a5e 100644
--- a/arch/alpha/kernel/osf_sys.c
+++ b/arch/alpha/kernel/osf_sys.c
@@ -1404,3 +1404,52 @@ SYSCALL_DEFINE3(osf_writev, unsigned long, fd,
 }
 
 #endif
+
+SYSCALL_DEFINE2(osf_getpriority, int, which, int, who)
+{
+        int prio = sys_getpriority(which, who);
+        if (prio >= 0) {
+                /* Return value is the unbiased priority, i.e. 20 - prio.
+                   This does result in negative return values, so signal
+                   no error */
+                force_successful_syscall_return();
+                prio = 20 - prio;
+        }
+        return prio;
+}
+
+SYSCALL_DEFINE0(getxuid)
+{
+        current_pt_regs()->r20 = sys_geteuid();
+        return sys_getuid();
+}
+
+SYSCALL_DEFINE0(getxgid)
+{
+        current_pt_regs()->r20 = sys_getegid();
+        return sys_getgid();
+}
+
+SYSCALL_DEFINE0(getxpid)
+{
+        current_pt_regs()->r20 = sys_getppid();
+        return sys_getpid();
+}
+
+SYSCALL_DEFINE0(alpha_pipe)
+{
+        int fd[2];
+        int res = do_pipe_flags(fd, 0);
+        if (!res) {
+                /* The return values are in $0 and $20.  */
+                current_pt_regs()->r20 = fd[1];
+                res = fd[0];
+        }
+        return res;
+}
+
+SYSCALL_DEFINE1(sethae, unsigned long, val)
+{
+        current_pt_regs()->hae = val;
+        return 0;
+}
diff --git a/arch/alpha/kernel/process.c b/arch/alpha/kernel/process.c
index 153d3fce3e8e..d6fde98b74b3 100644
--- a/arch/alpha/kernel/process.c
+++ b/arch/alpha/kernel/process.c
@@ -455,3 +455,22 @@ get_wchan(struct task_struct *p)
         }
         return pc;
 }
+
+int kernel_execve(const char *path, const char *const argv[], const char *const envp[])
+{
+        /* Avoid the HAE being gratuitously wrong, which would cause us
+           to do the whole turn off interrupts thing and restore it.  */
+        struct pt_regs regs = {.hae = alpha_mv.hae_cache};
+        int err = do_execve(path, argv, envp, &regs);
+        if (!err) {
+                struct pt_regs *p = current_pt_regs();
+                /* copy regs to normal position and off to userland we go... */
+                *p = regs;
+                __asm__ __volatile__ (
+                        "mov    %0, $sp;"
+                        "br     $31, ret_from_sys_call"
+                        : : "r"(p));
+        }
+        return err;
+}
+EXPORT_SYMBOL(kernel_execve);
diff --git a/arch/alpha/kernel/systbls.S b/arch/alpha/kernel/systbls.S
index 87835235f114..2ac6b45c3e00 100644
--- a/arch/alpha/kernel/systbls.S
+++ b/arch/alpha/kernel/systbls.S
@@ -111,7 +111,7 @@ sys_call_table:
         .quad sys_socket
         .quad sys_connect
         .quad sys_accept
-        .quad osf_getpriority                   /* 100 */
+        .quad sys_osf_getpriority                       /* 100 */
         .quad sys_send
         .quad sys_recv
         .quad sys_sigreturn
@@ -522,6 +522,8 @@ sys_call_table:
         .quad sys_setns
         .quad sys_accept4
         .quad sys_sendmmsg
+        .quad sys_process_vm_readv
+        .quad sys_process_vm_writev             /* 505 */
 
         .size sys_call_table, . - sys_call_table
         .type sys_call_table, @object
diff --git a/arch/alpha/lib/Makefile b/arch/alpha/lib/Makefile
index c0a83ab62b78..59660743237c 100644
--- a/arch/alpha/lib/Makefile
+++ b/arch/alpha/lib/Makefile
@@ -31,8 +31,6 @@ lib-y =	__divqu.o __remqu.o __divlu.o __remlu.o \
         $(ev6-y)memchr.o \
         $(ev6-y)copy_user.o \
         $(ev6-y)clear_user.o \
-        $(ev6-y)strncpy_from_user.o \
-        $(ev67-y)strlen_user.o \
         $(ev6-y)csum_ipv6_magic.o \
         $(ev6-y)clear_page.o \
         $(ev6-y)copy_page.o \
diff --git a/arch/alpha/lib/ev6-strncpy_from_user.S b/arch/alpha/lib/ev6-strncpy_from_user.S
deleted file mode 100644
index d2e28178cacc..000000000000
--- a/arch/alpha/lib/ev6-strncpy_from_user.S
+++ /dev/null
@@ -1,424 +0,0 @@
-/*
- * arch/alpha/lib/ev6-strncpy_from_user.S
- * 21264 version contributed by Rick Gorton <rick.gorton@alpha-processor.com>
- *
- * Just like strncpy except in the return value:
- *
- * -EFAULT       if an exception occurs before the terminator is copied.
- * N             if the buffer filled.
- *
- * Otherwise the length of the string is returned.
- *
- * Much of the information about 21264 scheduling/coding comes from:
- *      Compiler Writer's Guide for the Alpha 21264
- *      abbreviated as 'CWG' in other comments here
- *      ftp.digital.com/pub/Digital/info/semiconductor/literature/dsc-library.html
- * Scheduling notation:
- *      E       - either cluster
- *      U       - upper subcluster; U0 - subcluster U0; U1 - subcluster U1
- *      L       - lower subcluster; L0 - subcluster L0; L1 - subcluster L1
- * A bunch of instructions got moved and temp registers were changed
- * to aid in scheduling.  Control flow was also re-arranged to eliminate
- * branches, and to provide longer code sequences to enable better scheduling.
- * A total rewrite (using byte load/stores for start & tail sequences)
- * is desirable, but very difficult to do without a from-scratch rewrite.
- * Save that for the future.
- */
-
-
-#include <asm/errno.h>
-#include <asm/regdef.h>
-
-
-/* Allow an exception for an insn; exit if we get one.  */
-#define EX(x,y...)                      \
-        99: x,##y;                      \
-        .section __ex_table,"a";        \
-        .long 99b - .;                  \
-        lda $31, $exception-99b($0);    \
-        .previous
-
-
-        .set noat
-        .set noreorder
-        .text
-
-        .globl __strncpy_from_user
-        .ent __strncpy_from_user
-        .frame $30, 0, $26
-        .prologue 0
-
-        .align 4
-__strncpy_from_user:
-        and     a0, 7, t3       # E : find dest misalignment
-        beq     a2, $zerolength # U :
-
-        /* Are source and destination co-aligned?  */
-        mov     a0, v0          # E : save the string start
-        xor     a0, a1, t4      # E :
-        EX( ldq_u t1, 0(a1) )   # L : Latency=3 load first quadword
-        ldq_u   t0, 0(a0)       # L : load first (partial) aligned dest quadword
-
-        addq    a2, t3, a2      # E : bias count by dest misalignment
-        subq    a2, 1, a3       # E :
-        addq    zero, 1, t10    # E :
-        and     t4, 7, t4       # E : misalignment between the two
-
-        and     a3, 7, t6       # E : number of tail bytes
-        sll     t10, t6, t10    # E : t10 = bitmask of last count byte
-        bne     t4, $unaligned  # U :
-        lda     t2, -1          # E : build a mask against false zero
-
-        /*
-         * We are co-aligned; take care of a partial first word.
-         * On entry to this basic block:
-         * t0 == the first destination word for masking back in
-         * t1 == the first source word.
-         */
-
-        srl     a3, 3, a2       # E : a2 = loop counter = (count - 1)/8
-        addq    a1, 8, a1       # E :
-        mskqh   t2, a1, t2      # U :   detection in the src word
-        nop
-
-        /* Create the 1st output word and detect 0's in the 1st input word.  */
-        mskqh   t1, a1, t3      # U :
-        mskql   t0, a1, t0      # U : assemble the first output word
-        ornot   t1, t2, t2      # E :
-        nop
-
-        cmpbge  zero, t2, t8    # E : bits set iff null found
-        or      t0, t3, t0      # E :
-        beq     a2, $a_eoc      # U :
-        bne     t8, $a_eos      # U : 2nd branch in a quad.  Bad.
-
-        /* On entry to this basic block:
-         * t0 == a source quad not containing a null.
-         * a0 - current aligned destination address
-         * a1 - current aligned source address
-         * a2 - count of quadwords to move.
-         * NOTE: Loop improvement - unrolling this is going to be
-         *      a huge win, since we're going to stall otherwise.
-         *      Fix this later.  For _really_ large copies, look
-         *      at using wh64 on a look-ahead basis.  See the code
-         *      in clear_user.S and copy_user.S.
-         * Presumably, since (a0) and (a1) do not overlap (by C definition)
-         * Lots of nops here:
-         *      - Separate loads from stores
-         *      - Keep it to 1 branch/quadpack so the branch predictor
-         *        can train.
-         */
-$a_loop:
-        stq_u   t0, 0(a0)       # L :
-        addq    a0, 8, a0       # E :
-        nop
-        subq    a2, 1, a2       # E :
-
-        EX( ldq_u t0, 0(a1) )   # L :
-        addq    a1, 8, a1       # E :
-        cmpbge  zero, t0, t8    # E : Stall 2 cycles on t0
-        beq     a2, $a_eoc      # U :
-
-        beq     t8, $a_loop     # U :
-        nop
-        nop
-        nop
-
-        /* Take care of the final (partial) word store.  At this point
-         * the end-of-count bit is set in t8 iff it applies.
-         *
-         * On entry to this basic block we have:
-         * t0 == the source word containing the null
-         * t8 == the cmpbge mask that found it.
-         */
-$a_eos:
-        negq    t8, t12         # E : find low bit set
-        and     t8, t12, t12    # E : 
-
-        /* We're doing a partial word store and so need to combine
-           our source and original destination words.  */
-        ldq_u   t1, 0(a0)       # L :
-        subq    t12, 1, t6      # E :
-
-        or      t12, t6, t8     # E :
-        zapnot  t0, t8, t0      # U : clear src bytes > null
-        zap     t1, t8, t1      # U : clear dst bytes <= null
-        or      t0, t1, t0      # E :
-
-        stq_u   t0, 0(a0)       # L :
-        br      $finish_up      # L0 :
-        nop
-        nop
-
-        /* Add the end-of-count bit to the eos detection bitmask.  */
-        .align 4
-$a_eoc:
-        or      t10, t8, t8
-        br      $a_eos
-        nop
-        nop
-
-
-/* The source and destination are not co-aligned.  Align the destination
-   and cope.  We have to be very careful about not reading too much and
-   causing a SEGV.  */
-
-        .align 4
-$u_head:
-        /* We know just enough now to be able to assemble the first
-           full source word.  We can still find a zero at the end of it
-           that prevents us from outputting the whole thing.
-
-           On entry to this basic block:
-           t0 == the first dest word, unmasked
-           t1 == the shifted low bits of the first source word
-           t6 == bytemask that is -1 in dest word bytes */
-
-        EX( ldq_u t2, 8(a1) )   # L : load second src word
-        addq    a1, 8, a1       # E :
-        mskql   t0, a0, t0      # U : mask trailing garbage in dst
-        extqh   t2, a1, t4      # U :
-
-        or      t1, t4, t1      # E : first aligned src word complete
-        mskqh   t1, a0, t1      # U : mask leading garbage in src
-        or      t0, t1, t0      # E : first output word complete
-        or      t0, t6, t6      # E : mask original data for zero test
-
-        cmpbge  zero, t6, t8    # E :
-        beq     a2, $u_eocfin   # U :
-        bne     t8, $u_final    # U : bad news - 2nd branch in a quad
-        lda     t6, -1          # E : mask out the bits we have
-
-        mskql   t6, a1, t6      # U :   already seen
-        stq_u   t0, 0(a0)       # L : store first output word
-        or      t6, t2, t2      # E :
-        cmpbge  zero, t2, t8    # E : find nulls in second partial
-
-        addq    a0, 8, a0               # E :
-        subq    a2, 1, a2               # E :
-        bne     t8, $u_late_head_exit   # U :
-        nop
-
-        /* Finally, we've got all the stupid leading edge cases taken care
-           of and we can set up to enter the main loop.  */
-
-        extql   t2, a1, t1      # U : position hi-bits of lo word
-        EX( ldq_u t2, 8(a1) )   # L : read next high-order source word
-        addq    a1, 8, a1       # E :
-        cmpbge  zero, t2, t8    # E :
-
-        beq     a2, $u_eoc      # U :
-        bne     t8, $u_eos      # U :
-        nop
-        nop
-
-        /* Unaligned copy main loop.  In order to avoid reading too much,
-           the loop is structured to detect zeros in aligned source words.
-           This has, unfortunately, effectively pulled half of a loop
-           iteration out into the head and half into the tail, but it does
-           prevent nastiness from accumulating in the very thing we want
-           to run as fast as possible.
-
-           On entry to this basic block:
-           t1 == the shifted high-order bits from the previous source word
-           t2 == the unshifted current source word
-
-           We further know that t2 does not contain a null terminator.  */
-
-        /*
-         * Extra nops here:
-         *      separate load quads from store quads
-         *      only one branch/quad to permit predictor training
-         */
-
-        .align 4
-$u_loop:
-        extqh   t2, a1, t0      # U : extract high bits for current word
-        addq    a1, 8, a1       # E :
-        extql   t2, a1, t3      # U : extract low bits for next time
-        addq    a0, 8, a0       # E :
-
-        or      t0, t1, t0      # E : current dst word now complete
-        EX( ldq_u t2, 0(a1) )   # L : load high word for next time
-        subq    a2, 1, a2       # E :
-        nop
-
-        stq_u   t0, -8(a0)      # L : save the current word
-        mov     t3, t1          # E :
-        cmpbge  zero, t2, t8    # E : test new word for eos
-        beq     a2, $u_eoc      # U :
-
-        beq     t8, $u_loop     # U :
-        nop
-        nop
-        nop
-
-        /* We've found a zero somewhere in the source word we just read.
-           If it resides in the lower half, we have one (probably partial)
-           word to write out, and if it resides in the upper half, we
-           have one full and one partial word left to write out.
-
-           On entry to this basic block:
-           t1 == the shifted high-order bits from the previous source word
-           t2 == the unshifted current source word.  */
-        .align 4
-$u_eos:
-        extqh   t2, a1, t0      # U :
-        or      t0, t1, t0      # E : first (partial) source word complete
-        cmpbge  zero, t0, t8    # E : is the null in this first bit?
-        nop
-
-        bne     t8, $u_final    # U :
-        stq_u   t0, 0(a0)       # L : the null was in the high-order bits
-        addq    a0, 8, a0       # E :
-        subq    a2, 1, a2       # E :
-
-        .align 4
-$u_late_head_exit:
-        extql   t2, a1, t0      # U :
-        cmpbge  zero, t0, t8    # E :
-        or      t8, t10, t6     # E :
-        cmoveq  a2, t6, t8      # E :
-
-        /* Take care of a final (probably partial) result word.
-           On entry to this basic block:
-           t0 == assembled source word
-           t8 == cmpbge mask that found the null.  */
-        .align 4
-$u_final:
-        negq    t8, t6          # E : isolate low bit set
-        and     t6, t8, t12     # E :
-        ldq_u   t1, 0(a0)       # L :
-        subq    t12, 1, t6      # E :
-
-        or      t6, t12, t8     # E :
-        zapnot  t0, t8, t0      # U : kill source bytes > null
-        zap     t1, t8, t1      # U : kill dest bytes <= null
-        or      t0, t1, t0      # E :
-
-        stq_u   t0, 0(a0)       # E :
-        br      $finish_up      # U :
-        nop
-        nop
-
-        .align 4
-$u_eoc:                         # end-of-count
-        extqh   t2, a1, t0      # U :
-        or      t0, t1, t0      # E :
-        cmpbge  zero, t0, t8    # E :
-        nop
-
-        .align 4
-$u_eocfin:                      # end-of-count, final word
-        or      t10, t8, t8     # E :
-        br      $u_final        # U :
-        nop
-        nop
-
-        /* Unaligned copy entry point.  */
-        .align 4
-$unaligned:
-
-        srl     a3, 3, a2       # U : a2 = loop counter = (count - 1)/8
-        and     a0, 7, t4       # E : find dest misalignment
-        and     a1, 7, t5       # E : find src misalignment
-        mov     zero, t0        # E :
-
-        /* Conditionally load the first destination word and a bytemask
-           with 0xff indicating that the destination byte is sacrosanct.  */
-
-        mov     zero, t6        # E :
-        beq     t4, 1f          # U :
-        ldq_u   t0, 0(a0)       # L :
-        lda     t6, -1          # E :
-
-        mskql   t6, a0, t6      # E :
-        nop
-        nop
-        nop
-
-        .align 4
-1:
-        subq    a1, t4, a1      # E : sub dest misalignment from src addr
-        /* If source misalignment is larger than dest misalignment, we need
-           extra startup checks to avoid SEGV.  */
-        cmplt   t4, t5, t12     # E :
-        extql   t1, a1, t1      # U : shift src into place
-        lda     t2, -1          # E : for creating masks later
-
-        beq     t12, $u_head    # U :
-        mskqh   t2, t5, t2      # U : begin src byte validity mask
-        cmpbge  zero, t1, t8    # E : is there a zero?
-        nop
-
-        extql   t2, a1, t2      # U :
-        or      t8, t10, t5     # E : test for end-of-count too
-        cmpbge  zero, t2, t3    # E :
-        cmoveq  a2, t5, t8      # E : Latency=2, extra map slot
-
-        nop                     # E : goes with cmov
-        andnot  t8, t3, t8      # E :
-        beq     t8, $u_head     # U :
-        nop
-
-        /* At this point we've found a zero in the first partial word of
-           the source.  We need to isolate the valid source data and mask
-           it into the original destination data.  (Incidentally, we know
-           that we'll need at least one byte of that original dest word.) */
-
-        ldq_u   t0, 0(a0)       # L :
-        negq    t8, t6          # E : build bitmask of bytes <= zero
-        mskqh   t1, t4, t1      # U :
-        and     t6, t8, t12     # E :
-
-        subq    t12, 1, t6      # E :
-        or      t6, t12, t8     # E :
-        zapnot  t2, t8, t2      # U : prepare source word; mirror changes
-        zapnot  t1, t8, t1      # U : to source validity mask
-
-        andnot  t0, t2, t0      # E : zero place for source to reside
-        or      t0, t1, t0      # E : and put it there
-        stq_u   t0, 0(a0)       # L :
-        nop
-
-        .align 4
-$finish_up:
-        zapnot  t0, t12, t4     # U : was last byte written null?
-        and     t12, 0xf0, t3   # E : binary search for the address of the
-        cmovne  t4, 1, t4       # E : Latency=2, extra map slot
-        nop                     # E : with cmovne
-
-        and     t12, 0xcc, t2   # E : last byte written
-        and     t12, 0xaa, t1   # E :
-        cmovne  t3, 4, t3       # E : Latency=2, extra map slot
-        nop                     # E : with cmovne
-
-        bic     a0, 7, t0
-        cmovne  t2, 2, t2       # E : Latency=2, extra map slot
-        nop                     # E : with cmovne
-        nop
-
-        cmovne  t1, 1, t1       # E : Latency=2, extra map slot
-        nop                     # E : with cmovne
-        addq    t0, t3, t0      # E :
-        addq    t1, t2, t1      # E :
-
-        addq    t0, t1, t0      # E :
-        addq    t0, t4, t0      # add one if we filled the buffer
-        subq    t0, v0, v0      # find string length
-        ret                     # L0 :
-
-        .align 4
-$zerolength:
-        nop
-        nop
-        nop
-        clr     v0
-
-$exception:
-        nop
-        nop
-        nop
-        ret
-
-        .end __strncpy_from_user
diff --git a/arch/alpha/lib/ev67-strlen_user.S b/arch/alpha/lib/ev67-strlen_user.S
deleted file mode 100644
index 57e0d77b81a6..000000000000
--- a/arch/alpha/lib/ev67-strlen_user.S
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * arch/alpha/lib/ev67-strlen_user.S
- * 21264 version contributed by Rick Gorton <rick.gorton@api-networks.com>
- *
- * Return the length of the string including the NULL terminator
- * (strlen+1) or zero if an error occurred.
- *
- * In places where it is critical to limit the processing time,
- * and the data is not trusted, strnlen_user() should be used.
- * It will return a value greater than its second argument if
- * that limit would be exceeded. This implementation is allowed
- * to access memory beyond the limit, but will not cross a page
- * boundary when doing so.
- *
- * Much of the information about 21264 scheduling/coding comes from:
- *      Compiler Writer's Guide for the Alpha 21264
- *      abbreviated as 'CWG' in other comments here
- *      ftp.digital.com/pub/Digital/info/semiconductor/literature/dsc-library.html
- * Scheduling notation:
- *      E       - either cluster
- *      U       - upper subcluster; U0 - subcluster U0; U1 - subcluster U1
- *      L       - lower subcluster; L0 - subcluster L0; L1 - subcluster L1
- * Try not to change the actual algorithm if possible for consistency.
- */
-
-#include <asm/regdef.h>
-
-
-/* Allow an exception for an insn; exit if we get one.  */
-#define EX(x,y...)                      \
-        99: x,##y;                      \
-        .section __ex_table,"a";        \
-        .long 99b - .;                  \
-        lda v0, $exception-99b(zero);   \
-        .previous
-
-
-        .set noreorder
-        .set noat
-        .text
-
-        .globl __strlen_user
-        .ent __strlen_user
-        .frame sp, 0, ra
-
-        .align 4
-__strlen_user:
-        ldah    a1, 32767(zero) # do not use plain strlen_user() for strings
-                                # that might be almost 2 GB long; you should
-                                # be using strnlen_user() instead
-        nop
-        nop
-        nop
-
-        .globl __strnlen_user
-
-        .align 4
-__strnlen_user:
-        .prologue 0
-        EX( ldq_u t0, 0(a0) )   # L : load first quadword (a0 may be misaligned)
-        lda     t1, -1(zero)    # E :
-
-        insqh   t1, a0, t1      # U :
-        andnot  a0, 7, v0       # E :
-        or      t1, t0, t0      # E :
-        subq    a0, 1, a0       # E : get our +1 for the return 
-
-        cmpbge  zero, t0, t1    # E : t1 <- bitmask: bit i == 1 <==> i-th byte == 0
-        subq    a1, 7, t2       # E :
-        subq    a0, v0, t0      # E :
-        bne     t1, $found      # U :
-
-        addq    t2, t0, t2      # E :
-        addq    a1, 1, a1       # E :
-        nop                     # E :
-        nop                     # E :
-
-        .align 4
-$loop:  ble     t2, $limit      # U :
-        EX( ldq t0, 8(v0) )     # L :
-        nop                     # E :
-        nop                     # E :
-
-        cmpbge  zero, t0, t1    # E :
-        subq    t2, 8, t2       # E :
-        addq    v0, 8, v0       # E : addr += 8
-        beq     t1, $loop       # U :
-
-$found: cttz    t1, t2          # U0 :
-        addq    v0, t2, v0      # E :
-        subq    v0, a0, v0      # E :
-        ret                     # L0 :
-
-$exception:
-        nop
-        nop
-        nop
-        ret
-
-        .align 4                # currently redundant
-$limit:
-        nop
-        nop
-        subq    a1, t2, v0
-        ret
-
-        .end __strlen_user
diff --git a/arch/alpha/lib/strlen_user.S b/arch/alpha/lib/strlen_user.S
deleted file mode 100644
index 508a18e96479..000000000000
--- a/arch/alpha/lib/strlen_user.S
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * arch/alpha/lib/strlen_user.S
- *
- * Return the length of the string including the NUL terminator
- * (strlen+1) or zero if an error occurred.
- *
- * In places where it is critical to limit the processing time,
- * and the data is not trusted, strnlen_user() should be used.
- * It will return a value greater than its second argument if
- * that limit would be exceeded. This implementation is allowed
- * to access memory beyond the limit, but will not cross a page
- * boundary when doing so.
- */
-
-#include <asm/regdef.h>
-
-
-/* Allow an exception for an insn; exit if we get one.  */
-#define EX(x,y...)                      \
-        99: x,##y;                      \
-        .section __ex_table,"a";        \
-        .long 99b - .;                  \
-        lda v0, $exception-99b(zero);   \
-        .previous
-
-
-        .set noreorder
-        .set noat
-        .text
-
-        .globl __strlen_user
-        .ent __strlen_user
-        .frame sp, 0, ra
-
-        .align 3
-__strlen_user:
-        ldah    a1, 32767(zero) # do not use plain strlen_user() for strings
-                                # that might be almost 2 GB long; you should
-                                # be using strnlen_user() instead
-
-        .globl __strnlen_user
-
-        .align 3
-__strnlen_user:
-        .prologue 0
-
-        EX( ldq_u t0, 0(a0) )   # load first quadword (a0 may be misaligned)
-        lda     t1, -1(zero)
-        insqh   t1, a0, t1
-        andnot  a0, 7, v0
-        or      t1, t0, t0
-        subq    a0, 1, a0       # get our +1 for the return 
-        cmpbge  zero, t0, t1    # t1 <- bitmask: bit i == 1 <==> i-th byte == 0
-        subq    a1, 7, t2
-        subq    a0, v0, t0
-        bne     t1, $found
-
-        addq    t2, t0, t2
-        addq    a1, 1, a1
-
-        .align 3
-$loop:  ble     t2, $limit
-        EX( ldq t0, 8(v0) )
-        subq    t2, 8, t2
-        addq    v0, 8, v0       # addr += 8
-        cmpbge  zero, t0, t1
-        beq     t1, $loop
-
-$found: negq    t1, t2          # clear all but least set bit
-        and     t1, t2, t1
-
-        and     t1, 0xf0, t2    # binary search for that set bit
-        and     t1, 0xcc, t3
-        and     t1, 0xaa, t4
-        cmovne  t2, 4, t2
-        cmovne  t3, 2, t3
-        cmovne  t4, 1, t4
-        addq    t2, t3, t2
-        addq    v0, t4, v0
-        addq    v0, t2, v0
-        nop                     # dual issue next two on ev4 and ev5
-        subq    v0, a0, v0
-$exception:
-        ret
-
-        .align 3                # currently redundant
-$limit:
-        subq    a1, t2, v0
-        ret
-
-        .end __strlen_user
diff --git a/arch/alpha/lib/strncpy_from_user.S b/arch/alpha/lib/strncpy_from_user.S
deleted file mode 100644
index 73ee21160ff7..000000000000
--- a/arch/alpha/lib/strncpy_from_user.S
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
- * arch/alpha/lib/strncpy_from_user.S
- * Contributed by Richard Henderson (rth@tamu.edu)
- *
- * Just like strncpy except in the return value:
- *
- * -EFAULT       if an exception occurs before the terminator is copied.
- * N             if the buffer filled.
- *
- * Otherwise the length of the string is returned.
- */
-
-
-#include <asm/errno.h>
-#include <asm/regdef.h>
-
-
-/* Allow an exception for an insn; exit if we get one.  */
-#define EX(x,y...)                      \
-        99: x,##y;                      \
-        .section __ex_table,"a";        \
-        .long 99b - .;                  \
-        lda $31, $exception-99b($0);    \
-        .previous
-
-
-        .set noat
-        .set noreorder
-        .text
-
-        .globl __strncpy_from_user
-        .ent __strncpy_from_user
-        .frame $30, 0, $26
-        .prologue 0
-
-        .align 3
-$aligned:
-        /* On entry to this basic block:
-           t0 == the first destination word for masking back in
-           t1 == the first source word.  */
-
-        /* Create the 1st output word and detect 0's in the 1st input word.  */
-        lda     t2, -1          # e1    : build a mask against false zero
-        mskqh   t2, a1, t2      # e0    :   detection in the src word
-        mskqh   t1, a1, t3      # e0    :
-        ornot   t1, t2, t2      # .. e1 :
-        mskql   t0, a1, t0      # e0    : assemble the first output word
-        cmpbge  zero, t2, t8    # .. e1 : bits set iff null found
-        or      t0, t3, t0      # e0    :
-        beq     a2, $a_eoc      # .. e1 :
-        bne     t8, $a_eos      # .. e1 :
-
-        /* On entry to this basic block:
-           t0 == a source word not containing a null.  */
-
-$a_loop:
-        stq_u   t0, 0(a0)       # e0    :
-        addq    a0, 8, a0       # .. e1 :
-        EX( ldq_u t0, 0(a1) )   # e0    :
-        addq    a1, 8, a1       # .. e1 :
-        subq    a2, 1, a2       # e0    :
-        cmpbge  zero, t0, t8    # .. e1 (stall)
-        beq     a2, $a_eoc      # e1    :
-        beq     t8, $a_loop     # e1    :
-
-        /* Take care of the final (partial) word store.  At this point
-           the end-of-count bit is set in t8 iff it applies.
-
-           On entry to this basic block we have:
-           t0 == the source word containing the null
-           t8 == the cmpbge mask that found it.  */
-
-$a_eos:
-        negq    t8, t12         # e0    : find low bit set
-        and     t8, t12, t12    # e1 (stall)
-
-        /* For the sake of the cache, don't read a destination word
-           if we're not going to need it.  */
-        and     t12, 0x80, t6   # e0    :
-        bne     t6, 1f          # .. e1 (zdb)
-
-        /* We're doing a partial word store and so need to combine
-           our source and original destination words.  */
-        ldq_u   t1, 0(a0)       # e0    :
-        subq    t12, 1, t6      # .. e1 :
-        or      t12, t6, t8     # e0    :
-        unop                    #
-        zapnot  t0, t8, t0      # e0    : clear src bytes > null
-        zap     t1, t8, t1      # .. e1 : clear dst bytes <= null
-        or      t0, t1, t0      # e1    :
-
-1:      stq_u   t0, 0(a0)
-        br      $finish_up
-
-        /* Add the end-of-count bit to the eos detection bitmask.  */
-$a_eoc:
-        or      t10, t8, t8
-        br      $a_eos
-
-        /*** The Function Entry Point ***/
-        .align 3
-__strncpy_from_user:
-        mov     a0, v0          # save the string start
-        beq     a2, $zerolength
-
-        /* Are source and destination co-aligned?  */
-        xor     a0, a1, t1      # e0    :
-        and     a0, 7, t0       # .. e1 : find dest misalignment
-        and     t1, 7, t1       # e0    :
-        addq    a2, t0, a2      # .. e1 : bias count by dest misalignment
-        subq    a2, 1, a2       # e0    :
-        and     a2, 7, t2       # e1    :
-        srl     a2, 3, a2       # e0    : a2 = loop counter = (count - 1)/8
-        addq    zero, 1, t10    # .. e1 :
-        sll     t10, t2, t10    # e0    : t10 = bitmask of last count byte
-        bne     t1, $unaligned  # .. e1 :
-
-        /* We are co-aligned; take care of a partial first word.  */
-
-        EX( ldq_u t1, 0(a1) )   # e0    : load first src word
-        addq    a1, 8, a1       # .. e1 :
-
-        beq     t0, $aligned    # avoid loading dest word if not needed
-        ldq_u   t0, 0(a0)       # e0    :
-        br      $aligned        # .. e1 :
-
-
-/* The source and destination are not co-aligned.  Align the destination
-   and cope.  We have to be very careful about not reading too much and
-   causing a SEGV.  */
-
-        .align 3
-$u_head:
-        /* We know just enough now to be able to assemble the first
-           full source word.  We can still find a zero at the end of it
-           that prevents us from outputting the whole thing.
-
-           On entry to this basic block:
-           t0 == the first dest word, unmasked
-           t1 == the shifted low bits of the first source word
-           t6 == bytemask that is -1 in dest word bytes */
-
-        EX( ldq_u t2, 8(a1) )   # e0    : load second src word
-        addq    a1, 8, a1       # .. e1 :
-        mskql   t0, a0, t0      # e0    : mask trailing garbage in dst
-        extqh   t2, a1, t4      # e0    :
-        or      t1, t4, t1      # e1    : first aligned src word complete
-        mskqh   t1, a0, t1      # e0    : mask leading garbage in src
-        or      t0, t1, t0      # e0    : first output word complete
-        or      t0, t6, t6      # e1    : mask original data for zero test
-        cmpbge  zero, t6, t8    # e0    :
-        beq     a2, $u_eocfin   # .. e1 :
-        bne     t8, $u_final    # e1    :
-
-        lda     t6, -1                  # e1    : mask out the bits we have
-        mskql   t6, a1, t6              # e0    :   already seen
-        stq_u   t0, 0(a0)               # e0    : store first output word
-        or      t6, t2, t2              # .. e1 :
-        cmpbge  zero, t2, t8            # e0    : find nulls in second partial
-        addq    a0, 8, a0               # .. e1 :
-        subq    a2, 1, a2               # e0    :
-        bne     t8, $u_late_head_exit   # .. e1 :
-
-        /* Finally, we've got all the stupid leading edge cases taken care
-           of and we can set up to enter the main loop.  */
-
-        extql   t2, a1, t1      # e0    : position hi-bits of lo word
-        EX( ldq_u t2, 8(a1) )   # .. e1 : read next high-order source word
-        addq    a1, 8, a1       # e0    :
-        cmpbge  zero, t2, t8    # e1 (stall)
-        beq     a2, $u_eoc      # e1    :
-        bne     t8, $u_eos      # e1    :
-
-        /* Unaligned copy main loop.  In order to avoid reading too much,
-           the loop is structured to detect zeros in aligned source words.
-           This has, unfortunately, effectively pulled half of a loop
-           iteration out into the head and half into the tail, but it does
-           prevent nastiness from accumulating in the very thing we want
-           to run as fast as possible.
-
-           On entry to this basic block:
-           t1 == the shifted high-order bits from the previous source word
-           t2 == the unshifted current source word
-
-           We further know that t2 does not contain a null terminator.  */
-
-        .align 3
-$u_loop:
-        extqh   t2, a1, t0      # e0    : extract high bits for current word
-        addq    a1, 8, a1       # .. e1 :
-        extql   t2, a1, t3      # e0    : extract low bits for next time
-        addq    a0, 8, a0       # .. e1 :
-        or      t0, t1, t0      # e0    : current dst word now complete
-        EX( ldq_u t2, 0(a1) )   # .. e1 : load high word for next time
-        stq_u   t0, -8(a0)      # e0    : save the current word
-        mov     t3, t1          # .. e1 :
-        subq    a2, 1, a2       # e0    :
-        cmpbge  zero, t2, t8    # .. e1 : test new word for eos
-        beq     a2, $u_eoc      # e1    :
-        beq     t8, $u_loop     # e1    :
-
-        /* We've found a zero somewhere in the source word we just read.
-           If it resides in the lower half, we have one (probably partial)
-           word to write out, and if it resides in the upper half, we
-           have one full and one partial word left to write out.
-
-           On entry to this basic block:
-           t1 == the shifted high-order bits from the previous source word
-           t2 == the unshifted current source word.  */
-$u_eos:
-        extqh   t2, a1, t0      # e0    :
-        or      t0, t1, t0      # e1    : first (partial) source word complete
-
-        cmpbge  zero, t0, t8    # e0    : is the null in this first bit?
-        bne     t8, $u_final    # .. e1 (zdb)
-
-        stq_u   t0, 0(a0)       # e0    : the null was in the high-order bits
-        addq    a0, 8, a0       # .. e1 :
-        subq    a2, 1, a2       # e1    :
-
-$u_late_head_exit:
-        extql   t2, a1, t0      # .. e0 :
-        cmpbge  zero, t0, t8    # e0    :
-        or      t8, t10, t6     # e1    :
-        cmoveq  a2, t6, t8      # e0    :
-        nop                     # .. e1 :
-
-        /* Take care of a final (probably partial) result word.
-           On entry to this basic block:
-           t0 == assembled source word
-           t8 == cmpbge mask that found the null.  */
-$u_final:
-        negq    t8, t6          # e0    : isolate low bit set
-        and     t6, t8, t12     # e1    :
-
-        and     t12, 0x80, t6   # e0    : avoid dest word load if we can
-        bne     t6, 1f          # .. e1 (zdb)
-
-        ldq_u   t1, 0(a0)       # e0    :
-        subq    t12, 1, t6      # .. e1 :
-        or      t6, t12, t8     # e0    :
-        zapnot  t0, t8, t0      # .. e1 : kill source bytes > null
-        zap     t1, t8, t1      # e0    : kill dest bytes <= null
-        or      t0, t1, t0      # e1    :
-
-1:      stq_u   t0, 0(a0)       # e0    :
-        br      $finish_up
-
-$u_eoc:                         # end-of-count
-        extqh   t2, a1, t0
-        or      t0, t1, t0
-        cmpbge  zero, t0, t8
-
-$u_eocfin:                      # end-of-count, final word
-        or      t10, t8, t8
-        br      $u_final
-
-        /* Unaligned copy entry point.  */
-        .align 3
-$unaligned:
-
-        EX( ldq_u t1, 0(a1) )   # e0    : load first source word
-
-        and     a0, 7, t4       # .. e1 : find dest misalignment
-        and     a1, 7, t5       # e0    : find src misalignment
-
-        /* Conditionally load the first destination word and a bytemask
-           with 0xff indicating that the destination byte is sacrosanct.  */
-
-        mov     zero, t0        # .. e1 :
-        mov     zero, t6        # e0    :
-        beq     t4, 1f          # .. e1 :
-        ldq_u   t0, 0(a0)       # e0    :
-        lda     t6, -1          # .. e1 :
-        mskql   t6, a0, t6      # e0    :
-1:
-        subq    a1, t4, a1      # .. e1 : sub dest misalignment from src addr
-
-        /* If source misalignment is larger than dest misalignment, we need
-           extra startup checks to avoid SEGV.  */
-
-        cmplt   t4, t5, t12     # e1    :
-        extql   t1, a1, t1      # .. e0 : shift src into place
-        lda     t2, -1          # e0    : for creating masks later
-        beq     t12, $u_head    # e1    :
-
-        mskqh   t2, t5, t2      # e0    : begin src byte validity mask
-        cmpbge  zero, t1, t8    # .. e1 : is there a zero?
-        extql   t2, a1, t2      # e0    :
-        or      t8, t10, t5     # .. e1 : test for end-of-count too
-        cmpbge  zero, t2, t3    # e0    :
-        cmoveq  a2, t5, t8      # .. e1 :
-        andnot  t8, t3, t8      # e0    :
-        beq     t8, $u_head     # .. e1 (zdb)
-
-        /* At this point we've found a zero in the first partial word of
-           the source.  We need to isolate the valid source data and mask
-           it into the original destination data.  (Incidentally, we know
-           that we'll need at least one byte of that original dest word.) */
-
-        ldq_u   t0, 0(a0)       # e0    :
-        negq    t8, t6          # .. e1 : build bitmask of bytes <= zero
-        mskqh   t1, t4, t1      # e0    :
-        and     t6, t8, t12     # .. e1 :
-        subq    t12, 1, t6      # e0    :
-        or      t6, t12, t8     # e1    :
-
-        zapnot  t2, t8, t2      # e0    : prepare source word; mirror changes
-        zapnot  t1, t8, t1      # .. e1 : to source validity mask
-
-        andnot  t0, t2, t0      # e0    : zero place for source to reside
-        or      t0, t1, t0      # e1    : and put it there
-        stq_u   t0, 0(a0)       # e0    :
-
-$finish_up:
-        zapnot  t0, t12, t4     # was last byte written null?
-        cmovne  t4, 1, t4
-
-        and     t12, 0xf0, t3   # binary search for the address of the
-        and     t12, 0xcc, t2   # last byte written
-        and     t12, 0xaa, t1
-        bic     a0, 7, t0
-        cmovne  t3, 4, t3
-        cmovne  t2, 2, t2
-        cmovne  t1, 1, t1
-        addq    t0, t3, t0
-        addq    t1, t2, t1
-        addq    t0, t1, t0
-        addq    t0, t4, t0      # add one if we filled the buffer
-
-        subq    t0, v0, v0      # find string length
-        ret
-
-$zerolength:
-        clr     v0
-$exception:
-        ret
-
-        .end __strncpy_from_user
diff --git a/arch/alpha/mm/fault.c b/arch/alpha/mm/fault.c
index 5eecab1a84ef..0c4132dd3507 100644
--- a/arch/alpha/mm/fault.c
+++ b/arch/alpha/mm/fault.c
@@ -89,6 +89,8 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
         const struct exception_table_entry *fixup;
         int fault, si_code = SEGV_MAPERR;
         siginfo_t info;
+        unsigned int flags = (FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE |
+                              (cause > 0 ? FAULT_FLAG_WRITE : 0));
 
         /* As of EV6, a load into $31/$f31 is a prefetch, and never faults
            (or is suppressed by the PALcode).  Support that for older CPUs
@@ -114,6 +116,7 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
                 goto vmalloc_fault;
 #endif
 
+retry:
         down_read(&mm->mmap_sem);
         vma = find_vma(mm, address);
         if (!vma)
@@ -144,8 +147,11 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
         /* If for any reason at all we couldn't handle the fault,
            make sure we exit gracefully rather than endlessly redo
            the fault.  */
-        fault = handle_mm_fault(mm, vma, address, cause > 0 ? FAULT_FLAG_WRITE : 0);
-        up_read(&mm->mmap_sem);
+        fault = handle_mm_fault(mm, vma, address, flags);
+
+        if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
+                return;
+
         if (unlikely(fault & VM_FAULT_ERROR)) {
                 if (fault & VM_FAULT_OOM)
                         goto out_of_memory;
@@ -153,10 +159,26 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
                         goto do_sigbus;
                 BUG();
         }
-        if (fault & VM_FAULT_MAJOR)
-                current->maj_flt++;
-        else
-                current->min_flt++;
+
+        if (flags & FAULT_FLAG_ALLOW_RETRY) {
+                if (fault & VM_FAULT_MAJOR)
+                        current->maj_flt++;
+                else
+                        current->min_flt++;
+                if (fault & VM_FAULT_RETRY) {
+                        flags &= ~FAULT_FLAG_ALLOW_RETRY;
+
+                         /* No need to up_read(&mm->mmap_sem) as we would
+                         * have already released it in __lock_page_or_retry
+                         * in mm/filemap.c.
+                         */
+
+                        goto retry;
+                }
+        }
+
+        up_read(&mm->mmap_sem);
+
         return;
 
         /* Something tried to access memory that isn't in our memory map.
@@ -186,12 +208,14 @@ do_page_fault(unsigned long address, unsigned long mmcsr,
         /* We ran out of memory, or some other thing happened to us that
            made us unable to handle the page fault gracefully.  */
  out_of_memory:
+        up_read(&mm->mmap_sem);
         if (!user_mode(regs))
                 goto no_context;
         pagefault_out_of_memory();
         return;
 
  do_sigbus:
+        up_read(&mm->mmap_sem);
         /* Send a sigbus, regardless of whether we were in kernel
            or user mode.  */
         info.si_signo = SIGBUS;
diff --git a/arch/alpha/oprofile/common.c b/arch/alpha/oprofile/common.c
index a0a5d27aa215..b8ce18f485d3 100644
--- a/arch/alpha/oprofile/common.c
+++ b/arch/alpha/oprofile/common.c
@@ -12,6 +12,7 @@
 #include <linux/smp.h>
 #include <linux/errno.h>
 #include <asm/ptrace.h>
+#include <asm/special_insns.h>
 
 #include "op_impl.h"
 
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index e91c7cdc6fe5..c5f9ae5dbd1a 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -38,7 +38,6 @@ config ARM
         select HARDIRQS_SW_RESEND
         select GENERIC_IRQ_PROBE
         select GENERIC_IRQ_SHOW
-        select GENERIC_IRQ_PROBE
         select ARCH_WANT_IPC_PARSE_VERSION
         select HARDIRQS_SW_RESEND
         select CPU_PM if (SUSPEND || CPU_IDLE)
@@ -126,11 +125,6 @@ config TRACE_IRQFLAGS_SUPPORT
         bool
         default y
 
-config GENERIC_LOCKBREAK
-        bool
-        default y
-        depends on SMP && PREEMPT
-
 config RWSEM_GENERIC_SPINLOCK
         bool
         default y
@@ -2150,6 +2144,7 @@ source "drivers/cpufreq/Kconfig"
 config CPU_FREQ_IMX
         tristate "CPUfreq driver for i.MX CPUs"
         depends on ARCH_MXC && CPU_FREQ
+        select CPU_FREQ_TABLE
         help
           This enables the CPUfreq driver for i.MX CPUs.
 
diff --git a/arch/arm/boot/dts/am33xx.dtsi b/arch/arm/boot/dts/am33xx.dtsi
index 59509c48d7e5..bd0cff3f808c 100644
--- a/arch/arm/boot/dts/am33xx.dtsi
+++ b/arch/arm/boot/dts/am33xx.dtsi
@@ -154,5 +154,10 @@
                         #size-cells = <0>;
                         ti,hwmods = "i2c3";
                 };
+
+                wdt2: wdt@44e35000 {
+                        compatible = "ti,omap3-wdt";
+                        ti,hwmods = "wd_timer2";
+                };
         };
 };
diff --git a/arch/arm/boot/dts/imx51-babbage.dts b/arch/arm/boot/dts/imx51-babbage.dts
index cd86177a3ea2..59d9789e5508 100644
--- a/arch/arm/boot/dts/imx51-babbage.dts
+++ b/arch/arm/boot/dts/imx51-babbage.dts
@@ -25,8 +25,8 @@
                 aips@70000000 { /* aips-1 */
                         spba@70000000 {
                                 esdhc@70004000 { /* ESDHC1 */
-                                        fsl,cd-internal;
-                                        fsl,wp-internal;
+                                        fsl,cd-controller;
+                                        fsl,wp-controller;
                                         status = "okay";
                                 };
 
diff --git a/arch/arm/boot/dts/kirkwood-iconnect.dts b/arch/arm/boot/dts/kirkwood-iconnect.dts
index 52d947045106..f8ca6fa88192 100644
--- a/arch/arm/boot/dts/kirkwood-iconnect.dts
+++ b/arch/arm/boot/dts/kirkwood-iconnect.dts
@@ -41,9 +41,13 @@
                 };
                 power-blue {
                         label = "power:blue";
-                        gpios = <&gpio1 11 0>;
+                        gpios = <&gpio1 10 0>;
                         linux,default-trigger = "timer";
                 };
+                power-red {
+                        label = "power:red";
+                        gpios = <&gpio1 11 0>;
+                };
                 usb1 {
                         label = "usb1:blue";
                         gpios = <&gpio1 12 0>;
diff --git a/arch/arm/boot/dts/twl6030.dtsi b/arch/arm/boot/dts/twl6030.dtsi
index 3b2f3510d7eb..d351b27d7213 100644
--- a/arch/arm/boot/dts/twl6030.dtsi
+++ b/arch/arm/boot/dts/twl6030.dtsi
@@ -66,6 +66,7 @@
 
         vcxio: regulator@8 {
                 compatible = "ti,twl6030-vcxio";
+                regulator-always-on;
         };
 
         vusb: regulator@9 {
@@ -74,10 +75,12 @@
 
         v1v8: regulator@10 {
                 compatible = "ti,twl6030-v1v8";
+                regulator-always-on;
         };
 
         v2v1: regulator@11 {
                 compatible = "ti,twl6030-v2v1";
+                regulator-always-on;
         };
 
         clk32kg: regulator@12 {
diff --git a/arch/arm/configs/u8500_defconfig b/arch/arm/configs/u8500_defconfig
index 2d4f661d1cf6..da6845493caa 100644
--- a/arch/arm/configs/u8500_defconfig
+++ b/arch/arm/configs/u8500_defconfig
@@ -86,6 +86,7 @@ CONFIG_NEW_LEDS=y
 CONFIG_LEDS_CLASS=y
 CONFIG_LEDS_LM3530=y
 CONFIG_LEDS_LP5521=y
+CONFIG_LEDS_GPIO=y
 CONFIG_RTC_CLASS=y
 CONFIG_RTC_DRV_AB8500=y
 CONFIG_RTC_DRV_PL031=y
diff --git a/arch/arm/include/asm/pgtable.h b/arch/arm/include/asm/pgtable.h
index f66626d71e7d..41dc31f834c3 100644
--- a/arch/arm/include/asm/pgtable.h
+++ b/arch/arm/include/asm/pgtable.h
@@ -195,6 +195,18 @@ static inline pte_t *pmd_page_vaddr(pmd_t pmd)
 
 #define pte_clear(mm,addr,ptep) set_pte_ext(ptep, __pte(0), 0)
 
+#define pte_none(pte)           (!pte_val(pte))
+#define pte_present(pte)        (pte_val(pte) & L_PTE_PRESENT)
+#define pte_write(pte)          (!(pte_val(pte) & L_PTE_RDONLY))
+#define pte_dirty(pte)          (pte_val(pte) & L_PTE_DIRTY)
+#define pte_young(pte)          (pte_val(pte) & L_PTE_YOUNG)
+#define pte_exec(pte)           (!(pte_val(pte) & L_PTE_XN))
+#define pte_special(pte)        (0)
+
+#define pte_present_user(pte) \
+        ((pte_val(pte) & (L_PTE_PRESENT | L_PTE_USER)) == \
+         (L_PTE_PRESENT | L_PTE_USER))
+
 #if __LINUX_ARM_ARCH__ < 6
 static inline void __sync_icache_dcache(pte_t pteval)
 {
@@ -206,25 +218,15 @@ extern void __sync_icache_dcache(pte_t pteval);
 static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,
                               pte_t *ptep, pte_t pteval)
 {
-        if (addr >= TASK_SIZE)
-                set_pte_ext(ptep, pteval, 0);
-        else {
+        unsigned long ext = 0;
+
+        if (addr < TASK_SIZE && pte_present_user(pteval)) {
                 __sync_icache_dcache(pteval);
-                set_pte_ext(ptep, pteval, PTE_EXT_NG);
+                ext |= PTE_EXT_NG;
         }
-}
 
-#define pte_none(pte)           (!pte_val(pte))
-#define pte_present(pte)        (pte_val(pte) & L_PTE_PRESENT)
-#define pte_write(pte)          (!(pte_val(pte) & L_PTE_RDONLY))
-#define pte_dirty(pte)          (pte_val(pte) & L_PTE_DIRTY)
-#define pte_young(pte)          (pte_val(pte) & L_PTE_YOUNG)
-#define pte_exec(pte)           (!(pte_val(pte) & L_PTE_XN))
-#define pte_special(pte)        (0)
-
-#define pte_present_user(pte) \
-        ((pte_val(pte) & (L_PTE_PRESENT | L_PTE_USER)) == \
-         (L_PTE_PRESENT | L_PTE_USER))
+        set_pte_ext(ptep, pteval, ext);
+}
 
 #define PTE_BIT_FUNC(fn,op) \
 static inline pte_t pte_##fn(pte_t pte) { pte_val(pte) op; return pte; }
@@ -251,13 +253,13 @@ static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
  *
  *   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
  *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
- *   <--------------- offset --------------------> <- type --> 0 0 0
+ *   <--------------- offset ----------------------> < type -> 0 0 0
  *
- * This gives us up to 63 swap files and 32GB per swap file.  Note that
+ * This gives us up to 31 swap files and 64GB per swap file.  Note that
  * the offset field is always non-zero.
  */
 #define __SWP_TYPE_SHIFT        3
-#define __SWP_TYPE_BITS         6
+#define __SWP_TYPE_BITS         5
 #define __SWP_TYPE_MASK         ((1 << __SWP_TYPE_BITS) - 1)
 #define __SWP_OFFSET_SHIFT      (__SWP_TYPE_BITS + __SWP_TYPE_SHIFT)
 
diff --git a/arch/arm/include/asm/sched_clock.h b/arch/arm/include/asm/sched_clock.h
index e3f757263438..05b8e82ec9f5 100644
--- a/arch/arm/include/asm/sched_clock.h
+++ b/arch/arm/include/asm/sched_clock.h
@@ -10,5 +10,7 @@
 
 extern void sched_clock_postinit(void);
 extern void setup_sched_clock(u32 (*read)(void), int bits, unsigned long rate);
+extern void setup_sched_clock_needs_suspend(u32 (*read)(void), int bits,
+                unsigned long rate);
 
 #endif
diff --git a/arch/arm/kernel/sched_clock.c b/arch/arm/kernel/sched_clock.c
index 27d186abbc06..f4515393248d 100644
--- a/arch/arm/kernel/sched_clock.c
+++ b/arch/arm/kernel/sched_clock.c
@@ -21,6 +21,8 @@ struct clock_data {
         u32 epoch_cyc_copy;
         u32 mult;
         u32 shift;
+        bool suspended;
+        bool needs_suspend;
 };
 
 static void sched_clock_poll(unsigned long wrap_ticks);
@@ -49,6 +51,9 @@ static unsigned long long cyc_to_sched_clock(u32 cyc, u32 mask)
         u64 epoch_ns;
         u32 epoch_cyc;
 
+        if (cd.suspended)
+                return cd.epoch_ns;
+
         /*
          * Load the epoch_cyc and epoch_ns atomically.  We do this by
          * ensuring that we always write epoch_cyc, epoch_ns and
@@ -98,6 +103,13 @@ static void sched_clock_poll(unsigned long wrap_ticks)
         update_sched_clock();
 }
 
+void __init setup_sched_clock_needs_suspend(u32 (*read)(void), int bits,
+                unsigned long rate)
+{
+        setup_sched_clock(read, bits, rate);
+        cd.needs_suspend = true;
+}
+
 void __init setup_sched_clock(u32 (*read)(void), int bits, unsigned long rate)
 {
         unsigned long r, w;
@@ -169,11 +181,23 @@ void __init sched_clock_postinit(void)
 static int sched_clock_suspend(void)
 {
         sched_clock_poll(sched_clock_timer.data);
+        if (cd.needs_suspend)
+                cd.suspended = true;
         return 0;
 }
 
+static void sched_clock_resume(void)
+{
+        if (cd.needs_suspend) {
+                cd.epoch_cyc = read_sched_clock();
+                cd.epoch_cyc_copy = cd.epoch_cyc;
+                cd.suspended = false;
+        }
+}
+
 static struct syscore_ops sched_clock_ops = {
         .suspend = sched_clock_suspend,
+        .resume = sched_clock_resume,
 };
 
 static int __init sched_clock_syscore_init(void)
diff --git a/arch/arm/kernel/topology.c b/arch/arm/kernel/topology.c
index 198b08456e90..26c12c6440fc 100644
--- a/arch/arm/kernel/topology.c
+++ b/arch/arm/kernel/topology.c
@@ -321,7 +321,7 @@ void store_cpu_topology(unsigned int cpuid)
  * init_cpu_topology is called at boot when only one cpu is running
  * which prevent simultaneous write access to cpu_topology array
  */
-void init_cpu_topology(void)
+void __init init_cpu_topology(void)
 {
         unsigned int cpu;
 
diff --git a/arch/arm/lib/Makefile b/arch/arm/lib/Makefile
index 2473fd1fd51c..af72969820b4 100644
--- a/arch/arm/lib/Makefile
+++ b/arch/arm/lib/Makefile
@@ -16,13 +16,30 @@ lib-y		:= backtrace.o changebit.o csumipv6.o csumpartial.o   \
                    call_with_stack.o
 
 mmu-y   := clear_user.o copy_page.o getuser.o putuser.o
-mmu-y   += copy_from_user.o copy_to_user.o
+
+# the code in uaccess.S is not preemption safe and
+# probably faster on ARMv3 only
+ifeq ($(CONFIG_PREEMPT),y)
+  mmu-y += copy_from_user.o copy_to_user.o
+else
+ifneq ($(CONFIG_CPU_32v3),y)
+  mmu-y += copy_from_user.o copy_to_user.o
+else
+  mmu-y += uaccess.o
+endif
+endif
 
 # using lib_ here won't override already available weak symbols
 obj-$(CONFIG_UACCESS_WITH_MEMCPY) += uaccess_with_memcpy.o
 
-lib-$(CONFIG_MMU)               += $(mmu-y)
-lib-y                           += io-readsw-armv4.o io-writesw-armv4.o
+lib-$(CONFIG_MMU) += $(mmu-y)
+
+ifeq ($(CONFIG_CPU_32v3),y)
+  lib-y += io-readsw-armv3.o io-writesw-armv3.o
+else
+  lib-y += io-readsw-armv4.o io-writesw-armv4.o
+endif
+
 lib-$(CONFIG_ARCH_RPC)          += ecard.o io-acorn.o floppydma.o
 lib-$(CONFIG_ARCH_SHARK)        += io-shark.o
 
diff --git a/arch/arm/lib/io-readsw-armv3.S b/arch/arm/lib/io-readsw-armv3.S
new file mode 100644
index 000000000000..88487c8c4f23
--- /dev/null
+++ b/arch/arm/lib/io-readsw-armv3.S
@@ -0,0 +1,106 @@
+/*
+ *  linux/arch/arm/lib/io-readsw-armv3.S
+ *
+ *  Copyright (C) 1995-2000 Russell King
+ *
+ * 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.
+ */
+#include <linux/linkage.h>
+#include <asm/assembler.h>
+
+.Linsw_bad_alignment:
+                adr     r0, .Linsw_bad_align_msg
+                mov     r2, lr
+                b       panic
+.Linsw_bad_align_msg:
+                .asciz  "insw: bad buffer alignment (0x%p, lr=0x%08lX)\n"
+                .align
+
+.Linsw_align:   tst     r1, #1
+                bne     .Linsw_bad_alignment
+
+                ldr     r3, [r0]
+                strb    r3, [r1], #1
+                mov     r3, r3, lsr #8
+                strb    r3, [r1], #1
+
+                subs    r2, r2, #1
+                moveq   pc, lr
+
+ENTRY(__raw_readsw)
+                teq     r2, #0          @ do we have to check for the zero len?
+                moveq   pc, lr
+                tst     r1, #3
+                bne     .Linsw_align
+
+.Linsw_aligned: mov     ip, #0xff
+                orr     ip, ip, ip, lsl #8
+                stmfd   sp!, {r4, r5, r6, lr}
+
+                subs    r2, r2, #8
+                bmi     .Lno_insw_8
+
+.Linsw_8_lp:    ldr     r3, [r0]
+                and     r3, r3, ip
+                ldr     r4, [r0]
+                orr     r3, r3, r4, lsl #16
+
+                ldr     r4, [r0]
+                and     r4, r4, ip
+                ldr     r5, [r0]
+                orr     r4, r4, r5, lsl #16
+
+                ldr     r5, [r0]
+                and     r5, r5, ip
+                ldr     r6, [r0]
+                orr     r5, r5, r6, lsl #16
+
+                ldr     r6, [r0]
+                and     r6, r6, ip
+                ldr     lr, [r0]
+                orr     r6, r6, lr, lsl #16
+
+                stmia   r1!, {r3 - r6}
+
+                subs    r2, r2, #8
+                bpl     .Linsw_8_lp
+
+                tst     r2, #7
+                ldmeqfd sp!, {r4, r5, r6, pc}
+
+.Lno_insw_8:    tst     r2, #4
+                beq     .Lno_insw_4
+
+                ldr     r3, [r0]
+                and     r3, r3, ip
+                ldr     r4, [r0]
+                orr     r3, r3, r4, lsl #16
+
+                ldr     r4, [r0]
+                and     r4, r4, ip
+                ldr     r5, [r0]
+                orr     r4, r4, r5, lsl #16
+
+                stmia   r1!, {r3, r4}
+
+.Lno_insw_4:    tst     r2, #2
+                beq     .Lno_insw_2
+
+                ldr     r3, [r0]
+                and     r3, r3, ip
+                ldr     r4, [r0]
+                orr     r3, r3, r4, lsl #16
+
+                str     r3, [r1], #4
+
+.Lno_insw_2:    tst     r2, #1
+                ldrne   r3, [r0]
+                strneb  r3, [r1], #1
+                movne   r3, r3, lsr #8
+                strneb  r3, [r1]
+
+                ldmfd   sp!, {r4, r5, r6, pc}
+
+
diff --git a/arch/arm/lib/io-writesw-armv3.S b/arch/arm/lib/io-writesw-armv3.S
new file mode 100644
index 000000000000..49b800419e32
--- /dev/null
+++ b/arch/arm/lib/io-writesw-armv3.S
@@ -0,0 +1,126 @@
+/*
+ *  linux/arch/arm/lib/io-writesw-armv3.S
+ *
+ *  Copyright (C) 1995-2000 Russell King
+ *
+ * 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.
+ */
+#include <linux/linkage.h>
+#include <asm/assembler.h>
+
+.Loutsw_bad_alignment:
+                adr     r0, .Loutsw_bad_align_msg
+                mov     r2, lr
+                b       panic
+.Loutsw_bad_align_msg:
+                .asciz  "outsw: bad buffer alignment (0x%p, lr=0x%08lX)\n"
+                .align
+
+.Loutsw_align:  tst     r1, #1
+                bne     .Loutsw_bad_alignment
+
+                add     r1, r1, #2
+
+                ldr     r3, [r1, #-4]
+                mov     r3, r3, lsr #16
+                orr     r3, r3, r3, lsl #16
+                str     r3, [r0]
+                subs    r2, r2, #1
+                moveq   pc, lr
+
+ENTRY(__raw_writesw)
+                teq     r2, #0          @ do we have to check for the zero len?
+                moveq   pc, lr
+                tst     r1, #3
+                bne     .Loutsw_align
+
+                stmfd   sp!, {r4, r5, r6, lr}
+
+                subs    r2, r2, #8
+                bmi     .Lno_outsw_8
+
+.Loutsw_8_lp:   ldmia   r1!, {r3, r4, r5, r6}
+
+                mov     ip, r3, lsl #16
+                orr     ip, ip, ip, lsr #16
+                str     ip, [r0]
+
+                mov     ip, r3, lsr #16
+                orr     ip, ip, ip, lsl #16
+                str     ip, [r0]
+
+                mov     ip, r4, lsl #16
+                orr     ip, ip, ip, lsr #16
+                str     ip, [r0]
+
+                mov     ip, r4, lsr #16
+                orr     ip, ip, ip, lsl #16
+                str     ip, [r0]
+
+                mov     ip, r5, lsl #16
+                orr     ip, ip, ip, lsr #16
+                str     ip, [r0]
+
+                mov     ip, r5, lsr #16
+                orr     ip, ip, ip, lsl #16
+                str     ip, [r0]
+
+                mov     ip, r6, lsl #16
+                orr     ip, ip, ip, lsr #16
+                str     ip, [r0]
+
+                mov     ip, r6, lsr #16
+                orr     ip, ip, ip, lsl #16
+                str     ip, [r0]
+
+                subs    r2, r2, #8
+                bpl     .Loutsw_8_lp
+
+                tst     r2, #7
+                ldmeqfd sp!, {r4, r5, r6, pc}
+
+.Lno_outsw_8:   tst     r2, #4
+                beq     .Lno_outsw_4
+
+                ldmia   r1!, {r3, r4}
+
+                mov     ip, r3, lsl #16
+                orr     ip, ip, ip, lsr #16
+                str     ip, [r0]
+
+                mov     ip, r3, lsr #16
+                orr     ip, ip, ip, lsl #16
+                str     ip, [r0]
+
+                mov     ip, r4, lsl #16
+                orr     ip, ip, ip, lsr #16
+                str     ip, [r0]
+
+                mov     ip, r4, lsr #16
+                orr     ip, ip, ip, lsl #16
+                str     ip, [r0]
+
+.Lno_outsw_4:   tst     r2, #2
+                beq     .Lno_outsw_2
+
+                ldr     r3, [r1], #4
+
+                mov     ip, r3, lsl #16
+                orr     ip, ip, ip, lsr #16
+                str     ip, [r0]
+
+                mov     ip, r3, lsr #16
+                orr     ip, ip, ip, lsl #16
+                str     ip, [r0]
+
+.Lno_outsw_2:   tst     r2, #1
+
+                ldrne   r3, [r1]
+
+                movne   ip, r3, lsl #16
+                orrne   ip, ip, ip, lsr #16
+                strne   ip, [r0]
+
+                ldmfd   sp!, {r4, r5, r6, pc}
diff --git a/arch/arm/lib/uaccess.S b/arch/arm/lib/uaccess.S
new file mode 100644
index 000000000000..5c908b1cb8ed
--- /dev/null
+++ b/arch/arm/lib/uaccess.S
@@ -0,0 +1,564 @@
+/*
+ *  linux/arch/arm/lib/uaccess.S
+ *
+ *  Copyright (C) 1995, 1996,1997,1998 Russell King
+ *
+ * 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.
+ *
+ *  Routines to block copy data to/from user memory
+ *   These are highly optimised both for the 4k page size
+ *   and for various alignments.
+ */
+#include <linux/linkage.h>
+#include <asm/assembler.h>
+#include <asm/errno.h>
+#include <asm/domain.h>
+
+                .text
+
+#define PAGE_SHIFT 12
+
+/* Prototype: int __copy_to_user(void *to, const char *from, size_t n)
+ * Purpose  : copy a block to user memory from kernel memory
+ * Params   : to   - user memory
+ *          : from - kernel memory
+ *          : n    - number of bytes to copy
+ * Returns  : Number of bytes NOT copied.
+ */
+
+.Lc2u_dest_not_aligned:
+                rsb     ip, ip, #4
+                cmp     ip, #2
+                ldrb    r3, [r1], #1
+USER(   TUSER(  strb)   r3, [r0], #1)                   @ May fault
+                ldrgeb  r3, [r1], #1
+USER(   TUSER(  strgeb) r3, [r0], #1)                   @ May fault
+                ldrgtb  r3, [r1], #1
+USER(   TUSER(  strgtb) r3, [r0], #1)                   @ May fault
+                sub     r2, r2, ip
+                b       .Lc2u_dest_aligned
+
+ENTRY(__copy_to_user)
+                stmfd   sp!, {r2, r4 - r7, lr}
+                cmp     r2, #4
+                blt     .Lc2u_not_enough
+                ands    ip, r0, #3
+                bne     .Lc2u_dest_not_aligned
+.Lc2u_dest_aligned:
+
+                ands    ip, r1, #3
+                bne     .Lc2u_src_not_aligned
+/*
+ * Seeing as there has to be at least 8 bytes to copy, we can
+ * copy one word, and force a user-mode page fault...
+ */
+
+.Lc2u_0fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lc2u_0nowords
+                ldr     r3, [r1], #4
+USER(   TUSER(  str)    r3, [r0], #4)                   @ May fault
+                mov     ip, r0, lsl #32 - PAGE_SHIFT    @ On each page, use a ld/st??t instruction
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lc2u_0fupi
+/*
+ * ip = max no. of bytes to copy before needing another "strt" insn
+ */
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #32
+                blt     .Lc2u_0rem8lp
+
+.Lc2u_0cpy8lp:  ldmia   r1!, {r3 - r6}
+                stmia   r0!, {r3 - r6}                  @ Shouldnt fault
+                ldmia   r1!, {r3 - r6}
+                subs    ip, ip, #32
+                stmia   r0!, {r3 - r6}                  @ Shouldnt fault
+                bpl     .Lc2u_0cpy8lp
+
+.Lc2u_0rem8lp:  cmn     ip, #16
+                ldmgeia r1!, {r3 - r6}
+                stmgeia r0!, {r3 - r6}                  @ Shouldnt fault
+                tst     ip, #8
+                ldmneia r1!, {r3 - r4}
+                stmneia r0!, {r3 - r4}                  @ Shouldnt fault
+                tst     ip, #4
+                ldrne   r3, [r1], #4
+        TUSER(  strne) r3, [r0], #4                     @ Shouldnt fault
+                ands    ip, ip, #3
+                beq     .Lc2u_0fupi
+.Lc2u_0nowords: teq     ip, #0
+                beq     .Lc2u_finished
+.Lc2u_nowords:  cmp     ip, #2
+                ldrb    r3, [r1], #1
+USER(   TUSER(  strb)   r3, [r0], #1)                   @ May fault
+                ldrgeb  r3, [r1], #1
+USER(   TUSER(  strgeb) r3, [r0], #1)                   @ May fault
+                ldrgtb  r3, [r1], #1
+USER(   TUSER(  strgtb) r3, [r0], #1)                   @ May fault
+                b       .Lc2u_finished
+
+.Lc2u_not_enough:
+                movs    ip, r2
+                bne     .Lc2u_nowords
+.Lc2u_finished: mov     r0, #0
+                ldmfd   sp!, {r2, r4 - r7, pc}
+
+.Lc2u_src_not_aligned:
+                bic     r1, r1, #3
+                ldr     r7, [r1], #4
+                cmp     ip, #2
+                bgt     .Lc2u_3fupi
+                beq     .Lc2u_2fupi
+.Lc2u_1fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lc2u_1nowords
+                mov     r3, r7, pull #8
+                ldr     r7, [r1], #4
+                orr     r3, r3, r7, push #24
+USER(   TUSER(  str)    r3, [r0], #4)                   @ May fault
+                mov     ip, r0, lsl #32 - PAGE_SHIFT
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lc2u_1fupi
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #16
+                blt     .Lc2u_1rem8lp
+
+.Lc2u_1cpy8lp:  mov     r3, r7, pull #8
+                ldmia   r1!, {r4 - r7}
+                subs    ip, ip, #16
+                orr     r3, r3, r4, push #24
+                mov     r4, r4, pull #8
+                orr     r4, r4, r5, push #24
+                mov     r5, r5, pull #8
+                orr     r5, r5, r6, push #24
+                mov     r6, r6, pull #8
+                orr     r6, r6, r7, push #24
+                stmia   r0!, {r3 - r6}                  @ Shouldnt fault
+                bpl     .Lc2u_1cpy8lp
+
+.Lc2u_1rem8lp:  tst     ip, #8
+                movne   r3, r7, pull #8
+                ldmneia r1!, {r4, r7}
+                orrne   r3, r3, r4, push #24
+                movne   r4, r4, pull #8
+                orrne   r4, r4, r7, push #24
+                stmneia r0!, {r3 - r4}                  @ Shouldnt fault
+                tst     ip, #4
+                movne   r3, r7, pull #8
+                ldrne   r7, [r1], #4
+                orrne   r3, r3, r7, push #24
+        TUSER(  strne) r3, [r0], #4                     @ Shouldnt fault
+                ands    ip, ip, #3
+                beq     .Lc2u_1fupi
+.Lc2u_1nowords: mov     r3, r7, get_byte_1
+                teq     ip, #0
+                beq     .Lc2u_finished
+                cmp     ip, #2
+USER(   TUSER(  strb)   r3, [r0], #1)                   @ May fault
+                movge   r3, r7, get_byte_2
+USER(   TUSER(  strgeb) r3, [r0], #1)                   @ May fault
+                movgt   r3, r7, get_byte_3
+USER(   TUSER(  strgtb) r3, [r0], #1)                   @ May fault
+                b       .Lc2u_finished
+
+.Lc2u_2fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lc2u_2nowords
+                mov     r3, r7, pull #16
+                ldr     r7, [r1], #4
+                orr     r3, r3, r7, push #16
+USER(   TUSER(  str)    r3, [r0], #4)                   @ May fault
+                mov     ip, r0, lsl #32 - PAGE_SHIFT
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lc2u_2fupi
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #16
+                blt     .Lc2u_2rem8lp
+
+.Lc2u_2cpy8lp:  mov     r3, r7, pull #16
+                ldmia   r1!, {r4 - r7}
+                subs    ip, ip, #16
+                orr     r3, r3, r4, push #16
+                mov     r4, r4, pull #16
+                orr     r4, r4, r5, push #16
+                mov     r5, r5, pull #16
+                orr     r5, r5, r6, push #16
+                mov     r6, r6, pull #16
+                orr     r6, r6, r7, push #16
+                stmia   r0!, {r3 - r6}                  @ Shouldnt fault
+                bpl     .Lc2u_2cpy8lp
+
+.Lc2u_2rem8lp:  tst     ip, #8
+                movne   r3, r7, pull #16
+                ldmneia r1!, {r4, r7}
+                orrne   r3, r3, r4, push #16
+                movne   r4, r4, pull #16
+                orrne   r4, r4, r7, push #16
+                stmneia r0!, {r3 - r4}                  @ Shouldnt fault
+                tst     ip, #4
+                movne   r3, r7, pull #16
+                ldrne   r7, [r1], #4
+                orrne   r3, r3, r7, push #16
+        TUSER(  strne) r3, [r0], #4                     @ Shouldnt fault
+                ands    ip, ip, #3
+                beq     .Lc2u_2fupi
+.Lc2u_2nowords: mov     r3, r7, get_byte_2
+                teq     ip, #0
+                beq     .Lc2u_finished
+                cmp     ip, #2
+USER(   TUSER(  strb)   r3, [r0], #1)                   @ May fault
+                movge   r3, r7, get_byte_3
+USER(   TUSER(  strgeb) r3, [r0], #1)                   @ May fault
+                ldrgtb  r3, [r1], #0
+USER(   TUSER(  strgtb) r3, [r0], #1)                   @ May fault
+                b       .Lc2u_finished
+
+.Lc2u_3fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lc2u_3nowords
+                mov     r3, r7, pull #24
+                ldr     r7, [r1], #4
+                orr     r3, r3, r7, push #8
+USER(   TUSER(  str)    r3, [r0], #4)                   @ May fault
+                mov     ip, r0, lsl #32 - PAGE_SHIFT
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lc2u_3fupi
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #16
+                blt     .Lc2u_3rem8lp
+
+.Lc2u_3cpy8lp:  mov     r3, r7, pull #24
+                ldmia   r1!, {r4 - r7}
+                subs    ip, ip, #16
+                orr     r3, r3, r4, push #8
+                mov     r4, r4, pull #24
+                orr     r4, r4, r5, push #8
+                mov     r5, r5, pull #24
+                orr     r5, r5, r6, push #8
+                mov     r6, r6, pull #24
+                orr     r6, r6, r7, push #8
+                stmia   r0!, {r3 - r6}                  @ Shouldnt fault
+                bpl     .Lc2u_3cpy8lp
+
+.Lc2u_3rem8lp:  tst     ip, #8
+                movne   r3, r7, pull #24
+                ldmneia r1!, {r4, r7}
+                orrne   r3, r3, r4, push #8
+                movne   r4, r4, pull #24
+                orrne   r4, r4, r7, push #8
+                stmneia r0!, {r3 - r4}                  @ Shouldnt fault
+                tst     ip, #4
+                movne   r3, r7, pull #24
+                ldrne   r7, [r1], #4
+                orrne   r3, r3, r7, push #8
+        TUSER(  strne) r3, [r0], #4                     @ Shouldnt fault
+                ands    ip, ip, #3
+                beq     .Lc2u_3fupi
+.Lc2u_3nowords: mov     r3, r7, get_byte_3
+                teq     ip, #0
+                beq     .Lc2u_finished
+                cmp     ip, #2
+USER(   TUSER(  strb)   r3, [r0], #1)                   @ May fault
+                ldrgeb  r3, [r1], #1
+USER(   TUSER(  strgeb) r3, [r0], #1)                   @ May fault
+                ldrgtb  r3, [r1], #0
+USER(   TUSER(  strgtb) r3, [r0], #1)                   @ May fault
+                b       .Lc2u_finished
+ENDPROC(__copy_to_user)
+
+                .pushsection .fixup,"ax"
+                .align  0
+9001:           ldmfd   sp!, {r0, r4 - r7, pc}
+                .popsection
+
+/* Prototype: unsigned long __copy_from_user(void *to,const void *from,unsigned long n);
+ * Purpose  : copy a block from user memory to kernel memory
+ * Params   : to   - kernel memory
+ *          : from - user memory
+ *          : n    - number of bytes to copy
+ * Returns  : Number of bytes NOT copied.
+ */
+.Lcfu_dest_not_aligned:
+                rsb     ip, ip, #4
+                cmp     ip, #2
+USER(   TUSER(  ldrb)   r3, [r1], #1)                   @ May fault
+                strb    r3, [r0], #1
+USER(   TUSER(  ldrgeb) r3, [r1], #1)                   @ May fault
+                strgeb  r3, [r0], #1
+USER(   TUSER(  ldrgtb) r3, [r1], #1)                   @ May fault
+                strgtb  r3, [r0], #1
+                sub     r2, r2, ip
+                b       .Lcfu_dest_aligned
+
+ENTRY(__copy_from_user)
+                stmfd   sp!, {r0, r2, r4 - r7, lr}
+                cmp     r2, #4
+                blt     .Lcfu_not_enough
+                ands    ip, r0, #3
+                bne     .Lcfu_dest_not_aligned
+.Lcfu_dest_aligned:
+                ands    ip, r1, #3
+                bne     .Lcfu_src_not_aligned
+
+/*
+ * Seeing as there has to be at least 8 bytes to copy, we can
+ * copy one word, and force a user-mode page fault...
+ */
+
+.Lcfu_0fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lcfu_0nowords
+USER(   TUSER(  ldr)    r3, [r1], #4)
+                str     r3, [r0], #4
+                mov     ip, r1, lsl #32 - PAGE_SHIFT    @ On each page, use a ld/st??t instruction
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lcfu_0fupi
+/*
+ * ip = max no. of bytes to copy before needing another "strt" insn
+ */
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #32
+                blt     .Lcfu_0rem8lp
+
+.Lcfu_0cpy8lp:  ldmia   r1!, {r3 - r6}                  @ Shouldnt fault
+                stmia   r0!, {r3 - r6}
+                ldmia   r1!, {r3 - r6}                  @ Shouldnt fault
+                subs    ip, ip, #32
+                stmia   r0!, {r3 - r6}
+                bpl     .Lcfu_0cpy8lp
+
+.Lcfu_0rem8lp:  cmn     ip, #16
+                ldmgeia r1!, {r3 - r6}                  @ Shouldnt fault
+                stmgeia r0!, {r3 - r6}
+                tst     ip, #8
+                ldmneia r1!, {r3 - r4}                  @ Shouldnt fault
+                stmneia r0!, {r3 - r4}
+                tst     ip, #4
+        TUSER(  ldrne) r3, [r1], #4                     @ Shouldnt fault
+                strne   r3, [r0], #4
+                ands    ip, ip, #3
+                beq     .Lcfu_0fupi
+.Lcfu_0nowords: teq     ip, #0
+                beq     .Lcfu_finished
+.Lcfu_nowords:  cmp     ip, #2
+USER(   TUSER(  ldrb)   r3, [r1], #1)                   @ May fault
+                strb    r3, [r0], #1
+USER(   TUSER(  ldrgeb) r3, [r1], #1)                   @ May fault
+                strgeb  r3, [r0], #1
+USER(   TUSER(  ldrgtb) r3, [r1], #1)                   @ May fault
+                strgtb  r3, [r0], #1
+                b       .Lcfu_finished
+
+.Lcfu_not_enough:
+                movs    ip, r2
+                bne     .Lcfu_nowords
+.Lcfu_finished: mov     r0, #0
+                add     sp, sp, #8
+                ldmfd   sp!, {r4 - r7, pc}
+
+.Lcfu_src_not_aligned:
+                bic     r1, r1, #3
+USER(   TUSER(  ldr)    r7, [r1], #4)                   @ May fault
+                cmp     ip, #2
+                bgt     .Lcfu_3fupi
+                beq     .Lcfu_2fupi
+.Lcfu_1fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lcfu_1nowords
+                mov     r3, r7, pull #8
+USER(   TUSER(  ldr)    r7, [r1], #4)                   @ May fault
+                orr     r3, r3, r7, push #24
+                str     r3, [r0], #4
+                mov     ip, r1, lsl #32 - PAGE_SHIFT
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lcfu_1fupi
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #16
+                blt     .Lcfu_1rem8lp
+
+.Lcfu_1cpy8lp:  mov     r3, r7, pull #8
+                ldmia   r1!, {r4 - r7}                  @ Shouldnt fault
+                subs    ip, ip, #16
+                orr     r3, r3, r4, push #24
+                mov     r4, r4, pull #8
+                orr     r4, r4, r5, push #24
+                mov     r5, r5, pull #8
+                orr     r5, r5, r6, push #24
+                mov     r6, r6, pull #8
+                orr     r6, r6, r7, push #24
+                stmia   r0!, {r3 - r6}
+                bpl     .Lcfu_1cpy8lp
+
+.Lcfu_1rem8lp:  tst     ip, #8
+                movne   r3, r7, pull #8
+                ldmneia r1!, {r4, r7}                   @ Shouldnt fault
+                orrne   r3, r3, r4, push #24
+                movne   r4, r4, pull #8
+                orrne   r4, r4, r7, push #24
+                stmneia r0!, {r3 - r4}
+                tst     ip, #4
+                movne   r3, r7, pull #8
+USER(   TUSER(  ldrne) r7, [r1], #4)                    @ May fault
+                orrne   r3, r3, r7, push #24
+                strne   r3, [r0], #4
+                ands    ip, ip, #3
+                beq     .Lcfu_1fupi
+.Lcfu_1nowords: mov     r3, r7, get_byte_1
+                teq     ip, #0
+                beq     .Lcfu_finished
+                cmp     ip, #2
+                strb    r3, [r0], #1
+                movge   r3, r7, get_byte_2
+                strgeb  r3, [r0], #1
+                movgt   r3, r7, get_byte_3
+                strgtb  r3, [r0], #1
+                b       .Lcfu_finished
+
+.Lcfu_2fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lcfu_2nowords
+                mov     r3, r7, pull #16
+USER(   TUSER(  ldr)    r7, [r1], #4)                   @ May fault
+                orr     r3, r3, r7, push #16
+                str     r3, [r0], #4
+                mov     ip, r1, lsl #32 - PAGE_SHIFT
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lcfu_2fupi
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #16
+                blt     .Lcfu_2rem8lp
+
+
+.Lcfu_2cpy8lp:  mov     r3, r7, pull #16
+                ldmia   r1!, {r4 - r7}                  @ Shouldnt fault
+                subs    ip, ip, #16
+                orr     r3, r3, r4, push #16
+                mov     r4, r4, pull #16
+                orr     r4, r4, r5, push #16
+                mov     r5, r5, pull #16
+                orr     r5, r5, r6, push #16
+                mov     r6, r6, pull #16
+                orr     r6, r6, r7, push #16
+                stmia   r0!, {r3 - r6}
+                bpl     .Lcfu_2cpy8lp
+
+.Lcfu_2rem8lp:  tst     ip, #8
+                movne   r3, r7, pull #16
+                ldmneia r1!, {r4, r7}                   @ Shouldnt fault
+                orrne   r3, r3, r4, push #16
+                movne   r4, r4, pull #16
+                orrne   r4, r4, r7, push #16
+                stmneia r0!, {r3 - r4}
+                tst     ip, #4
+                movne   r3, r7, pull #16
+USER(   TUSER(  ldrne) r7, [r1], #4)                    @ May fault
+                orrne   r3, r3, r7, push #16
+                strne   r3, [r0], #4
+                ands    ip, ip, #3
+                beq     .Lcfu_2fupi
+.Lcfu_2nowords: mov     r3, r7, get_byte_2
+                teq     ip, #0
+                beq     .Lcfu_finished
+                cmp     ip, #2
+                strb    r3, [r0], #1
+                movge   r3, r7, get_byte_3
+                strgeb  r3, [r0], #1
+USER(   TUSER(  ldrgtb) r3, [r1], #0)                   @ May fault
+                strgtb  r3, [r0], #1
+                b       .Lcfu_finished
+
+.Lcfu_3fupi:    subs    r2, r2, #4
+                addmi   ip, r2, #4
+                bmi     .Lcfu_3nowords
+                mov     r3, r7, pull #24
+USER(   TUSER(  ldr)    r7, [r1], #4)                   @ May fault
+                orr     r3, r3, r7, push #8
+                str     r3, [r0], #4
+                mov     ip, r1, lsl #32 - PAGE_SHIFT
+                rsb     ip, ip, #0
+                movs    ip, ip, lsr #32 - PAGE_SHIFT
+                beq     .Lcfu_3fupi
+                cmp     r2, ip
+                movlt   ip, r2
+                sub     r2, r2, ip
+                subs    ip, ip, #16
+                blt     .Lcfu_3rem8lp
+
+.Lcfu_3cpy8lp:  mov     r3, r7, pull #24
+                ldmia   r1!, {r4 - r7}                  @ Shouldnt fault
+                orr     r3, r3, r4, push #8
+                mov     r4, r4, pull #24
+                orr     r4, r4, r5, push #8
+                mov     r5, r5, pull #24
+                orr     r5, r5, r6, push #8
+                mov     r6, r6, pull #24
+                orr     r6, r6, r7, push #8
+                stmia   r0!, {r3 - r6}
+                subs    ip, ip, #16
+                bpl     .Lcfu_3cpy8lp
+
+.Lcfu_3rem8lp:  tst     ip, #8
+                movne   r3, r7, pull #24
+                ldmneia r1!, {r4, r7}                   @ Shouldnt fault
+                orrne   r3, r3, r4, push #8
+                movne   r4, r4, pull #24
+                orrne   r4, r4, r7, push #8
+                stmneia r0!, {r3 - r4}
+                tst     ip, #4
+                movne   r3, r7, pull #24
+USER(   TUSER(  ldrne) r7, [r1], #4)                    @ May fault
+                orrne   r3, r3, r7, push #8
+                strne   r3, [r0], #4
+                ands    ip, ip, #3
+                beq     .Lcfu_3fupi
+.Lcfu_3nowords: mov     r3, r7, get_byte_3
+                teq     ip, #0
+                beq     .Lcfu_finished
+                cmp     ip, #2
+                strb    r3, [r0], #1
+USER(   TUSER(  ldrgeb) r3, [r1], #1)                   @ May fault
+                strgeb  r3, [r0], #1
+USER(   TUSER(  ldrgtb) r3, [r1], #1)                   @ May fault
+                strgtb  r3, [r0], #1
+                b       .Lcfu_finished
+ENDPROC(__copy_from_user)
+
+                .pushsection .fixup,"ax"
+                .align  0
+                /*
+                 * We took an exception.  r0 contains a pointer to
+                 * the byte not copied.
+                 */
+9001:           ldr     r2, [sp], #4                    @ void *to
+                sub     r2, r0, r2                      @ bytes copied
+                ldr     r1, [sp], #4                    @ unsigned long count
+                subs    r4, r1, r2                      @ bytes left to copy
+                movne   r1, r4
+                blne    __memzero
+                mov     r0, r4
+                ldmfd   sp!, {r4 - r7, pc}
+                .popsection
+
diff --git a/arch/arm/mach-dove/common.c b/arch/arm/mach-dove/common.c
index 4db5de54b6a7..6321567d8eaa 100644
--- a/arch/arm/mach-dove/common.c
+++ b/arch/arm/mach-dove/common.c
@@ -102,7 +102,8 @@ void __init dove_ehci1_init(void)
 void __init dove_ge00_init(struct mv643xx_eth_platform_data *eth_data)
 {
         orion_ge00_init(eth_data, DOVE_GE00_PHYS_BASE,
-                        IRQ_DOVE_GE00_SUM, IRQ_DOVE_GE00_ERR);
+                        IRQ_DOVE_GE00_SUM, IRQ_DOVE_GE00_ERR,
+                        1600);
 }
 
 /*****************************************************************************
diff --git a/arch/arm/mach-exynos/mach-origen.c b/arch/arm/mach-exynos/mach-origen.c
index 5ca80307d6d7..4e574c24581c 100644
--- a/arch/arm/mach-exynos/mach-origen.c
+++ b/arch/arm/mach-exynos/mach-origen.c
@@ -42,6 +42,7 @@
 #include <plat/backlight.h>
 #include <plat/fb.h>
 #include <plat/mfc.h>
+#include <plat/hdmi.h>
 
 #include <mach/ohci.h>
 #include <mach/map.h>
@@ -734,6 +735,11 @@ static void __init origen_bt_setup(void)
         s3c_gpio_setpull(EXYNOS4_GPX2(2), S3C_GPIO_PULL_NONE);
 }
 
+/* I2C module and id for HDMIPHY */
+static struct i2c_board_info hdmiphy_info = {
+        I2C_BOARD_INFO("hdmiphy-exynos4210", 0x38),
+};
+
 static void s5p_tv_setup(void)
 {
         /* Direct HPD to HDMI chip */
@@ -781,6 +787,7 @@ static void __init origen_machine_init(void)
 
         s5p_tv_setup();
         s5p_i2c_hdmiphy_set_platdata(NULL);
+        s5p_hdmi_set_platdata(&hdmiphy_info, NULL, 0);
 
 #ifdef CONFIG_DRM_EXYNOS
         s5p_device_fimd0.dev.platform_data = &drm_fimd_pdata;
diff --git a/arch/arm/mach-exynos/mach-smdkv310.c b/arch/arm/mach-exynos/mach-smdkv310.c
index 3cfa688d274a..73f2bce097e1 100644
--- a/arch/arm/mach-exynos/mach-smdkv310.c
+++ b/arch/arm/mach-exynos/mach-smdkv310.c
@@ -40,6 +40,7 @@
 #include <plat/mfc.h>
 #include <plat/ehci.h>
 #include <plat/clock.h>
+#include <plat/hdmi.h>
 
 #include <mach/map.h>
 #include <mach/ohci.h>
@@ -354,6 +355,11 @@ static struct platform_pwm_backlight_data smdkv310_bl_data = {
         .pwm_period_ns  = 1000,
 };
 
+/* I2C module and id for HDMIPHY */
+static struct i2c_board_info hdmiphy_info = {
+        I2C_BOARD_INFO("hdmiphy-exynos4210", 0x38),
+};
+
 static void s5p_tv_setup(void)
 {
         /* direct HPD to HDMI chip */
@@ -388,6 +394,7 @@ static void __init smdkv310_machine_init(void)
 
         s5p_tv_setup();
         s5p_i2c_hdmiphy_set_platdata(NULL);
+        s5p_hdmi_set_platdata(&hdmiphy_info, NULL, 0);
 
         samsung_keypad_set_platdata(&smdkv310_keypad_data);
 
diff --git a/arch/arm/mach-imx/Makefile b/arch/arm/mach-imx/Makefile
index 07f7c226e4cf..d004d37ad9d8 100644
--- a/arch/arm/mach-imx/Makefile
+++ b/arch/arm/mach-imx/Makefile
@@ -9,7 +9,8 @@ obj-$(CONFIG_SOC_IMX27) += clk-imx27.o mm-imx27.o ehci-imx27.o
 obj-$(CONFIG_SOC_IMX31) += mm-imx3.o cpu-imx31.o clk-imx31.o iomux-imx31.o ehci-imx31.o pm-imx3.o
 obj-$(CONFIG_SOC_IMX35) += mm-imx3.o cpu-imx35.o clk-imx35.o ehci-imx35.o pm-imx3.o
 
-obj-$(CONFIG_SOC_IMX5) += cpu-imx5.o mm-imx5.o clk-imx51-imx53.o ehci-imx5.o pm-imx5.o cpu_op-mx51.o
+imx5-pm-$(CONFIG_PM) += pm-imx5.o
+obj-$(CONFIG_SOC_IMX5) += cpu-imx5.o mm-imx5.o clk-imx51-imx53.o ehci-imx5.o $(imx5-pm-y) cpu_op-mx51.o
 
 obj-$(CONFIG_COMMON_CLK) += clk-pllv1.o clk-pllv2.o clk-pllv3.o clk-gate2.o \
                             clk-pfd.o clk-busy.o
@@ -70,14 +71,13 @@ obj-$(CONFIG_DEBUG_LL) += lluart.o
 obj-$(CONFIG_HAVE_IMX_GPC) += gpc.o
 obj-$(CONFIG_HAVE_IMX_MMDC) += mmdc.o
 obj-$(CONFIG_HAVE_IMX_SRC) += src.o
-obj-$(CONFIG_CPU_V7) += head-v7.o
-AFLAGS_head-v7.o :=-Wa,-march=armv7-a
-obj-$(CONFIG_SMP) += platsmp.o
+AFLAGS_headsmp.o :=-Wa,-march=armv7-a
+obj-$(CONFIG_SMP) += headsmp.o platsmp.o
 obj-$(CONFIG_HOTPLUG_CPU) += hotplug.o
 obj-$(CONFIG_SOC_IMX6Q) += clk-imx6q.o mach-imx6q.o
 
 ifeq ($(CONFIG_PM),y)
-obj-$(CONFIG_SOC_IMX6Q) += pm-imx6q.o
+obj-$(CONFIG_SOC_IMX6Q) += pm-imx6q.o headsmp.o
 endif
 
 # i.MX5 based machines
diff --git a/arch/arm/mach-imx/clk-imx6q.c b/arch/arm/mach-imx/clk-imx6q.c
index ea89520b6e22..4233d9e3531d 100644
--- a/arch/arm/mach-imx/clk-imx6q.c
+++ b/arch/arm/mach-imx/clk-imx6q.c
@@ -152,7 +152,7 @@ enum mx6q_clks {
         ssi2, ssi3, uart_ipg, uart_serial, usboh3, usdhc1, usdhc2, usdhc3,
         usdhc4, vdo_axi, vpu_axi, cko1, pll1_sys, pll2_bus, pll3_usb_otg,
         pll4_audio, pll5_video, pll6_mlb, pll7_usb_host, pll8_enet, ssi1_ipg,
-        ssi2_ipg, ssi3_ipg, rom, usbphy1, usbphy2,
+        ssi2_ipg, ssi3_ipg, rom, usbphy1, usbphy2, ldb_di0_div_3_5, ldb_di1_div_3_5,
         clk_max
 };
 
@@ -288,8 +288,10 @@ int __init mx6q_clocks_init(void)
         clk[gpu3d_shader]     = imx_clk_divider("gpu3d_shader",     "gpu3d_shader_sel",  base + 0x18, 29, 3);
         clk[ipu1_podf]        = imx_clk_divider("ipu1_podf",        "ipu1_sel",          base + 0x3c, 11, 3);
         clk[ipu2_podf]        = imx_clk_divider("ipu2_podf",        "ipu2_sel",          base + 0x3c, 16, 3);
-        clk[ldb_di0_podf]     = imx_clk_divider("ldb_di0_podf",     "ldb_di0_sel",       base + 0x20, 10, 1);
-        clk[ldb_di1_podf]     = imx_clk_divider("ldb_di1_podf",     "ldb_di1_sel",       base + 0x20, 11, 1);
+        clk[ldb_di0_div_3_5]  = imx_clk_fixed_factor("ldb_di0_div_3_5", "ldb_di0_sel", 2, 7);
+        clk[ldb_di0_podf]     = imx_clk_divider("ldb_di0_podf",     "ldb_di0_div_3_5",       base + 0x20, 10, 1);
+        clk[ldb_di1_div_3_5]  = imx_clk_fixed_factor("ldb_di1_div_3_5", "ldb_di1_sel", 2, 7);
+        clk[ldb_di1_podf]     = imx_clk_divider("ldb_di1_podf",     "ldb_di1_div_3_5",   base + 0x20, 11, 1);
         clk[ipu1_di0_pre]     = imx_clk_divider("ipu1_di0_pre",     "ipu1_di0_pre_sel",  base + 0x34, 3,  3);
         clk[ipu1_di1_pre]     = imx_clk_divider("ipu1_di1_pre",     "ipu1_di1_pre_sel",  base + 0x34, 12, 3);
         clk[ipu2_di0_pre]     = imx_clk_divider("ipu2_di0_pre",     "ipu2_di0_pre_sel",  base + 0x38, 3,  3);
diff --git a/arch/arm/mach-imx/head-v7.S b/arch/arm/mach-imx/headsmp.S
index 7e49deb128a4..7e49deb128a4 100644
--- a/arch/arm/mach-imx/head-v7.S
+++ b/arch/arm/mach-imx/headsmp.S
diff --git a/arch/arm/mach-imx/hotplug.c b/arch/arm/mach-imx/hotplug.c
index 20ed2d56c1af..f8f7437c83b8 100644
--- a/arch/arm/mach-imx/hotplug.c
+++ b/arch/arm/mach-imx/hotplug.c
@@ -42,22 +42,6 @@ static inline void cpu_enter_lowpower(void)
           : "cc");
 }
 
-static inline void cpu_leave_lowpower(void)
-{
-        unsigned int v;
-
-        asm volatile(
-                "mrc    p15, 0, %0, c1, c0, 0\n"
-        "       orr     %0, %0, %1\n"
-        "       mcr     p15, 0, %0, c1, c0, 0\n"
-        "       mrc     p15, 0, %0, c1, c0, 1\n"
-        "       orr     %0, %0, %2\n"
-        "       mcr     p15, 0, %0, c1, c0, 1\n"
-          : "=&r" (v)
-          : "Ir" (CR_C), "Ir" (0x40)
-          : "cc");
-}
-
 /*
  * platform-specific code to shutdown a CPU
  *
@@ -67,11 +51,10 @@ void platform_cpu_die(unsigned int cpu)
 {
         cpu_enter_lowpower();
         imx_enable_cpu(cpu, false);
-        cpu_do_idle();
-        cpu_leave_lowpower();
 
-        /* We should never return from idle */
-        panic("cpu %d unexpectedly exit from shutdown\n", cpu);
+        /* spin here until hardware takes it down */
+        while (1)
+                ;
 }
 
 int platform_cpu_disable(unsigned int cpu)
diff --git a/arch/arm/mach-imx/mach-imx6q.c b/arch/arm/mach-imx/mach-imx6q.c
index 5ec0608f2a76..045b3f6a387d 100644
--- a/arch/arm/mach-imx/mach-imx6q.c
+++ b/arch/arm/mach-imx/mach-imx6q.c
@@ -71,7 +71,7 @@ soft:
 /* For imx6q sabrelite board: set KSZ9021RN RGMII pad skew */
 static int ksz9021rn_phy_fixup(struct phy_device *phydev)
 {
-        if (IS_ENABLED(CONFIG_PHYLIB)) {
+        if (IS_BUILTIN(CONFIG_PHYLIB)) {
                 /* min rx data delay */
                 phy_write(phydev, 0x0b, 0x8105);
                 phy_write(phydev, 0x0c, 0x0000);
@@ -112,7 +112,7 @@ put_clk:
 
 static void __init imx6q_sabrelite_init(void)
 {
-        if (IS_ENABLED(CONFIG_PHYLIB))
+        if (IS_BUILTIN(CONFIG_PHYLIB))
                 phy_register_fixup_for_uid(PHY_ID_KSZ9021, MICREL_PHY_ID_MASK,
                                 ksz9021rn_phy_fixup);
         imx6q_sabrelite_cko1_setup();
diff --git a/arch/arm/mach-kirkwood/Makefile.boot b/arch/arm/mach-kirkwood/Makefile.boot
index a5717558ee89..a13299d758e1 100644
--- a/arch/arm/mach-kirkwood/Makefile.boot
+++ b/arch/arm/mach-kirkwood/Makefile.boot
@@ -7,7 +7,8 @@ dtb-$(CONFIG_MACH_DLINK_KIRKWOOD_DT) += kirkwood-dns320.dtb
 dtb-$(CONFIG_MACH_DLINK_KIRKWOOD_DT) += kirkwood-dns325.dtb
 dtb-$(CONFIG_MACH_ICONNECT_DT) += kirkwood-iconnect.dtb
 dtb-$(CONFIG_MACH_IB62X0_DT) += kirkwood-ib62x0.dtb
-dtb-$(CONFIG_MACH_TS219_DT)     += kirkwood-qnap-ts219.dtb
+dtb-$(CONFIG_MACH_TS219_DT)     += kirkwood-ts219-6281.dtb
+dtb-$(CONFIG_MACH_TS219_DT)     += kirkwood-ts219-6282.dtb
 dtb-$(CONFIG_MACH_GOFLEXNET_DT) += kirkwood-goflexnet.dtb
 dtb-$(CONFIG_MACH_LSXL_DT) += kirkwood-lschlv2.dtb
 dtb-$(CONFIG_MACH_LSXL_DT) += kirkwood-lsxhl.dtb
diff --git a/arch/arm/mach-kirkwood/common.c b/arch/arm/mach-kirkwood/common.c
index c4b64adcbfce..3226077735b1 100644
--- a/arch/arm/mach-kirkwood/common.c
+++ b/arch/arm/mach-kirkwood/common.c
@@ -301,7 +301,7 @@ void __init kirkwood_ge00_init(struct mv643xx_eth_platform_data *eth_data)
 {
         orion_ge00_init(eth_data,
                         GE00_PHYS_BASE, IRQ_KIRKWOOD_GE00_SUM,
-                        IRQ_KIRKWOOD_GE00_ERR);
+                        IRQ_KIRKWOOD_GE00_ERR, 1600);
         /* The interface forgets the MAC address assigned by u-boot if
         the clock is turned off, so claim the clk now. */
         clk_prepare_enable(ge0);
@@ -315,7 +315,7 @@ void __init kirkwood_ge01_init(struct mv643xx_eth_platform_data *eth_data)
 {
         orion_ge01_init(eth_data,
                         GE01_PHYS_BASE, IRQ_KIRKWOOD_GE01_SUM,
-                        IRQ_KIRKWOOD_GE01_ERR);
+                        IRQ_KIRKWOOD_GE01_ERR, 1600);
         clk_prepare_enable(ge1);
 }
 
diff --git a/arch/arm/mach-mmp/sram.c b/arch/arm/mach-mmp/sram.c
index 4304f9519372..7e8a5a2e1ec7 100644
--- a/arch/arm/mach-mmp/sram.c
+++ b/arch/arm/mach-mmp/sram.c
@@ -68,7 +68,7 @@ static int __devinit sram_probe(struct platform_device *pdev)
         struct resource *res;
         int ret = 0;
 
-        if (!pdata && !pdata->pool_name)
+        if (!pdata || !pdata->pool_name)
                 return -ENODEV;
 
         info = kzalloc(sizeof(*info), GFP_KERNEL);
diff --git a/arch/arm/mach-mv78xx0/addr-map.c b/arch/arm/mach-mv78xx0/addr-map.c
index 62b53d710efd..a9bc84180d21 100644
--- a/arch/arm/mach-mv78xx0/addr-map.c
+++ b/arch/arm/mach-mv78xx0/addr-map.c
@@ -37,7 +37,7 @@
 #define WIN0_OFF(n)             (BRIDGE_VIRT_BASE + 0x0000 + ((n) << 4))
 #define WIN8_OFF(n)             (BRIDGE_VIRT_BASE + 0x0900 + (((n) - 8) << 4))
 
-static void __init __iomem *win_cfg_base(int win)
+static void __init __iomem *win_cfg_base(const struct orion_addr_map_cfg *cfg, int win)
 {
         /*
          * Find the control register base address for this window.
diff --git a/arch/arm/mach-mv78xx0/common.c b/arch/arm/mach-mv78xx0/common.c
index b4c53b846c9c..3057f7d4329a 100644
--- a/arch/arm/mach-mv78xx0/common.c
+++ b/arch/arm/mach-mv78xx0/common.c
@@ -213,7 +213,8 @@ void __init mv78xx0_ge00_init(struct mv643xx_eth_platform_data *eth_data)
 {
         orion_ge00_init(eth_data,
                         GE00_PHYS_BASE, IRQ_MV78XX0_GE00_SUM,
-                        IRQ_MV78XX0_GE_ERR);
+                        IRQ_MV78XX0_GE_ERR,
+                        MV643XX_TX_CSUM_DEFAULT_LIMIT);
 }
 
 
@@ -224,7 +225,8 @@ void __init mv78xx0_ge01_init(struct mv643xx_eth_platform_data *eth_data)
 {
         orion_ge01_init(eth_data,
                         GE01_PHYS_BASE, IRQ_MV78XX0_GE01_SUM,
-                        NO_IRQ);
+                        NO_IRQ,
+                        MV643XX_TX_CSUM_DEFAULT_LIMIT);
 }
 
 
diff --git a/arch/arm/mach-omap2/Kconfig b/arch/arm/mach-omap2/Kconfig
index dd2db025f778..fcd4e85c4ddc 100644
--- a/arch/arm/mach-omap2/Kconfig
+++ b/arch/arm/mach-omap2/Kconfig
@@ -62,13 +62,14 @@ config ARCH_OMAP4
         select PM_OPP if PM
         select USB_ARCH_HAS_EHCI if USB_SUPPORT
         select ARM_CPU_SUSPEND if PM
-        select ARCH_NEEDS_CPU_IDLE_COUPLED
+        select ARCH_NEEDS_CPU_IDLE_COUPLED if SMP
 
 config SOC_OMAP5
         bool "TI OMAP5"
         select CPU_V7
         select ARM_GIC
         select HAVE_SMP
+        select ARM_CPU_SUSPEND if PM
 
 comment "OMAP Core Type"
         depends on ARCH_OMAP2
diff --git a/arch/arm/mach-omap2/board-igep0020.c b/arch/arm/mach-omap2/board-igep0020.c
index 74915295482e..28214483aaba 100644
--- a/arch/arm/mach-omap2/board-igep0020.c
+++ b/arch/arm/mach-omap2/board-igep0020.c
@@ -554,6 +554,8 @@ static const struct usbhs_omap_board_data igep3_usbhs_bdata __initconst = {
 
 #ifdef CONFIG_OMAP_MUX
 static struct omap_board_mux board_mux[] __initdata = {
+        /* SMSC9221 LAN Controller ETH IRQ (GPIO_176) */
+        OMAP3_MUX(MCSPI1_CS2, OMAP_MUX_MODE4 | OMAP_PIN_INPUT),
         { .reg_offset = OMAP_MUX_TERMINATOR },
 };
 #endif
diff --git a/arch/arm/mach-omap2/board-omap3evm.c b/arch/arm/mach-omap2/board-omap3evm.c
index ef230a0eb5eb..0d362e9f9cb9 100644
--- a/arch/arm/mach-omap2/board-omap3evm.c
+++ b/arch/arm/mach-omap2/board-omap3evm.c
@@ -58,6 +58,7 @@
 #include "hsmmc.h"
 #include "common-board-devices.h"
 
+#define OMAP3_EVM_TS_GPIO       175
 #define OMAP3_EVM_EHCI_VBUS     22
 #define OMAP3_EVM_EHCI_SELECT   61
 
diff --git a/arch/arm/mach-omap2/common-board-devices.c b/arch/arm/mach-omap2/common-board-devices.c
index 14734746457c..c1875862679f 100644
--- a/arch/arm/mach-omap2/common-board-devices.c
+++ b/arch/arm/mach-omap2/common-board-devices.c
@@ -35,16 +35,6 @@ static struct omap2_mcspi_device_config ads7846_mcspi_config = {
         .turbo_mode     = 0,
 };
 
-/*
- * ADS7846 driver maybe request a gpio according to the value
- * of pdata->get_pendown_state, but we have done this. So set
- * get_pendown_state to avoid twice gpio requesting.
- */
-static int omap3_get_pendown_state(void)
-{
-        return !gpio_get_value(OMAP3_EVM_TS_GPIO);
-}
-
 static struct ads7846_platform_data ads7846_config = {
         .x_max                  = 0x0fff,
         .y_max                  = 0x0fff,
@@ -55,7 +45,6 @@ static struct ads7846_platform_data ads7846_config = {
         .debounce_rep           = 1,
         .gpio_pendown           = -EINVAL,
         .keep_vref_on           = 1,
-        .get_pendown_state      = &omap3_get_pendown_state,
 };
 
 static struct spi_board_info ads7846_spi_board_info __initdata = {
diff --git a/arch/arm/mach-omap2/common-board-devices.h b/arch/arm/mach-omap2/common-board-devices.h
index 4c4ef6a6166b..a0b4a42836ab 100644
--- a/arch/arm/mach-omap2/common-board-devices.h
+++ b/arch/arm/mach-omap2/common-board-devices.h
@@ -4,7 +4,6 @@
 #include "twl-common.h"
 
 #define NAND_BLOCK_SIZE SZ_128K
-#define OMAP3_EVM_TS_GPIO       175
 
 struct mtd_partition;
 struct ads7846_platform_data;
diff --git a/arch/arm/mach-omap2/cpuidle44xx.c b/arch/arm/mach-omap2/cpuidle44xx.c
index ee05e193fc61..288bee6cbb76 100644
--- a/arch/arm/mach-omap2/cpuidle44xx.c
+++ b/arch/arm/mach-omap2/cpuidle44xx.c
@@ -238,8 +238,9 @@ int __init omap4_idle_init(void)
         for_each_cpu(cpu_id, cpu_online_mask) {
                 dev = &per_cpu(omap4_idle_dev, cpu_id);
                 dev->cpu = cpu_id;
+#ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
                 dev->coupled_cpus = *cpu_online_mask;
-
+#endif
                 cpuidle_register_driver(&omap4_idle_driver);
 
                 if (cpuidle_register_device(dev)) {
diff --git a/arch/arm/mach-omap2/mux.h b/arch/arm/mach-omap2/mux.h
index 471e62a74a16..76f9b3c2f586 100644
--- a/arch/arm/mach-omap2/mux.h
+++ b/arch/arm/mach-omap2/mux.h
@@ -127,7 +127,6 @@ struct omap_mux_partition {
  * @gpio:       GPIO number
  * @muxnames:   available signal modes for a ball
  * @balls:      available balls on the package
- * @partition:  mux partition
  */
 struct omap_mux {
         u16     reg_offset;
diff --git a/arch/arm/mach-omap2/opp4xxx_data.c b/arch/arm/mach-omap2/opp4xxx_data.c
index 2293ba27101b..c95415da23c2 100644
--- a/arch/arm/mach-omap2/opp4xxx_data.c
+++ b/arch/arm/mach-omap2/opp4xxx_data.c
@@ -94,7 +94,7 @@ int __init omap4_opp_init(void)
 {
         int r = -ENODEV;
 
-        if (!cpu_is_omap44xx())
+        if (!cpu_is_omap443x())
                 return r;
 
         r = omap_init_opp_table(omap44xx_opp_def_list,
diff --git a/arch/arm/mach-omap2/pm34xx.c b/arch/arm/mach-omap2/pm34xx.c
index e4fc88c65dbd..05bd8f02723f 100644
--- a/arch/arm/mach-omap2/pm34xx.c
+++ b/arch/arm/mach-omap2/pm34xx.c
@@ -272,21 +272,16 @@ void omap_sram_idle(void)
         per_next_state = pwrdm_read_next_pwrst(per_pwrdm);
         core_next_state = pwrdm_read_next_pwrst(core_pwrdm);
 
-        if (mpu_next_state < PWRDM_POWER_ON) {
-                pwrdm_pre_transition(mpu_pwrdm);
-                pwrdm_pre_transition(neon_pwrdm);
-        }
+        pwrdm_pre_transition(NULL);
 
         /* PER */
         if (per_next_state < PWRDM_POWER_ON) {
-                pwrdm_pre_transition(per_pwrdm);
                 per_going_off = (per_next_state == PWRDM_POWER_OFF) ? 1 : 0;
                 omap2_gpio_prepare_for_idle(per_going_off);
         }
 
         /* CORE */
         if (core_next_state < PWRDM_POWER_ON) {
-                pwrdm_pre_transition(core_pwrdm);
                 if (core_next_state == PWRDM_POWER_OFF) {
                         omap3_core_save_context();
                         omap3_cm_save_context();
@@ -339,20 +334,14 @@ void omap_sram_idle(void)
                         omap2_prm_clear_mod_reg_bits(OMAP3430_AUTO_OFF_MASK,
                                                OMAP3430_GR_MOD,
                                                OMAP3_PRM_VOLTCTRL_OFFSET);
-                pwrdm_post_transition(core_pwrdm);
         }
         omap3_intc_resume_idle();
 
+        pwrdm_post_transition(NULL);
+
         /* PER */
-        if (per_next_state < PWRDM_POWER_ON) {
+        if (per_next_state < PWRDM_POWER_ON)
                 omap2_gpio_resume_after_idle();
-                pwrdm_post_transition(per_pwrdm);
-        }
-
-        if (mpu_next_state < PWRDM_POWER_ON) {
-                pwrdm_post_transition(mpu_pwrdm);
-                pwrdm_post_transition(neon_pwrdm);
-        }
 }
 
 static void omap3_pm_idle(void)
diff --git a/arch/arm/mach-omap2/sleep44xx.S b/arch/arm/mach-omap2/sleep44xx.S
index 9f6b83d1b193..91e71d8f46f0 100644
--- a/arch/arm/mach-omap2/sleep44xx.S
+++ b/arch/arm/mach-omap2/sleep44xx.S
@@ -56,9 +56,13 @@ ppa_por_params:
  * The restore function pointer is stored at CPUx_WAKEUP_NS_PA_ADDR_OFFSET.
  * It returns to the caller for CPU INACTIVE and ON power states or in case
  * CPU failed to transition to targeted OFF/DORMANT state.
+ *
+ * omap4_finish_suspend() calls v7_flush_dcache_all() which doesn't save
+ * stack frame and it expects the caller to take care of it. Hence the entire
+ * stack frame is saved to avoid possible stack corruption.
  */
 ENTRY(omap4_finish_suspend)
-        stmfd   sp!, {lr}
+        stmfd   sp!, {r4-r12, lr}
         cmp     r0, #0x0
         beq     do_WFI                          @ No lowpower state, jump to WFI
 
@@ -226,7 +230,7 @@ scu_gp_clear:
 skip_scu_gp_clear:
         isb
         dsb
-        ldmfd   sp!, {pc}
+        ldmfd   sp!, {r4-r12, pc}
 ENDPROC(omap4_finish_suspend)
 
 /*
diff --git a/arch/arm/mach-omap2/twl-common.c b/arch/arm/mach-omap2/twl-common.c
index de47f170ba50..db5ff6642375 100644
--- a/arch/arm/mach-omap2/twl-common.c
+++ b/arch/arm/mach-omap2/twl-common.c
@@ -67,6 +67,7 @@ void __init omap_pmic_init(int bus, u32 clkrate,
                            const char *pmic_type, int pmic_irq,
                            struct twl4030_platform_data *pmic_data)
 {
+        omap_mux_init_signal("sys_nirq", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
         strncpy(pmic_i2c_board_info.type, pmic_type,
                 sizeof(pmic_i2c_board_info.type));
         pmic_i2c_board_info.irq = pmic_irq;
diff --git a/arch/arm/mach-orion5x/common.c b/arch/arm/mach-orion5x/common.c
index 9148b229d0de..410291c67666 100644
--- a/arch/arm/mach-orion5x/common.c
+++ b/arch/arm/mach-orion5x/common.c
@@ -109,7 +109,8 @@ void __init orion5x_eth_init(struct mv643xx_eth_platform_data *eth_data)
 {
         orion_ge00_init(eth_data,
                         ORION5X_ETH_PHYS_BASE, IRQ_ORION5X_ETH_SUM,
-                        IRQ_ORION5X_ETH_ERR);
+                        IRQ_ORION5X_ETH_ERR,
+                        MV643XX_TX_CSUM_DEFAULT_LIMIT);
 }
 
 
diff --git a/arch/arm/mach-s3c24xx/include/mach/dma.h b/arch/arm/mach-s3c24xx/include/mach/dma.h
index 454831b66037..ee99fd56c043 100644
--- a/arch/arm/mach-s3c24xx/include/mach/dma.h
+++ b/arch/arm/mach-s3c24xx/include/mach/dma.h
@@ -24,7 +24,8 @@
 */
 
 enum dma_ch {
-        DMACH_XD0,
+        DMACH_DT_PROP = -1,     /* not yet supported, do not use */
+        DMACH_XD0 = 0,
         DMACH_XD1,
         DMACH_SDI,
         DMACH_SPI0,
diff --git a/arch/arm/mach-ux500/Kconfig b/arch/arm/mach-ux500/Kconfig
index c013bbf79cac..53d3d46dec12 100644
--- a/arch/arm/mach-ux500/Kconfig
+++ b/arch/arm/mach-ux500/Kconfig
@@ -41,7 +41,6 @@ config MACH_HREFV60
 config MACH_SNOWBALL
         bool "U8500 Snowball platform"
         select MACH_MOP500
-        select LEDS_GPIO
         help
           Include support for the snowball development platform.
 
diff --git a/arch/arm/mach-ux500/board-mop500-msp.c b/arch/arm/mach-ux500/board-mop500-msp.c
index 996048038743..df15646036aa 100644
--- a/arch/arm/mach-ux500/board-mop500-msp.c
+++ b/arch/arm/mach-ux500/board-mop500-msp.c
@@ -191,9 +191,9 @@ static struct platform_device *db8500_add_msp_i2s(struct device *parent,
         return pdev;
 }
 
-/* Platform device for ASoC U8500 machine */
-static struct platform_device snd_soc_u8500 = {
-                .name = "snd-soc-u8500",
+/* Platform device for ASoC MOP500 machine */
+static struct platform_device snd_soc_mop500 = {
+                .name = "snd-soc-mop500",
                 .id = 0,
                 .dev = {
                         .platform_data = NULL,
@@ -227,8 +227,8 @@ int mop500_msp_init(struct device *parent)
 {
         struct platform_device *msp1;
 
-        pr_info("%s: Register platform-device 'snd-soc-u8500'.\n", __func__);
-        platform_device_register(&snd_soc_u8500);
+        pr_info("%s: Register platform-device 'snd-soc-mop500'.\n", __func__);
+        platform_device_register(&snd_soc_mop500);
 
         pr_info("Initialize MSP I2S-devices.\n");
         db8500_add_msp_i2s(parent, 0, U8500_MSP0_BASE, IRQ_DB8500_MSP0,
diff --git a/arch/arm/mach-ux500/board-mop500.c b/arch/arm/mach-ux500/board-mop500.c
index 8674a890fd1c..a534d8880de1 100644
--- a/arch/arm/mach-ux500/board-mop500.c
+++ b/arch/arm/mach-ux500/board-mop500.c
@@ -797,6 +797,7 @@ static void __init u8500_init_machine(void)
                                 ARRAY_SIZE(mop500_platform_devs));
 
                 mop500_sdi_init(parent);
+                mop500_msp_init(parent);
                 i2c0_devs = ARRAY_SIZE(mop500_i2c0_devices);
                 i2c_register_board_info(0, mop500_i2c0_devices, i2c0_devs);
                 i2c_register_board_info(2, mop500_i2c2_devices,
@@ -804,6 +805,8 @@ static void __init u8500_init_machine(void)
 
                 mop500_uib_init();
 
+        } else if (of_machine_is_compatible("calaosystems,snowball-a9500")) {
+                mop500_msp_init(parent);
         } else if (of_machine_is_compatible("st-ericsson,hrefv60+")) {
                 /*
                  * The HREFv60 board removed a GPIO expander and routed
@@ -815,6 +818,7 @@ static void __init u8500_init_machine(void)
                                 ARRAY_SIZE(mop500_platform_devs));
 
                 hrefv60_sdi_init(parent);
+                mop500_msp_init(parent);
 
                 i2c0_devs = ARRAY_SIZE(mop500_i2c0_devices);
                 i2c0_devs -= NUM_PRE_V60_I2C0_DEVICES;
diff --git a/arch/arm/mm/flush.c b/arch/arm/mm/flush.c
index 77458548e031..40ca11ed6e5f 100644
--- a/arch/arm/mm/flush.c
+++ b/arch/arm/mm/flush.c
@@ -231,8 +231,6 @@ void __sync_icache_dcache(pte_t pteval)
         struct page *page;
         struct address_space *mapping;
 
-        if (!pte_present_user(pteval))
-                return;
         if (cache_is_vipt_nonaliasing() && !pte_exec(pteval))
                 /* only flush non-aliasing VIPT caches for exec mappings */
                 return;
diff --git a/arch/arm/mm/tlb-v7.S b/arch/arm/mm/tlb-v7.S
index c2021139cb56..ea94765acf9a 100644
--- a/arch/arm/mm/tlb-v7.S
+++ b/arch/arm/mm/tlb-v7.S
@@ -38,10 +38,10 @@ ENTRY(v7wbi_flush_user_tlb_range)
         dsb
         mov     r0, r0, lsr #PAGE_SHIFT         @ align address
         mov     r1, r1, lsr #PAGE_SHIFT
-#ifdef CONFIG_ARM_ERRATA_720789
-        mov     r3, #0
-#else
         asid    r3, r3                          @ mask ASID
+#ifdef CONFIG_ARM_ERRATA_720789
+        ALT_SMP(W(mov)  r3, #0  )
+        ALT_UP(W(nop)           )
 #endif
         orr     r0, r3, r0, lsl #PAGE_SHIFT     @ Create initial MVA
         mov     r1, r1, lsl #PAGE_SHIFT
diff --git a/arch/arm/plat-omap/dmtimer.c b/arch/arm/plat-omap/dmtimer.c
index 626ad8cad7a9..938b50a33439 100644
--- a/arch/arm/plat-omap/dmtimer.c
+++ b/arch/arm/plat-omap/dmtimer.c
@@ -189,6 +189,7 @@ struct omap_dm_timer *omap_dm_timer_request(void)
                 timer->reserved = 1;
                 break;
         }
+        spin_unlock_irqrestore(&dm_timer_lock, flags);
 
         if (timer) {
                 ret = omap_dm_timer_prepare(timer);
@@ -197,7 +198,6 @@ struct omap_dm_timer *omap_dm_timer_request(void)
                         timer = NULL;
                 }
         }
-        spin_unlock_irqrestore(&dm_timer_lock, flags);
 
         if (!timer)
                 pr_debug("%s: timer request failed!\n", __func__);
@@ -220,6 +220,7 @@ struct omap_dm_timer *omap_dm_timer_request_specific(int id)
                         break;
                 }
         }
+        spin_unlock_irqrestore(&dm_timer_lock, flags);
 
         if (timer) {
                 ret = omap_dm_timer_prepare(timer);
@@ -228,7 +229,6 @@ struct omap_dm_timer *omap_dm_timer_request_specific(int id)
                         timer = NULL;
                 }
         }
-        spin_unlock_irqrestore(&dm_timer_lock, flags);
 
         if (!timer)
                 pr_debug("%s: timer%d request failed!\n", __func__, id);
@@ -258,7 +258,7 @@ EXPORT_SYMBOL_GPL(omap_dm_timer_enable);
 
 void omap_dm_timer_disable(struct omap_dm_timer *timer)
 {
-        pm_runtime_put(&timer->pdev->dev);
+        pm_runtime_put_sync(&timer->pdev->dev);
 }
 EXPORT_SYMBOL_GPL(omap_dm_timer_disable);
 
diff --git a/arch/arm/plat-omap/include/plat/cpu.h b/arch/arm/plat-omap/include/plat/cpu.h
index 68b180edcfff..bb5d08a70dbc 100644
--- a/arch/arm/plat-omap/include/plat/cpu.h
+++ b/arch/arm/plat-omap/include/plat/cpu.h
@@ -372,7 +372,8 @@ IS_OMAP_TYPE(3430, 0x3430)
 #define cpu_class_is_omap1()    (cpu_is_omap7xx() || cpu_is_omap15xx() || \
                                 cpu_is_omap16xx())
 #define cpu_class_is_omap2()    (cpu_is_omap24xx() || cpu_is_omap34xx() || \
-                                cpu_is_omap44xx() || soc_is_omap54xx())
+                                cpu_is_omap44xx() || soc_is_omap54xx() || \
+                                soc_is_am33xx())
 
 /* Various silicon revisions for omap2 */
 #define OMAP242X_CLASS          0x24200024
diff --git a/arch/arm/plat-omap/include/plat/multi.h b/arch/arm/plat-omap/include/plat/multi.h
index 045e320f1067..324d31b14852 100644
--- a/arch/arm/plat-omap/include/plat/multi.h
+++ b/arch/arm/plat-omap/include/plat/multi.h
@@ -108,4 +108,13 @@
 # endif
 #endif
 
+#ifdef CONFIG_SOC_AM33XX
+# ifdef OMAP_NAME
+#  undef  MULTI_OMAP2
+#  define MULTI_OMAP2
+# else
+#  define OMAP_NAME am33xx
+# endif
+#endif
+
 #endif  /* __PLAT_OMAP_MULTI_H */
diff --git a/arch/arm/plat-omap/include/plat/uncompress.h b/arch/arm/plat-omap/include/plat/uncompress.h
index b8d19a136781..7f7b112acccb 100644
--- a/arch/arm/plat-omap/include/plat/uncompress.h
+++ b/arch/arm/plat-omap/include/plat/uncompress.h
@@ -110,7 +110,7 @@ static inline void flush(void)
         _DEBUG_LL_ENTRY(mach, AM33XX_UART##p##_BASE, OMAP_PORT_SHIFT,   \
                 AM33XXUART##p)
 
-static inline void __arch_decomp_setup(unsigned long arch_id)
+static inline void arch_decomp_setup(void)
 {
         int port = 0;
 
@@ -198,8 +198,6 @@ static inline void __arch_decomp_setup(unsigned long arch_id)
         } while (0);
 }
 
-#define arch_decomp_setup()     __arch_decomp_setup(arch_id)
-
 /*
  * nothing to do
  */
diff --git a/arch/arm/plat-orion/common.c b/arch/arm/plat-orion/common.c
index d245a87dc014..b8b747a9d360 100644
--- a/arch/arm/plat-orion/common.c
+++ b/arch/arm/plat-orion/common.c
@@ -291,10 +291,12 @@ static struct platform_device orion_ge00 = {
 void __init orion_ge00_init(struct mv643xx_eth_platform_data *eth_data,
                             unsigned long mapbase,
                             unsigned long irq,
-                            unsigned long irq_err)
+                            unsigned long irq_err,
+                            unsigned int tx_csum_limit)
 {
         fill_resources(&orion_ge00_shared, orion_ge00_shared_resources,
                        mapbase + 0x2000, SZ_16K - 1, irq_err);
+        orion_ge00_shared_data.tx_csum_limit = tx_csum_limit;
         ge_complete(&orion_ge00_shared_data,
                     orion_ge00_resources, irq, &orion_ge00_shared,
                     eth_data, &orion_ge00);
@@ -343,10 +345,12 @@ static struct platform_device orion_ge01 = {
 void __init orion_ge01_init(struct mv643xx_eth_platform_data *eth_data,
                             unsigned long mapbase,
                             unsigned long irq,
-                            unsigned long irq_err)
+                            unsigned long irq_err,
+                            unsigned int tx_csum_limit)
 {
         fill_resources(&orion_ge01_shared, orion_ge01_shared_resources,
                        mapbase + 0x2000, SZ_16K - 1, irq_err);
+        orion_ge01_shared_data.tx_csum_limit = tx_csum_limit;
         ge_complete(&orion_ge01_shared_data,
                     orion_ge01_resources, irq, &orion_ge01_shared,
                     eth_data, &orion_ge01);
diff --git a/arch/arm/plat-orion/include/plat/common.h b/arch/arm/plat-orion/include/plat/common.h
index e00fdb213609..ae2377ef63e5 100644
--- a/arch/arm/plat-orion/include/plat/common.h
+++ b/arch/arm/plat-orion/include/plat/common.h
@@ -39,12 +39,14 @@ void __init orion_rtc_init(unsigned long mapbase,
 void __init orion_ge00_init(struct mv643xx_eth_platform_data *eth_data,
                             unsigned long mapbase,
                             unsigned long irq,
-                            unsigned long irq_err);
+                            unsigned long irq_err,
+                            unsigned int tx_csum_limit);
 
 void __init orion_ge01_init(struct mv643xx_eth_platform_data *eth_data,
                             unsigned long mapbase,
                             unsigned long irq,
-                            unsigned long irq_err);
+                            unsigned long irq_err,
+                            unsigned int tx_csum_limit);
 
 void __init orion_ge10_init(struct mv643xx_eth_platform_data *eth_data,
                             unsigned long mapbase,
diff --git a/arch/arm/plat-s3c24xx/dma.c b/arch/arm/plat-s3c24xx/dma.c
index 28f898f75380..db98e7021f0d 100644
--- a/arch/arm/plat-s3c24xx/dma.c
+++ b/arch/arm/plat-s3c24xx/dma.c
@@ -430,7 +430,7 @@ s3c2410_dma_canload(struct s3c2410_dma_chan *chan)
  * when necessary.
 */
 
-int s3c2410_dma_enqueue(unsigned int channel, void *id,
+int s3c2410_dma_enqueue(enum dma_ch channel, void *id,
                         dma_addr_t data, int size)
 {
         struct s3c2410_dma_chan *chan = s3c_dma_lookup_channel(channel);
diff --git a/arch/arm/plat-samsung/devs.c b/arch/arm/plat-samsung/devs.c
index 74e31ce35538..fc49f3dabd76 100644
--- a/arch/arm/plat-samsung/devs.c
+++ b/arch/arm/plat-samsung/devs.c
@@ -32,6 +32,8 @@
 #include <linux/platform_data/s3c-hsudc.h>
 #include <linux/platform_data/s3c-hsotg.h>
 
+#include <media/s5p_hdmi.h>
+
 #include <asm/irq.h>
 #include <asm/pmu.h>
 #include <asm/mach/arch.h>
@@ -748,7 +750,8 @@ void __init s5p_i2c_hdmiphy_set_platdata(struct s3c2410_platform_i2c *pd)
         if (!pd) {
                 pd = &default_i2c_data;
 
-                if (soc_is_exynos4210())
+                if (soc_is_exynos4210() ||
+                    soc_is_exynos4212() || soc_is_exynos4412())
                         pd->bus_num = 8;
                 else if (soc_is_s5pv210())
                         pd->bus_num = 3;
@@ -759,6 +762,30 @@ void __init s5p_i2c_hdmiphy_set_platdata(struct s3c2410_platform_i2c *pd)
         npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c),
                                &s5p_device_i2c_hdmiphy);
 }
+
+struct s5p_hdmi_platform_data s5p_hdmi_def_platdata;
+
+void __init s5p_hdmi_set_platdata(struct i2c_board_info *hdmiphy_info,
+                                  struct i2c_board_info *mhl_info, int mhl_bus)
+{
+        struct s5p_hdmi_platform_data *pd = &s5p_hdmi_def_platdata;
+
+        if (soc_is_exynos4210() ||
+            soc_is_exynos4212() || soc_is_exynos4412())
+                pd->hdmiphy_bus = 8;
+        else if (soc_is_s5pv210())
+                pd->hdmiphy_bus = 3;
+        else
+                pd->hdmiphy_bus = 0;
+
+        pd->hdmiphy_info = hdmiphy_info;
+        pd->mhl_info = mhl_info;
+        pd->mhl_bus = mhl_bus;
+
+        s3c_set_platdata(pd, sizeof(struct s5p_hdmi_platform_data),
+                         &s5p_device_hdmi);
+}
+
 #endif /* CONFIG_S5P_DEV_I2C_HDMIPHY */
 
 /* I2S */
diff --git a/arch/arm/plat-samsung/include/plat/hdmi.h b/arch/arm/plat-samsung/include/plat/hdmi.h
new file mode 100644
index 000000000000..331d046ac2c5
--- /dev/null
+++ b/arch/arm/plat-samsung/include/plat/hdmi.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics Co.Ltd
+ *
+ * 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.
+ */
+
+#ifndef __PLAT_SAMSUNG_HDMI_H
+#define __PLAT_SAMSUNG_HDMI_H __FILE__
+
+extern void s5p_hdmi_set_platdata(struct i2c_board_info *hdmiphy_info,
+                                  struct i2c_board_info *mhl_info, int mhl_bus);
+
+#endif /* __PLAT_SAMSUNG_HDMI_H */
diff --git a/arch/arm/plat-samsung/pm.c b/arch/arm/plat-samsung/pm.c
index 64ab65f0fdbc..15070284343e 100644
--- a/arch/arm/plat-samsung/pm.c
+++ b/arch/arm/plat-samsung/pm.c
@@ -74,7 +74,7 @@ unsigned char pm_uart_udivslot;
 
 #ifdef CONFIG_SAMSUNG_PM_DEBUG
 
-struct pm_uart_save uart_save[CONFIG_SERIAL_SAMSUNG_UARTS];
+static struct pm_uart_save uart_save[CONFIG_SERIAL_SAMSUNG_UARTS];
 
 static void s3c_pm_save_uart(unsigned int uart, struct pm_uart_save *save)
 {
diff --git a/arch/arm/vfp/vfpmodule.c b/arch/arm/vfp/vfpmodule.c
index fb849d044bde..c834b32af275 100644
--- a/arch/arm/vfp/vfpmodule.c
+++ b/arch/arm/vfp/vfpmodule.c
@@ -719,8 +719,10 @@ static int __init vfp_init(void)
                         if ((fmrx(MVFR1) & 0x000fff00) == 0x00011100)
                                 elf_hwcap |= HWCAP_NEON;
 #endif
+#ifdef CONFIG_VFPv3
                         if ((fmrx(MVFR1) & 0xf0000000) == 0x10000000)
                                 elf_hwcap |= HWCAP_VFPv4;
+#endif
                 }
         }
         return 0;
diff --git a/arch/c6x/Kconfig b/arch/c6x/Kconfig
index 052f81a76239..983c859e40b7 100644
--- a/arch/c6x/Kconfig
+++ b/arch/c6x/Kconfig
@@ -6,6 +6,7 @@
 config C6X
         def_bool y
         select CLKDEV_LOOKUP
+        select GENERIC_ATOMIC64
         select GENERIC_IRQ_SHOW
         select HAVE_ARCH_TRACEHOOK
         select HAVE_DMA_API_DEBUG
diff --git a/arch/c6x/include/asm/cache.h b/arch/c6x/include/asm/cache.h
index 6d521d96d941..09c5a0f5f4d1 100644
--- a/arch/c6x/include/asm/cache.h
+++ b/arch/c6x/include/asm/cache.h
@@ -1,7 +1,7 @@
 /*
  *  Port on Texas Instruments TMS320C6x architecture
  *
- *  Copyright (C) 2005, 2006, 2009, 2010 Texas Instruments Incorporated
+ *  Copyright (C) 2005, 2006, 2009, 2010, 2012 Texas Instruments Incorporated
  *  Author: Aurelien Jacquiot (aurelien.jacquiot@jaluna.com)
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -16,9 +16,14 @@
 /*
  * Cache line size
  */
-#define L1D_CACHE_BYTES   64
-#define L1P_CACHE_BYTES   32
-#define L2_CACHE_BYTES    128
+#define L1D_CACHE_SHIFT   6
+#define L1D_CACHE_BYTES   (1 << L1D_CACHE_SHIFT)
+
+#define L1P_CACHE_SHIFT   5
+#define L1P_CACHE_BYTES   (1 << L1P_CACHE_SHIFT)
+
+#define L2_CACHE_SHIFT    7
+#define L2_CACHE_BYTES    (1 << L2_CACHE_SHIFT)
 
 /*
  * L2 used as cache
@@ -29,7 +34,8 @@
  * For practical reasons the L1_CACHE_BYTES defines should not be smaller than
  * the L2 line size
  */
-#define L1_CACHE_BYTES        L2_CACHE_BYTES
+#define L1_CACHE_SHIFT        L2_CACHE_SHIFT
+#define L1_CACHE_BYTES        (1 << L1_CACHE_SHIFT)
 
 #define L2_CACHE_ALIGN_LOW(x) \
         (((x) & ~(L2_CACHE_BYTES - 1)))
diff --git a/arch/ia64/configs/generic_defconfig b/arch/ia64/configs/generic_defconfig
index 954d81e2e837..7913695b2fcb 100644
--- a/arch/ia64/configs/generic_defconfig
+++ b/arch/ia64/configs/generic_defconfig
@@ -234,5 +234,4 @@ CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_MD5=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRC_T10DIF=y
-CONFIG_MISC_DEVICES=y
 CONFIG_INTEL_IOMMU=y
diff --git a/arch/ia64/configs/gensparse_defconfig b/arch/ia64/configs/gensparse_defconfig
index 91c41ecfa6d9..f8e913365423 100644
--- a/arch/ia64/configs/gensparse_defconfig
+++ b/arch/ia64/configs/gensparse_defconfig
@@ -209,4 +209,3 @@ CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_DEBUG_MUTEXES=y
 CONFIG_CRYPTO_MD5=y
-CONFIG_MISC_DEVICES=y
diff --git a/arch/m68k/Kconfig b/arch/m68k/Kconfig
index 4a469907f04a..b22df9410dce 100644
--- a/arch/m68k/Kconfig
+++ b/arch/m68k/Kconfig
@@ -5,6 +5,7 @@ config M68K
         select HAVE_AOUT if MMU
         select HAVE_GENERIC_HARDIRQS
         select GENERIC_IRQ_SHOW
+        select GENERIC_ATOMIC64
         select ARCH_HAVE_NMI_SAFE_CMPXCHG if RMW_INSNS
         select GENERIC_CPU_DEVICES
         select GENERIC_STRNCPY_FROM_USER if MMU
diff --git a/arch/m68k/Kconfig.cpu b/arch/m68k/Kconfig.cpu
index 82068349a2bb..c4eb79edecec 100644
--- a/arch/m68k/Kconfig.cpu
+++ b/arch/m68k/Kconfig.cpu
@@ -28,6 +28,7 @@ config COLDFIRE
         select CPU_HAS_NO_BITFIELDS
         select CPU_HAS_NO_MULDIV64
         select GENERIC_CSUM
+        select HAVE_CLK
 
 endchoice
 
@@ -58,7 +59,6 @@ config MCPU32
 config M68020
         bool "68020 support"
         depends on MMU
-        select GENERIC_ATOMIC64
         select CPU_HAS_ADDRESS_SPACES
         help
           If you anticipate running this kernel on a computer with a MC68020
@@ -69,7 +69,6 @@ config M68020
 config M68030
         bool "68030 support"
         depends on MMU && !MMU_SUN3
-        select GENERIC_ATOMIC64
         select CPU_HAS_ADDRESS_SPACES
         help
           If you anticipate running this kernel on a computer with a MC68030
@@ -79,7 +78,6 @@ config M68030
 config M68040
         bool "68040 support"
         depends on MMU && !MMU_SUN3
-        select GENERIC_ATOMIC64
         select CPU_HAS_ADDRESS_SPACES
         help
           If you anticipate running this kernel on a computer with a MC68LC040
@@ -90,7 +88,6 @@ config M68040
 config M68060
         bool "68060 support"
         depends on MMU && !MMU_SUN3
-        select GENERIC_ATOMIC64
         select CPU_HAS_ADDRESS_SPACES
         help
           If you anticipate running this kernel on a computer with a MC68060
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index 331d574df99c..faf65286574e 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -89,6 +89,7 @@ config ATH79
         select CEVT_R4K
         select CSRC_R4K
         select DMA_NONCOHERENT
+        select HAVE_CLK
         select IRQ_CPU
         select MIPS_MACHINE
         select SYS_HAS_CPU_MIPS32_R2
diff --git a/arch/mips/alchemy/board-mtx1.c b/arch/mips/alchemy/board-mtx1.c
index 99969484c475..a124c251c0c9 100644
--- a/arch/mips/alchemy/board-mtx1.c
+++ b/arch/mips/alchemy/board-mtx1.c
@@ -228,6 +228,8 @@ static int mtx1_pci_idsel(unsigned int devsel, int assert)
          * adapter on the mtx-1 "singleboard" variant. It triggers a custom
          * logic chip connected to EXT_IO3 (GPIO1) to suppress IDSEL signals.
          */
+        udelay(1);
+
         if (assert && devsel != 0)
                 /* Suppress signal to Cardbus */
                 alchemy_gpio_set_value(1, 0);   /* set EXT_IO3 OFF */
diff --git a/arch/mips/ath79/dev-usb.c b/arch/mips/ath79/dev-usb.c
index 36e9570e7bc4..b2a2311ec85b 100644
--- a/arch/mips/ath79/dev-usb.c
+++ b/arch/mips/ath79/dev-usb.c
@@ -145,6 +145,8 @@ static void __init ar7240_usb_setup(void)
 
         ath79_ohci_resources[0].start = AR7240_OHCI_BASE;
         ath79_ohci_resources[0].end = AR7240_OHCI_BASE + AR7240_OHCI_SIZE - 1;
+        ath79_ohci_resources[1].start = ATH79_CPU_IRQ_USB;
+        ath79_ohci_resources[1].end = ATH79_CPU_IRQ_USB;
         platform_device_register(&ath79_ohci_device);
 }
 
diff --git a/arch/mips/ath79/gpio.c b/arch/mips/ath79/gpio.c
index 29054f211832..48fe762d2526 100644
--- a/arch/mips/ath79/gpio.c
+++ b/arch/mips/ath79/gpio.c
@@ -188,8 +188,10 @@ void __init ath79_gpio_init(void)
 
         if (soc_is_ar71xx())
                 ath79_gpio_count = AR71XX_GPIO_COUNT;
-        else if (soc_is_ar724x())
-                ath79_gpio_count = AR724X_GPIO_COUNT;
+        else if (soc_is_ar7240())
+                ath79_gpio_count = AR7240_GPIO_COUNT;
+        else if (soc_is_ar7241() || soc_is_ar7242())
+                ath79_gpio_count = AR7241_GPIO_COUNT;
         else if (soc_is_ar913x())
                 ath79_gpio_count = AR913X_GPIO_COUNT;
         else if (soc_is_ar933x())
diff --git a/arch/mips/bcm63xx/dev-spi.c b/arch/mips/bcm63xx/dev-spi.c
index e39f73048d4f..f1c9c3e2f678 100644
--- a/arch/mips/bcm63xx/dev-spi.c
+++ b/arch/mips/bcm63xx/dev-spi.c
@@ -106,11 +106,15 @@ int __init bcm63xx_spi_register(void)
         if (BCMCPU_IS_6338() || BCMCPU_IS_6348()) {
                 spi_resources[0].end += BCM_6338_RSET_SPI_SIZE - 1;
                 spi_pdata.fifo_size = SPI_6338_MSG_DATA_SIZE;
+                spi_pdata.msg_type_shift = SPI_6338_MSG_TYPE_SHIFT;
+                spi_pdata.msg_ctl_width = SPI_6338_MSG_CTL_WIDTH;
         }
 
         if (BCMCPU_IS_6358() || BCMCPU_IS_6368()) {
                 spi_resources[0].end += BCM_6358_RSET_SPI_SIZE - 1;
                 spi_pdata.fifo_size = SPI_6358_MSG_DATA_SIZE;
+                spi_pdata.msg_type_shift = SPI_6358_MSG_TYPE_SHIFT;
+                spi_pdata.msg_ctl_width = SPI_6358_MSG_CTL_WIDTH;
         }
 
         bcm63xx_spi_regs_init();
diff --git a/arch/mips/cavium-octeon/octeon-irq.c b/arch/mips/cavium-octeon/octeon-irq.c
index 7fb1f222b8a5..274cd4fad30c 100644
--- a/arch/mips/cavium-octeon/octeon-irq.c
+++ b/arch/mips/cavium-octeon/octeon-irq.c
@@ -61,6 +61,12 @@ static void octeon_irq_set_ciu_mapping(int irq, int line, int bit,
         octeon_irq_ciu_to_irq[line][bit] = irq;
 }
 
+static void octeon_irq_force_ciu_mapping(struct irq_domain *domain,
+                                         int irq, int line, int bit)
+{
+        irq_domain_associate(domain, irq, line << 6 | bit);
+}
+
 static int octeon_coreid_for_cpu(int cpu)
 {
 #ifdef CONFIG_SMP
@@ -183,19 +189,9 @@ static void __init octeon_irq_init_core(void)
                 mutex_init(&cd->core_irq_mutex);
 
                 irq = OCTEON_IRQ_SW0 + i;
-                switch (irq) {
-                case OCTEON_IRQ_TIMER:
-                case OCTEON_IRQ_SW0:
-                case OCTEON_IRQ_SW1:
-                case OCTEON_IRQ_5:
-                case OCTEON_IRQ_PERF:
-                        irq_set_chip_data(irq, cd);
-                        irq_set_chip_and_handler(irq, &octeon_irq_chip_core,
-                                                 handle_percpu_irq);
-                        break;
-                default:
-                        break;
-                }
+                irq_set_chip_data(irq, cd);
+                irq_set_chip_and_handler(irq, &octeon_irq_chip_core,
+                                         handle_percpu_irq);
         }
 }
 
@@ -890,7 +886,6 @@ static int octeon_irq_gpio_xlat(struct irq_domain *d,
         unsigned int type;
         unsigned int pin;
         unsigned int trigger;
-        struct octeon_irq_gpio_domain_data *gpiod;
 
         if (d->of_node != node)
                 return -EINVAL;
@@ -925,8 +920,7 @@ static int octeon_irq_gpio_xlat(struct irq_domain *d,
                 break;
         }
         *out_type = type;
-        gpiod = d->host_data;
-        *out_hwirq = gpiod->base_hwirq + pin;
+        *out_hwirq = pin;
 
         return 0;
 }
@@ -996,19 +990,21 @@ static int octeon_irq_ciu_map(struct irq_domain *d,
 static int octeon_irq_gpio_map(struct irq_domain *d,
                                unsigned int virq, irq_hw_number_t hw)
 {
-        unsigned int line = hw >> 6;
-        unsigned int bit = hw & 63;
+        struct octeon_irq_gpio_domain_data *gpiod = d->host_data;
+        unsigned int line, bit;
 
         if (!octeon_irq_virq_in_range(virq))
                 return -EINVAL;
 
+        hw += gpiod->base_hwirq;
+        line = hw >> 6;
+        bit = hw & 63;
         if (line > 1 || octeon_irq_ciu_to_irq[line][bit] != 0)
                 return -EINVAL;
 
         octeon_irq_set_ciu_mapping(virq, line, bit,
                                    octeon_irq_gpio_chip,
                                    octeon_irq_handle_gpio);
-
         return 0;
 }
 
@@ -1149,6 +1145,7 @@ static void __init octeon_irq_init_ciu(void)
         struct irq_chip *chip_wd;
         struct device_node *gpio_node;
         struct device_node *ciu_node;
+        struct irq_domain *ciu_domain = NULL;
 
         octeon_irq_init_ciu_percpu();
         octeon_irq_setup_secondary = octeon_irq_setup_secondary_ciu;
@@ -1177,31 +1174,6 @@ static void __init octeon_irq_init_ciu(void)
         /* Mips internal */
         octeon_irq_init_core();
 
-        /* CIU_0 */
-        for (i = 0; i < 16; i++)
-                octeon_irq_set_ciu_mapping(i + OCTEON_IRQ_WORKQ0, 0, i + 0, chip, handle_level_irq);
-
-        octeon_irq_set_ciu_mapping(OCTEON_IRQ_MBOX0, 0, 32, chip_mbox, handle_percpu_irq);
-        octeon_irq_set_ciu_mapping(OCTEON_IRQ_MBOX1, 0, 33, chip_mbox, handle_percpu_irq);
-
-        for (i = 0; i < 4; i++)
-                octeon_irq_set_ciu_mapping(i + OCTEON_IRQ_PCI_INT0, 0, i + 36, chip, handle_level_irq);
-        for (i = 0; i < 4; i++)
-                octeon_irq_set_ciu_mapping(i + OCTEON_IRQ_PCI_MSI0, 0, i + 40, chip, handle_level_irq);
-
-        octeon_irq_set_ciu_mapping(OCTEON_IRQ_RML, 0, 46, chip, handle_level_irq);
-        for (i = 0; i < 4; i++)
-                octeon_irq_set_ciu_mapping(i + OCTEON_IRQ_TIMER0, 0, i + 52, chip, handle_edge_irq);
-
-        octeon_irq_set_ciu_mapping(OCTEON_IRQ_USB0, 0, 56, chip, handle_level_irq);
-        octeon_irq_set_ciu_mapping(OCTEON_IRQ_BOOTDMA, 0, 63, chip, handle_level_irq);
-
-        /* CIU_1 */
-        for (i = 0; i < 16; i++)
-                octeon_irq_set_ciu_mapping(i + OCTEON_IRQ_WDOG0, 1, i + 0, chip_wd, handle_level_irq);
-
-        octeon_irq_set_ciu_mapping(OCTEON_IRQ_USB1, 1, 17, chip, handle_level_irq);
-
         gpio_node = of_find_compatible_node(NULL, NULL, "cavium,octeon-3860-gpio");
         if (gpio_node) {
                 struct octeon_irq_gpio_domain_data *gpiod;
@@ -1219,10 +1191,35 @@ static void __init octeon_irq_init_ciu(void)
 
         ciu_node = of_find_compatible_node(NULL, NULL, "cavium,octeon-3860-ciu");
         if (ciu_node) {
-                irq_domain_add_tree(ciu_node, &octeon_irq_domain_ciu_ops, NULL);
+                ciu_domain = irq_domain_add_tree(ciu_node, &octeon_irq_domain_ciu_ops, NULL);
                 of_node_put(ciu_node);
         } else
-                pr_warn("Cannot find device node for cavium,octeon-3860-ciu.\n");
+                panic("Cannot find device node for cavium,octeon-3860-ciu.");
+
+        /* CIU_0 */
+        for (i = 0; i < 16; i++)
+                octeon_irq_force_ciu_mapping(ciu_domain, i + OCTEON_IRQ_WORKQ0, 0, i + 0);
+
+        octeon_irq_set_ciu_mapping(OCTEON_IRQ_MBOX0, 0, 32, chip_mbox, handle_percpu_irq);
+        octeon_irq_set_ciu_mapping(OCTEON_IRQ_MBOX1, 0, 33, chip_mbox, handle_percpu_irq);
+
+        for (i = 0; i < 4; i++)
+                octeon_irq_force_ciu_mapping(ciu_domain, i + OCTEON_IRQ_PCI_INT0, 0, i + 36);
+        for (i = 0; i < 4; i++)
+                octeon_irq_force_ciu_mapping(ciu_domain, i + OCTEON_IRQ_PCI_MSI0, 0, i + 40);
+
+        octeon_irq_force_ciu_mapping(ciu_domain, OCTEON_IRQ_RML, 0, 46);
+        for (i = 0; i < 4; i++)
+                octeon_irq_force_ciu_mapping(ciu_domain, i + OCTEON_IRQ_TIMER0, 0, i + 52);
+
+        octeon_irq_force_ciu_mapping(ciu_domain, OCTEON_IRQ_USB0, 0, 56);
+        octeon_irq_force_ciu_mapping(ciu_domain, OCTEON_IRQ_BOOTDMA, 0, 63);
+
+        /* CIU_1 */
+        for (i = 0; i < 16; i++)
+                octeon_irq_set_ciu_mapping(i + OCTEON_IRQ_WDOG0, 1, i + 0, chip_wd, handle_level_irq);
+
+        octeon_irq_force_ciu_mapping(ciu_domain, OCTEON_IRQ_USB1, 1, 17);
 
         /* Enable the CIU lines */
         set_c0_status(STATUSF_IP3 | STATUSF_IP2);
diff --git a/arch/mips/include/asm/mach-ath79/ar71xx_regs.h b/arch/mips/include/asm/mach-ath79/ar71xx_regs.h
index 1caa78ad06d5..dde504477fac 100644
--- a/arch/mips/include/asm/mach-ath79/ar71xx_regs.h
+++ b/arch/mips/include/asm/mach-ath79/ar71xx_regs.h
@@ -393,7 +393,8 @@
 #define AR71XX_GPIO_REG_FUNC            0x28
 
 #define AR71XX_GPIO_COUNT               16
-#define AR724X_GPIO_COUNT               18
+#define AR7240_GPIO_COUNT               18
+#define AR7241_GPIO_COUNT               20
 #define AR913X_GPIO_COUNT               22
 #define AR933X_GPIO_COUNT               30
 #define AR934X_GPIO_COUNT               23
diff --git a/arch/mips/include/asm/mach-ath79/cpu-feature-overrides.h b/arch/mips/include/asm/mach-ath79/cpu-feature-overrides.h
index 4476fa03bf36..6ddae926bf79 100644
--- a/arch/mips/include/asm/mach-ath79/cpu-feature-overrides.h
+++ b/arch/mips/include/asm/mach-ath79/cpu-feature-overrides.h
@@ -42,7 +42,6 @@
 #define cpu_has_mips64r1        0
 #define cpu_has_mips64r2        0
 
-#define cpu_has_dsp             0
 #define cpu_has_mipsmt          0
 
 #define cpu_has_64bits          0
diff --git a/arch/mips/include/asm/mach-bcm63xx/bcm63xx_dev_spi.h b/arch/mips/include/asm/mach-bcm63xx/bcm63xx_dev_spi.h
index 7d98dbe5d4b5..c9bae1362606 100644
--- a/arch/mips/include/asm/mach-bcm63xx/bcm63xx_dev_spi.h
+++ b/arch/mips/include/asm/mach-bcm63xx/bcm63xx_dev_spi.h
@@ -9,6 +9,8 @@ int __init bcm63xx_spi_register(void);
 
 struct bcm63xx_spi_pdata {
         unsigned int    fifo_size;
+        unsigned int    msg_type_shift;
+        unsigned int    msg_ctl_width;
         int             bus_num;
         int             num_chipselect;
         u32             speed_hz;
diff --git a/arch/mips/include/asm/mach-bcm63xx/bcm63xx_regs.h b/arch/mips/include/asm/mach-bcm63xx/bcm63xx_regs.h
index 4ccc2a748aff..61f2a2a5099d 100644
--- a/arch/mips/include/asm/mach-bcm63xx/bcm63xx_regs.h
+++ b/arch/mips/include/asm/mach-bcm63xx/bcm63xx_regs.h
@@ -1054,7 +1054,8 @@
 #define SPI_6338_FILL_BYTE              0x07
 #define SPI_6338_MSG_TAIL               0x09
 #define SPI_6338_RX_TAIL                0x0b
-#define SPI_6338_MSG_CTL                0x40
+#define SPI_6338_MSG_CTL                0x40    /* 8-bits register */
+#define SPI_6338_MSG_CTL_WIDTH          8
 #define SPI_6338_MSG_DATA               0x41
 #define SPI_6338_MSG_DATA_SIZE          0x3f
 #define SPI_6338_RX_DATA                0x80
@@ -1070,7 +1071,8 @@
 #define SPI_6348_FILL_BYTE              0x07
 #define SPI_6348_MSG_TAIL               0x09
 #define SPI_6348_RX_TAIL                0x0b
-#define SPI_6348_MSG_CTL                0x40
+#define SPI_6348_MSG_CTL                0x40    /* 8-bits register */
+#define SPI_6348_MSG_CTL_WIDTH          8
 #define SPI_6348_MSG_DATA               0x41
 #define SPI_6348_MSG_DATA_SIZE          0x3f
 #define SPI_6348_RX_DATA                0x80
@@ -1078,6 +1080,7 @@
 
 /* BCM 6358 SPI core */
 #define SPI_6358_MSG_CTL                0x00    /* 16-bits register */
+#define SPI_6358_MSG_CTL_WIDTH          16
 #define SPI_6358_MSG_DATA               0x02
 #define SPI_6358_MSG_DATA_SIZE          0x21e
 #define SPI_6358_RX_DATA                0x400
@@ -1094,6 +1097,7 @@
 
 /* BCM 6358 SPI core */
 #define SPI_6368_MSG_CTL                0x00    /* 16-bits register */
+#define SPI_6368_MSG_CTL_WIDTH          16
 #define SPI_6368_MSG_DATA               0x02
 #define SPI_6368_MSG_DATA_SIZE          0x21e
 #define SPI_6368_RX_DATA                0x400
@@ -1115,7 +1119,10 @@
 #define SPI_HD_W                        0x01
 #define SPI_HD_R                        0x02
 #define SPI_BYTE_CNT_SHIFT              0
-#define SPI_MSG_TYPE_SHIFT              14
+#define SPI_6338_MSG_TYPE_SHIFT         6
+#define SPI_6348_MSG_TYPE_SHIFT         6
+#define SPI_6358_MSG_TYPE_SHIFT         14
+#define SPI_6368_MSG_TYPE_SHIFT         14
 
 /* Command */
 #define SPI_CMD_NOOP                    0x00
diff --git a/arch/mips/include/asm/mach-cavium-octeon/irq.h b/arch/mips/include/asm/mach-cavium-octeon/irq.h
index 418992042f6f..c22a3078bf11 100644
--- a/arch/mips/include/asm/mach-cavium-octeon/irq.h
+++ b/arch/mips/include/asm/mach-cavium-octeon/irq.h
@@ -21,14 +21,10 @@ enum octeon_irq {
         OCTEON_IRQ_TIMER,
 /* sources in CIU_INTX_EN0 */
         OCTEON_IRQ_WORKQ0,
-        OCTEON_IRQ_GPIO0 = OCTEON_IRQ_WORKQ0 + 16,
-        OCTEON_IRQ_WDOG0 = OCTEON_IRQ_GPIO0 + 16,
+        OCTEON_IRQ_WDOG0 = OCTEON_IRQ_WORKQ0 + 16,
         OCTEON_IRQ_WDOG15 = OCTEON_IRQ_WDOG0 + 15,
         OCTEON_IRQ_MBOX0 = OCTEON_IRQ_WDOG0 + 16,
         OCTEON_IRQ_MBOX1,
-        OCTEON_IRQ_UART0,
-        OCTEON_IRQ_UART1,
-        OCTEON_IRQ_UART2,
         OCTEON_IRQ_PCI_INT0,
         OCTEON_IRQ_PCI_INT1,
         OCTEON_IRQ_PCI_INT2,
@@ -38,8 +34,6 @@ enum octeon_irq {
         OCTEON_IRQ_PCI_MSI2,
         OCTEON_IRQ_PCI_MSI3,
 
-        OCTEON_IRQ_TWSI,
-        OCTEON_IRQ_TWSI2,
         OCTEON_IRQ_RML,
         OCTEON_IRQ_TIMER0,
         OCTEON_IRQ_TIMER1,
@@ -47,8 +41,6 @@ enum octeon_irq {
         OCTEON_IRQ_TIMER3,
         OCTEON_IRQ_USB0,
         OCTEON_IRQ_USB1,
-        OCTEON_IRQ_MII0,
-        OCTEON_IRQ_MII1,
         OCTEON_IRQ_BOOTDMA,
 #ifndef CONFIG_PCI_MSI
         OCTEON_IRQ_LAST = 127
diff --git a/arch/mips/include/asm/module.h b/arch/mips/include/asm/module.h
index 7531ecd654d6..dca8bce8c7ab 100644
--- a/arch/mips/include/asm/module.h
+++ b/arch/mips/include/asm/module.h
@@ -10,6 +10,7 @@ struct mod_arch_specific {
         struct list_head dbe_list;
         const struct exception_table_entry *dbe_start;
         const struct exception_table_entry *dbe_end;
+        struct mips_hi16 *r_mips_hi16_list;
 };
 
 typedef uint8_t Elf64_Byte;             /* Type for a 8-bit quantity.  */
diff --git a/arch/mips/include/asm/r4k-timer.h b/arch/mips/include/asm/r4k-timer.h
index a37d12b3b61c..afe9e0e03fe9 100644
--- a/arch/mips/include/asm/r4k-timer.h
+++ b/arch/mips/include/asm/r4k-timer.h
@@ -12,16 +12,16 @@
 
 #ifdef CONFIG_SYNC_R4K
 
-extern void synchronise_count_master(void);
-extern void synchronise_count_slave(void);
+extern void synchronise_count_master(int cpu);
+extern void synchronise_count_slave(int cpu);
 
 #else
 
-static inline void synchronise_count_master(void)
+static inline void synchronise_count_master(int cpu)
 {
 }
 
-static inline void synchronise_count_slave(void)
+static inline void synchronise_count_slave(int cpu)
 {
 }
 
diff --git a/arch/mips/kernel/module.c b/arch/mips/kernel/module.c
index a5066b1c3de3..4f8c3cba8c0c 100644
--- a/arch/mips/kernel/module.c
+++ b/arch/mips/kernel/module.c
@@ -39,8 +39,6 @@ struct mips_hi16 {
         Elf_Addr value;
 };
 
-static struct mips_hi16 *mips_hi16_list;
-
 static LIST_HEAD(dbe_list);
 static DEFINE_SPINLOCK(dbe_lock);
 
@@ -128,8 +126,8 @@ static int apply_r_mips_hi16_rel(struct module *me, u32 *location, Elf_Addr v)
 
         n->addr = (Elf_Addr *)location;
         n->value = v;
-        n->next = mips_hi16_list;
-        mips_hi16_list = n;
+        n->next = me->arch.r_mips_hi16_list;
+        me->arch.r_mips_hi16_list = n;
 
         return 0;
 }
@@ -142,18 +140,28 @@ static int apply_r_mips_hi16_rela(struct module *me, u32 *location, Elf_Addr v)
         return 0;
 }
 
+static void free_relocation_chain(struct mips_hi16 *l)
+{
+        struct mips_hi16 *next;
+
+        while (l) {
+                next = l->next;
+                kfree(l);
+                l = next;
+        }
+}
+
 static int apply_r_mips_lo16_rel(struct module *me, u32 *location, Elf_Addr v)
 {
         unsigned long insnlo = *location;
+        struct mips_hi16 *l;
         Elf_Addr val, vallo;
 
         /* Sign extend the addend we extract from the lo insn.  */
         vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
 
-        if (mips_hi16_list != NULL) {
-                struct mips_hi16 *l;
-
-                l = mips_hi16_list;
+        if (me->arch.r_mips_hi16_list != NULL) {
+                l = me->arch.r_mips_hi16_list;
                 while (l != NULL) {
                         struct mips_hi16 *next;
                         unsigned long insn;
@@ -188,7 +196,7 @@ static int apply_r_mips_lo16_rel(struct module *me, u32 *location, Elf_Addr v)
                         l = next;
                 }
 
-                mips_hi16_list = NULL;
+                me->arch.r_mips_hi16_list = NULL;
         }
 
         /*
@@ -201,6 +209,9 @@ static int apply_r_mips_lo16_rel(struct module *me, u32 *location, Elf_Addr v)
         return 0;
 
 out_danger:
+        free_relocation_chain(l);
+        me->arch.r_mips_hi16_list = NULL;
+
         pr_err("module %s: dangerous R_MIPS_LO16 REL relocation\n", me->name);
 
         return -ENOEXEC;
@@ -273,6 +284,7 @@ int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
         pr_debug("Applying relocate section %u to %u\n", relsec,
                sechdrs[relsec].sh_info);
 
+        me->arch.r_mips_hi16_list = NULL;
         for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
                 /* This is where to make the change */
                 location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
@@ -296,6 +308,19 @@ int apply_relocate(Elf_Shdr *sechdrs, const char *strtab,
                         return res;
         }
 
+        /*
+         * Normally the hi16 list should be deallocated at this point.  A
+         * malformed binary however could contain a series of R_MIPS_HI16
+         * relocations not followed by a R_MIPS_LO16 relocation.  In that
+         * case, free up the list and return an error.
+         */
+        if (me->arch.r_mips_hi16_list) {
+                free_relocation_chain(me->arch.r_mips_hi16_list);
+                me->arch.r_mips_hi16_list = NULL;
+
+                return -ENOEXEC;
+        }
+
         return 0;
 }
 
diff --git a/arch/mips/kernel/smp.c b/arch/mips/kernel/smp.c
index 31637d8c8738..9005bf9fb859 100644
--- a/arch/mips/kernel/smp.c
+++ b/arch/mips/kernel/smp.c
@@ -130,7 +130,7 @@ asmlinkage __cpuinit void start_secondary(void)
 
         cpu_set(cpu, cpu_callin_map);
 
-        synchronise_count_slave();
+        synchronise_count_slave(cpu);
 
         /*
          * irq will be enabled in ->smp_finish(), enabling it too early
@@ -173,7 +173,6 @@ void smp_send_stop(void)
 void __init smp_cpus_done(unsigned int max_cpus)
 {
         mp_ops->cpus_done();
-        synchronise_count_master();
 }
 
 /* called from main before smp_init() */
@@ -206,6 +205,7 @@ int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *tidle)
         while (!cpu_isset(cpu, cpu_callin_map))
                 udelay(100);
 
+        synchronise_count_master(cpu);
         return 0;
 }
 
diff --git a/arch/mips/kernel/sync-r4k.c b/arch/mips/kernel/sync-r4k.c
index 842d55e411fd..7f1eca3858de 100644
--- a/arch/mips/kernel/sync-r4k.c
+++ b/arch/mips/kernel/sync-r4k.c
@@ -28,12 +28,11 @@ static atomic_t __cpuinitdata count_reference = ATOMIC_INIT(0);
 #define COUNTON 100
 #define NR_LOOPS 5
 
-void __cpuinit synchronise_count_master(void)
+void __cpuinit synchronise_count_master(int cpu)
 {
         int i;
         unsigned long flags;
         unsigned int initcount;
-        int nslaves;
 
 #ifdef CONFIG_MIPS_MT_SMTC
         /*
@@ -43,8 +42,7 @@ void __cpuinit synchronise_count_master(void)
         return;
 #endif
 
-        printk(KERN_INFO "Synchronize counters across %u CPUs: ",
-               num_online_cpus());
+        printk(KERN_INFO "Synchronize counters for CPU %u: ", cpu);
 
         local_irq_save(flags);
 
@@ -52,7 +50,7 @@ void __cpuinit synchronise_count_master(void)
          * Notify the slaves that it's time to start
          */
         atomic_set(&count_reference, read_c0_count());
-        atomic_set(&count_start_flag, 1);
+        atomic_set(&count_start_flag, cpu);
         smp_wmb();
 
         /* Count will be initialised to current timer for all CPU's */
@@ -69,10 +67,9 @@ void __cpuinit synchronise_count_master(void)
          * two CPUs.
          */
 
-        nslaves = num_online_cpus()-1;
         for (i = 0; i < NR_LOOPS; i++) {
-                /* slaves loop on '!= ncpus' */
-                while (atomic_read(&count_count_start) != nslaves)
+                /* slaves loop on '!= 2' */
+                while (atomic_read(&count_count_start) != 1)
                         mb();
                 atomic_set(&count_count_stop, 0);
                 smp_wmb();
@@ -89,7 +86,7 @@ void __cpuinit synchronise_count_master(void)
                 /*
                  * Wait for all slaves to leave the synchronization point:
                  */
-                while (atomic_read(&count_count_stop) != nslaves)
+                while (atomic_read(&count_count_stop) != 1)
                         mb();
                 atomic_set(&count_count_start, 0);
                 smp_wmb();
@@ -97,6 +94,7 @@ void __cpuinit synchronise_count_master(void)
         }
         /* Arrange for an interrupt in a short while */
         write_c0_compare(read_c0_count() + COUNTON);
+        atomic_set(&count_start_flag, 0);
 
         local_irq_restore(flags);
 
@@ -108,11 +106,10 @@ void __cpuinit synchronise_count_master(void)
         printk("done.\n");
 }
 
-void __cpuinit synchronise_count_slave(void)
+void __cpuinit synchronise_count_slave(int cpu)
 {
         int i;
         unsigned int initcount;
-        int ncpus;
 
 #ifdef CONFIG_MIPS_MT_SMTC
         /*
@@ -127,16 +124,15 @@ void __cpuinit synchronise_count_slave(void)
          * so we first wait for the master to say everyone is ready
          */
 
-        while (!atomic_read(&count_start_flag))
+        while (atomic_read(&count_start_flag) != cpu)
                 mb();
 
         /* Count will be initialised to next expire for all CPU's */
         initcount = atomic_read(&count_reference);
 
-        ncpus = num_online_cpus();
         for (i = 0; i < NR_LOOPS; i++) {
                 atomic_inc(&count_count_start);
-                while (atomic_read(&count_count_start) != ncpus)
+                while (atomic_read(&count_count_start) != 2)
                         mb();
 
                 /*
@@ -146,7 +142,7 @@ void __cpuinit synchronise_count_slave(void)
                         write_c0_count(initcount);
 
                 atomic_inc(&count_count_stop);
-                while (atomic_read(&count_count_stop) != ncpus)
+                while (atomic_read(&count_count_stop) != 2)
                         mb();
         }
         /* Arrange for an interrupt in a short while */
diff --git a/arch/mips/mti-malta/malta-pci.c b/arch/mips/mti-malta/malta-pci.c
index 284dea54faf5..2147cb34e705 100644
--- a/arch/mips/mti-malta/malta-pci.c
+++ b/arch/mips/mti-malta/malta-pci.c
@@ -252,16 +252,3 @@ void __init mips_pcibios_init(void)
 
         register_pci_controller(controller);
 }
-
-/* Enable PCI 2.1 compatibility in PIIX4 */
-static void __devinit quirk_dlcsetup(struct pci_dev *dev)
-{
-        u8 odlc, ndlc;
-        (void) pci_read_config_byte(dev, 0x82, &odlc);
-        /* Enable passive releases and delayed transaction */
-        ndlc = odlc | 7;
-        (void) pci_write_config_byte(dev, 0x82, ndlc);
-}
-
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_0,
-        quirk_dlcsetup);
diff --git a/arch/mips/pci/pci-ar724x.c b/arch/mips/pci/pci-ar724x.c
index 414a7459858d..86d77a666458 100644
--- a/arch/mips/pci/pci-ar724x.c
+++ b/arch/mips/pci/pci-ar724x.c
@@ -23,9 +23,12 @@
 #define AR724X_PCI_MEM_BASE     0x10000000
 #define AR724X_PCI_MEM_SIZE     0x08000000
 
+#define AR724X_PCI_REG_RESET            0x18
 #define AR724X_PCI_REG_INT_STATUS       0x4c
 #define AR724X_PCI_REG_INT_MASK         0x50
 
+#define AR724X_PCI_RESET_LINK_UP        BIT(0)
+
 #define AR724X_PCI_INT_DEV0             BIT(14)
 
 #define AR724X_PCI_IRQ_COUNT            1
@@ -38,6 +41,15 @@ static void __iomem *ar724x_pci_ctrl_base;
 
 static u32 ar724x_pci_bar0_value;
 static bool ar724x_pci_bar0_is_cached;
+static bool ar724x_pci_link_up;
+
+static inline bool ar724x_pci_check_link(void)
+{
+        u32 reset;
+
+        reset = __raw_readl(ar724x_pci_ctrl_base + AR724X_PCI_REG_RESET);
+        return reset & AR724X_PCI_RESET_LINK_UP;
+}
 
 static int ar724x_pci_read(struct pci_bus *bus, unsigned int devfn, int where,
                             int size, uint32_t *value)
@@ -46,6 +58,9 @@ static int ar724x_pci_read(struct pci_bus *bus, unsigned int devfn, int where,
         void __iomem *base;
         u32 data;
 
+        if (!ar724x_pci_link_up)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
         if (devfn)
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
@@ -96,6 +111,9 @@ static int ar724x_pci_write(struct pci_bus *bus, unsigned int devfn, int where,
         u32 data;
         int s;
 
+        if (!ar724x_pci_link_up)
+                return PCIBIOS_DEVICE_NOT_FOUND;
+
         if (devfn)
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
@@ -280,6 +298,10 @@ int __init ar724x_pcibios_init(int irq)
         if (ar724x_pci_ctrl_base == NULL)
                 goto err_unmap_devcfg;
 
+        ar724x_pci_link_up = ar724x_pci_check_link();
+        if (!ar724x_pci_link_up)
+                pr_warn("ar724x: PCIe link is down\n");
+
         ar724x_pci_irq_init(irq);
         register_pci_controller(&ar724x_pci_controller);
 
diff --git a/arch/parisc/include/asm/atomic.h b/arch/parisc/include/asm/atomic.h
index 6c6defc24619..af9cf30ed474 100644
--- a/arch/parisc/include/asm/atomic.h
+++ b/arch/parisc/include/asm/atomic.h
@@ -141,7 +141,7 @@ static __inline__ int __atomic_add_unless(atomic_t *v, int a, int u)
 
 #define atomic_sub_and_test(i,v)        (atomic_sub_return((i),(v)) == 0)
 
-#define ATOMIC_INIT(i)  ((atomic_t) { (i) })
+#define ATOMIC_INIT(i)  { (i) }
 
 #define smp_mb__before_atomic_dec()     smp_mb()
 #define smp_mb__after_atomic_dec()      smp_mb()
@@ -150,7 +150,7 @@ static __inline__ int __atomic_add_unless(atomic_t *v, int a, int u)
 
 #ifdef CONFIG_64BIT
 
-#define ATOMIC64_INIT(i) ((atomic64_t) { (i) })
+#define ATOMIC64_INIT(i) { (i) }
 
 static __inline__ s64
 __atomic64_add_return(s64 i, atomic64_t *v)
diff --git a/arch/parisc/kernel/process.c b/arch/parisc/kernel/process.c
index d4b94b395c16..2c05a9292a81 100644
--- a/arch/parisc/kernel/process.c
+++ b/arch/parisc/kernel/process.c
@@ -309,7 +309,7 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
                 cregs->ksp = (unsigned long)stack
                         + (pregs->gr[21] & (THREAD_SIZE - 1));
                 cregs->gr[30] = usp;
-                if (p->personality == PER_HPUX) {
+                if (personality(p->personality) == PER_HPUX) {
 #ifdef CONFIG_HPUX
                         cregs->kpc = (unsigned long) &hpux_child_return;
 #else
diff --git a/arch/parisc/kernel/sys_parisc.c b/arch/parisc/kernel/sys_parisc.c
index c9b932260f47..7426e40699bd 100644
--- a/arch/parisc/kernel/sys_parisc.c
+++ b/arch/parisc/kernel/sys_parisc.c
@@ -225,12 +225,12 @@ long parisc_personality(unsigned long personality)
         long err;
 
         if (personality(current->personality) == PER_LINUX32
-            && personality == PER_LINUX)
-                personality = PER_LINUX32;
+            && personality(personality) == PER_LINUX)
+                personality = (personality & ~PER_MASK) | PER_LINUX32;
 
         err = sys_personality(personality);
-        if (err == PER_LINUX32)
-                err = PER_LINUX;
+        if (personality(err) == PER_LINUX32)
+                err = (err & ~PER_MASK) | PER_LINUX;
 
         return err;
 }
diff --git a/arch/powerpc/boot/dts/fsl/p4080si-post.dtsi b/arch/powerpc/boot/dts/fsl/p4080si-post.dtsi
index 8d35d2c1f694..4f9c9f682ecf 100644
--- a/arch/powerpc/boot/dts/fsl/p4080si-post.dtsi
+++ b/arch/powerpc/boot/dts/fsl/p4080si-post.dtsi
@@ -345,6 +345,13 @@
 /include/ "qoriq-duart-1.dtsi"
 /include/ "qoriq-gpio-0.dtsi"
 /include/ "qoriq-usb2-mph-0.dtsi"
+        usb@210000 {
+                compatible = "fsl-usb2-mph-v1.6", "fsl,mpc85xx-usb2-mph", "fsl-usb2-mph";
+                port0;
+        };
 /include/ "qoriq-usb2-dr-0.dtsi"
+        usb@211000 {
+                compatible = "fsl-usb2-dr-v1.6", "fsl,mpc85xx-usb2-dr", "fsl-usb2-dr";
+        };
 /include/ "qoriq-sec4.0-0.dtsi"
 };
diff --git a/arch/powerpc/configs/85xx/p1023rds_defconfig b/arch/powerpc/configs/85xx/p1023rds_defconfig
index f4337bacd0e7..26e541c4662b 100644
--- a/arch/powerpc/configs/85xx/p1023rds_defconfig
+++ b/arch/powerpc/configs/85xx/p1023rds_defconfig
@@ -6,28 +6,27 @@ CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_AUDIT=y
-CONFIG_SPARSE_IRQ=y
+CONFIG_IRQ_DOMAIN_DEBUG=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=14
 CONFIG_BLK_DEV_INITRD=y
-# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_KALLSYMS_ALL=y
-CONFIG_KALLSYMS_EXTRA_PASS=y
 CONFIG_EMBEDDED=y
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 # CONFIG_BLK_DEV_BSG is not set
+CONFIG_PARTITION_ADVANCED=y
+CONFIG_MAC_PARTITION=y
 CONFIG_P1023_RDS=y
 CONFIG_QUICC_ENGINE=y
 CONFIG_QE_GPIO=y
 CONFIG_CPM2=y
-CONFIG_GPIO_MPC8XXX=y
 CONFIG_HIGHMEM=y
-CONFIG_NO_HZ=y
-CONFIG_HIGH_RES_TIMERS=y
 # CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
 CONFIG_BINFMT_MISC=m
 CONFIG_MATH_EMULATION=y
@@ -63,11 +62,11 @@ CONFIG_INET_ESP=y
 CONFIG_IPV6=y
 CONFIG_IP_SCTP=m
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
 CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=131072
-CONFIG_MISC_DEVICES=y
 CONFIG_EEPROM_LEGACY=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_CHR_DEV_ST=y
@@ -80,15 +79,14 @@ CONFIG_SATA_FSL=y
 CONFIG_SATA_SIL24=y
 CONFIG_NETDEVICES=y
 CONFIG_DUMMY=y
+CONFIG_FS_ENET=y
+CONFIG_FSL_PQ_MDIO=y
+CONFIG_E1000E=y
 CONFIG_MARVELL_PHY=y
 CONFIG_DAVICOM_PHY=y
 CONFIG_CICADA_PHY=y
 CONFIG_VITESSE_PHY=y
 CONFIG_FIXED_PHY=y
-CONFIG_NET_ETHERNET=y
-CONFIG_FS_ENET=y
-CONFIG_E1000E=y
-CONFIG_FSL_PQ_MDIO=y
 CONFIG_INPUT_FF_MEMLESS=m
 # CONFIG_INPUT_MOUSEDEV is not set
 # CONFIG_INPUT_KEYBOARD is not set
@@ -98,16 +96,15 @@ CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
 CONFIG_SERIAL_8250_NR_UARTS=2
 CONFIG_SERIAL_8250_RUNTIME_UARTS=2
-CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_DETECT_IRQ=y
 CONFIG_SERIAL_8250_RSA=y
 CONFIG_SERIAL_QE=m
-CONFIG_HW_RANDOM=y
 CONFIG_NVRAM=y
 CONFIG_I2C=y
 CONFIG_I2C_CPM=m
 CONFIG_I2C_MPC=y
+CONFIG_GPIO_MPC8XXX=y
 # CONFIG_HWMON is not set
 CONFIG_VIDEO_OUTPUT_CONTROL=y
 CONFIG_SOUND=y
@@ -123,7 +120,6 @@ CONFIG_DMADEVICES=y
 CONFIG_FSL_DMA=y
 # CONFIG_NET_DMA is not set
 CONFIG_STAGING=y
-# CONFIG_STAGING_EXCLUDE_BUILD is not set
 CONFIG_EXT2_FS=y
 CONFIG_EXT3_FS=y
 # CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
@@ -150,22 +146,15 @@ CONFIG_QNX4FS_FS=m
 CONFIG_SYSV_FS=m
 CONFIG_UFS_FS=m
 CONFIG_NFS_FS=y
-CONFIG_NFS_V3=y
 CONFIG_NFS_V4=y
 CONFIG_ROOT_NFS=y
 CONFIG_NFSD=y
-CONFIG_PARTITION_ADVANCED=y
-CONFIG_MAC_PARTITION=y
 CONFIG_CRC_T10DIF=y
 CONFIG_FRAME_WARN=8092
 CONFIG_DEBUG_FS=y
-CONFIG_DEBUG_KERNEL=y
 CONFIG_DETECT_HUNG_TASK=y
 # CONFIG_DEBUG_BUGVERBOSE is not set
 CONFIG_DEBUG_INFO=y
-# CONFIG_RCU_CPU_STALL_DETECTOR is not set
-CONFIG_SYSCTL_SYSCALL_CHECK=y
-CONFIG_IRQ_DOMAIN_DEBUG=y
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_SHA256=y
 CONFIG_CRYPTO_SHA512=y
diff --git a/arch/powerpc/configs/corenet32_smp_defconfig b/arch/powerpc/configs/corenet32_smp_defconfig
index cbb98c1234fd..8b3d57c1ebe8 100644
--- a/arch/powerpc/configs/corenet32_smp_defconfig
+++ b/arch/powerpc/configs/corenet32_smp_defconfig
@@ -6,8 +6,8 @@ CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_AUDIT=y
-CONFIG_SPARSE_IRQ=y
-CONFIG_RCU_TRACE=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=14
@@ -21,23 +21,22 @@ CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 # CONFIG_BLK_DEV_BSG is not set
+CONFIG_PARTITION_ADVANCED=y
+CONFIG_MAC_PARTITION=y
 CONFIG_P2041_RDB=y
 CONFIG_P3041_DS=y
 CONFIG_P4080_DS=y
 CONFIG_P5020_DS=y
 CONFIG_HIGHMEM=y
-CONFIG_NO_HZ=y
-CONFIG_HIGH_RES_TIMERS=y
 # CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
 CONFIG_BINFMT_MISC=m
 CONFIG_KEXEC=y
 CONFIG_IRQ_ALL_CPUS=y
 CONFIG_FORCE_MAX_ZONEORDER=13
-CONFIG_FSL_LBC=y
 CONFIG_PCI=y
 CONFIG_PCIEPORTBUS=y
-CONFIG_PCI_MSI=y
 # CONFIG_PCIEASPM is not set
+CONFIG_PCI_MSI=y
 CONFIG_RAPIDIO=y
 CONFIG_FSL_RIO=y
 CONFIG_NET=y
@@ -70,6 +69,7 @@ CONFIG_INET_IPCOMP=y
 CONFIG_IPV6=y
 CONFIG_IP_SCTP=m
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
 CONFIG_MTD=y
 CONFIG_MTD_CMDLINE_PARTS=y
 CONFIG_MTD_CHAR=y
@@ -77,17 +77,14 @@ CONFIG_MTD_BLOCK=y
 CONFIG_MTD_CFI=y
 CONFIG_MTD_CFI_AMDSTD=y
 CONFIG_MTD_PHYSMAP_OF=y
+CONFIG_MTD_M25P80=y
 CONFIG_MTD_NAND=y
-CONFIG_MTD_NAND_ECC=y
-CONFIG_MTD_NAND_IDS=y
-CONFIG_MTD_NAND_FSL_IFC=y
 CONFIG_MTD_NAND_FSL_ELBC=y
-CONFIG_MTD_M25P80=y
+CONFIG_MTD_NAND_FSL_IFC=y
 CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=131072
-CONFIG_MISC_DEVICES=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_CHR_DEV_ST=y
 CONFIG_BLK_DEV_SR=y
@@ -115,11 +112,9 @@ CONFIG_SERIO_LIBPS2=y
 CONFIG_PPC_EPAPR_HV_BYTECHAN=y
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
-CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_DETECT_IRQ=y
 CONFIG_SERIAL_8250_RSA=y
-CONFIG_HW_RANDOM=y
 CONFIG_NVRAM=y
 CONFIG_I2C=y
 CONFIG_I2C_CHARDEV=y
@@ -132,7 +127,6 @@ CONFIG_SPI_FSL_ESPI=y
 CONFIG_VIDEO_OUTPUT_CONTROL=y
 CONFIG_USB_HID=m
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_FSL=y
@@ -142,8 +136,6 @@ CONFIG_USB_OHCI_HCD_PPC_OF_LE=y
 CONFIG_USB_STORAGE=y
 CONFIG_MMC=y
 CONFIG_MMC_SDHCI=y
-CONFIG_MMC_SDHCI_OF=y
-CONFIG_MMC_SDHCI_OF_ESDHC=y
 CONFIG_EDAC=y
 CONFIG_EDAC_MM_EDAC=y
 CONFIG_EDAC_MPC85XX=y
@@ -170,19 +162,16 @@ CONFIG_HUGETLBFS=y
 CONFIG_JFFS2_FS=y
 CONFIG_CRAMFS=y
 CONFIG_NFS_FS=y
-CONFIG_NFS_V3=y
 CONFIG_NFS_V4=y
 CONFIG_ROOT_NFS=y
 CONFIG_NFSD=m
-CONFIG_PARTITION_ADVANCED=y
-CONFIG_MAC_PARTITION=y
 CONFIG_NLS_ISO8859_1=y
 CONFIG_NLS_UTF8=m
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_SHIRQ=y
 CONFIG_DETECT_HUNG_TASK=y
 CONFIG_DEBUG_INFO=y
-CONFIG_SYSCTL_SYSCALL_CHECK=y
+CONFIG_RCU_TRACE=y
 CONFIG_CRYPTO_NULL=y
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_MD4=y
diff --git a/arch/powerpc/configs/corenet64_smp_defconfig b/arch/powerpc/configs/corenet64_smp_defconfig
index dd89de8b0b7f..0516e22ca3de 100644
--- a/arch/powerpc/configs/corenet64_smp_defconfig
+++ b/arch/powerpc/configs/corenet64_smp_defconfig
@@ -56,6 +56,7 @@ CONFIG_INET_ESP=y
 CONFIG_IPV6=y
 CONFIG_IP_SCTP=m
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
 CONFIG_MTD=y
 CONFIG_MTD_CMDLINE_PARTS=y
 CONFIG_MTD_CHAR=y
diff --git a/arch/powerpc/configs/g5_defconfig b/arch/powerpc/configs/g5_defconfig
index 15130066e5e2..07b7f2af2dca 100644
--- a/arch/powerpc/configs/g5_defconfig
+++ b/arch/powerpc/configs/g5_defconfig
@@ -1,8 +1,10 @@
+CONFIG_PPC64=y
+CONFIG_ALTIVEC=y
+CONFIG_SMP=y
+CONFIG_NR_CPUS=4
 CONFIG_EXPERIMENTAL=y
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
-CONFIG_NO_HZ=y
-CONFIG_HIGH_RES_TIMERS=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_BLK_DEV_INITRD=y
@@ -13,15 +15,16 @@ CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
-CONFIG_PARTITION_ADVANCED=y
-CONFIG_MAC_PARTITION=y
-CONFIG_SMP=y
-CONFIG_NR_CPUS=4
-CONFIG_KEXEC=y
-# CONFIG_RELOCATABLE is not set
+# CONFIG_PPC_PSERIES is not set
 CONFIG_CPU_FREQ=y
 CONFIG_CPU_FREQ_GOV_POWERSAVE=y
 CONFIG_CPU_FREQ_GOV_USERSPACE=y
+CONFIG_CPU_FREQ_PMAC64=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
+CONFIG_KEXEC=y
+CONFIG_IRQ_ALL_CPUS=y
+# CONFIG_MIGRATION is not set
 CONFIG_PCI_MSI=y
 CONFIG_NET=y
 CONFIG_PACKET=y
@@ -49,6 +52,7 @@ CONFIG_NF_CT_NETLINK=m
 CONFIG_NF_CONNTRACK_IPV4=m
 CONFIG_IP_NF_QUEUE=m
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_RAM=y
@@ -56,6 +60,8 @@ CONFIG_BLK_DEV_RAM_SIZE=65536
 CONFIG_CDROM_PKTCDVD=m
 CONFIG_IDE=y
 CONFIG_BLK_DEV_IDECD=y
+CONFIG_BLK_DEV_IDE_PMAC=y
+CONFIG_BLK_DEV_IDE_PMAC_ATA100FIRST=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_CHR_DEV_ST=y
 CONFIG_BLK_DEV_SR=y
@@ -79,24 +85,33 @@ CONFIG_DM_CRYPT=m
 CONFIG_DM_SNAPSHOT=m
 CONFIG_DM_MIRROR=m
 CONFIG_DM_ZERO=m
-CONFIG_MACINTOSH_DRIVERS=y
+CONFIG_IEEE1394=y
+CONFIG_IEEE1394_OHCI1394=y
+CONFIG_IEEE1394_SBP2=m
+CONFIG_IEEE1394_ETH1394=m
+CONFIG_IEEE1394_RAWIO=y
+CONFIG_IEEE1394_VIDEO1394=m
+CONFIG_IEEE1394_DV1394=m
+CONFIG_ADB_PMU=y
+CONFIG_PMAC_SMU=y
 CONFIG_MAC_EMUMOUSEBTN=y
+CONFIG_THERM_PM72=y
+CONFIG_WINDFARM=y
+CONFIG_WINDFARM_PM81=y
+CONFIG_WINDFARM_PM91=y
+CONFIG_WINDFARM_PM112=y
+CONFIG_WINDFARM_PM121=y
 CONFIG_NETDEVICES=y
-CONFIG_BONDING=m
 CONFIG_DUMMY=m
-CONFIG_MII=y
+CONFIG_BONDING=m
 CONFIG_TUN=m
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=y
+CONFIG_SUNGEM=y
 CONFIG_ACENIC=m
 CONFIG_ACENIC_OMIT_TIGON_I=y
-CONFIG_TIGON3=y
 CONFIG_E1000=y
-CONFIG_SUNGEM=y
-CONFIG_PPP=m
-CONFIG_PPP_BSDCOMP=m
-CONFIG_PPP_DEFLATE=m
-CONFIG_PPPOE=m
-CONFIG_PPP_ASYNC=m
-CONFIG_PPP_SYNC_TTY=m
+CONFIG_TIGON3=y
 CONFIG_USB_CATC=m
 CONFIG_USB_KAWETH=m
 CONFIG_USB_PEGASUS=m
@@ -106,24 +121,36 @@ CONFIG_USB_USBNET=m
 # CONFIG_USB_NET_NET1080 is not set
 # CONFIG_USB_NET_CDC_SUBSET is not set
 # CONFIG_USB_NET_ZAURUS is not set
+CONFIG_PPP=m
+CONFIG_PPP_ASYNC=m
+CONFIG_PPP_SYNC_TTY=m
+CONFIG_PPP_DEFLATE=m
+CONFIG_PPP_BSDCOMP=m
+CONFIG_PPPOE=m
 # CONFIG_INPUT_MOUSEDEV_PSAUX is not set
 CONFIG_INPUT_JOYDEV=m
 CONFIG_INPUT_EVDEV=y
+# CONFIG_KEYBOARD_ATKBD is not set
 # CONFIG_MOUSE_PS2 is not set
+# CONFIG_SERIO_I8042 is not set
 # CONFIG_SERIO_SERPORT is not set
-CONFIG_VT_HW_CONSOLE_BINDING=y
 # CONFIG_HW_RANDOM is not set
 CONFIG_GEN_RTC=y
 CONFIG_RAW_DRIVER=y
 CONFIG_I2C_CHARDEV=y
 # CONFIG_HWMON is not set
-CONFIG_AGP=y
-CONFIG_DRM=y
-CONFIG_DRM_NOUVEAU=y
+CONFIG_AGP=m
+CONFIG_AGP_UNINORTH=m
 CONFIG_VIDEO_OUTPUT_CONTROL=m
+CONFIG_FB=y
 CONFIG_FIRMWARE_EDID=y
 CONFIG_FB_TILEBLITTING=y
+CONFIG_FB_OF=y
+CONFIG_FB_NVIDIA=y
+CONFIG_FB_NVIDIA_I2C=y
 CONFIG_FB_RADEON=y
+# CONFIG_VGA_CONSOLE is not set
+CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_LOGO=y
 CONFIG_SOUND=m
 CONFIG_SND=m
@@ -131,7 +158,15 @@ CONFIG_SND_SEQUENCER=m
 CONFIG_SND_MIXER_OSS=m
 CONFIG_SND_PCM_OSS=m
 CONFIG_SND_SEQUENCER_OSS=y
+CONFIG_SND_POWERMAC=m
+CONFIG_SND_AOA=m
+CONFIG_SND_AOA_FABRIC_LAYOUT=m
+CONFIG_SND_AOA_ONYX=m
+CONFIG_SND_AOA_TAS=m
+CONFIG_SND_AOA_TOONIE=m
 CONFIG_SND_USB_AUDIO=m
+CONFIG_HID_PID=y
+CONFIG_USB_HIDDEV=y
 CONFIG_HID_GYRATION=y
 CONFIG_LOGITECH_FF=y
 CONFIG_HID_PANTHERLORD=y
@@ -139,12 +174,13 @@ CONFIG_HID_PETALYNX=y
 CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
-CONFIG_HID_PID=y
-CONFIG_USB_HIDDEV=y
 CONFIG_USB=y
+CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
+# CONFIG_USB_EHCI_HCD_PPC_OF is not set
 CONFIG_USB_OHCI_HCD=y
+CONFIG_USB_OHCI_HCD_PPC_OF_BE=y
 CONFIG_USB_ACM=m
 CONFIG_USB_PRINTER=y
 CONFIG_USB_STORAGE=y
@@ -208,6 +244,8 @@ CONFIG_REISERFS_FS_POSIX_ACL=y
 CONFIG_REISERFS_FS_SECURITY=y
 CONFIG_XFS_FS=m
 CONFIG_XFS_POSIX_ACL=y
+CONFIG_INOTIFY=y
+CONFIG_AUTOFS_FS=m
 CONFIG_ISO9660_FS=y
 CONFIG_JOLIET=y
 CONFIG_ZISOFS=y
@@ -221,12 +259,14 @@ CONFIG_HFS_FS=m
 CONFIG_HFSPLUS_FS=m
 CONFIG_CRAMFS=y
 CONFIG_NFS_FS=y
+CONFIG_NFS_V3=y
 CONFIG_NFS_V3_ACL=y
 CONFIG_NFS_V4=y
 CONFIG_NFSD=y
 CONFIG_NFSD_V3_ACL=y
 CONFIG_NFSD_V4=y
 CONFIG_CIFS=m
+CONFIG_PARTITION_ADVANCED=y
 CONFIG_NLS_CODEPAGE_437=y
 CONFIG_NLS_CODEPAGE_1250=y
 CONFIG_NLS_CODEPAGE_1251=y
@@ -234,23 +274,29 @@ CONFIG_NLS_ASCII=y
 CONFIG_NLS_ISO8859_1=y
 CONFIG_NLS_ISO8859_15=y
 CONFIG_NLS_UTF8=y
+CONFIG_CRC_T10DIF=y
+CONFIG_LIBCRC32C=m
 CONFIG_MAGIC_SYSRQ=y
-# CONFIG_UNUSED_SYMBOLS is not set
 CONFIG_DEBUG_FS=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_DEBUG_MUTEXES=y
+# CONFIG_RCU_CPU_STALL_DETECTOR is not set
 CONFIG_LATENCYTOP=y
-CONFIG_STRICT_DEVMEM=y
+CONFIG_SYSCTL_SYSCALL_CHECK=y
+CONFIG_BOOTX_TEXT=y
 CONFIG_CRYPTO_NULL=m
 CONFIG_CRYPTO_TEST=m
+CONFIG_CRYPTO_ECB=m
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_HMAC=y
+CONFIG_CRYPTO_MD4=m
 CONFIG_CRYPTO_MICHAEL_MIC=m
 CONFIG_CRYPTO_SHA256=m
 CONFIG_CRYPTO_SHA512=m
 CONFIG_CRYPTO_WP512=m
 CONFIG_CRYPTO_AES=m
 CONFIG_CRYPTO_ANUBIS=m
+CONFIG_CRYPTO_ARC4=m
 CONFIG_CRYPTO_BLOWFISH=m
 CONFIG_CRYPTO_CAST5=m
 CONFIG_CRYPTO_CAST6=m
@@ -260,6 +306,3 @@ CONFIG_CRYPTO_TEA=m
 CONFIG_CRYPTO_TWOFISH=m
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 # CONFIG_CRYPTO_HW is not set
-# CONFIG_VIRTUALIZATION is not set
-CONFIG_CRC_T10DIF=y
-CONFIG_LIBCRC32C=m
diff --git a/arch/powerpc/configs/mpc83xx_defconfig b/arch/powerpc/configs/mpc83xx_defconfig
index 5aac9a8bc53b..9352e4430c3b 100644
--- a/arch/powerpc/configs/mpc83xx_defconfig
+++ b/arch/powerpc/configs/mpc83xx_defconfig
@@ -2,12 +2,12 @@ CONFIG_EXPERIMENTAL=y
 CONFIG_SYSVIPC=y
 CONFIG_LOG_BUF_SHIFT=14
 CONFIG_BLK_DEV_INITRD=y
-# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_EXPERT=y
 CONFIG_SLAB=y
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 # CONFIG_BLK_DEV_BSG is not set
+CONFIG_PARTITION_ADVANCED=y
 # CONFIG_PPC_CHRP is not set
 # CONFIG_PPC_PMAC is not set
 CONFIG_PPC_83xx=y
@@ -25,7 +25,6 @@ CONFIG_ASP834x=y
 CONFIG_QUICC_ENGINE=y
 CONFIG_QE_GPIO=y
 CONFIG_MATH_EMULATION=y
-CONFIG_SPARSE_IRQ=y
 CONFIG_PCI=y
 CONFIG_NET=y
 CONFIG_PACKET=y
@@ -42,10 +41,9 @@ CONFIG_INET_ESP=y
 # CONFIG_INET_LRO is not set
 # CONFIG_IPV6 is not set
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
 # CONFIG_FW_LOADER is not set
 CONFIG_MTD=y
-CONFIG_MTD_PARTITIONS=y
-CONFIG_MTD_OF_PARTS=y
 CONFIG_MTD_CHAR=y
 CONFIG_MTD_BLOCK=y
 CONFIG_MTD_CFI=y
@@ -64,15 +62,14 @@ CONFIG_ATA=y
 CONFIG_SATA_FSL=y
 CONFIG_SATA_SIL=y
 CONFIG_NETDEVICES=y
+CONFIG_MII=y
+CONFIG_UCC_GETH=y
+CONFIG_GIANFAR=y
 CONFIG_MARVELL_PHY=y
 CONFIG_DAVICOM_PHY=y
 CONFIG_VITESSE_PHY=y
 CONFIG_ICPLUS_PHY=y
 CONFIG_FIXED_PHY=y
-CONFIG_NET_ETHERNET=y
-CONFIG_MII=y
-CONFIG_GIANFAR=y
-CONFIG_UCC_GETH=y
 CONFIG_INPUT_FF_MEMLESS=m
 # CONFIG_INPUT_MOUSEDEV is not set
 # CONFIG_INPUT_KEYBOARD is not set
@@ -112,17 +109,12 @@ CONFIG_RTC_DRV_DS1374=y
 CONFIG_EXT2_FS=y
 CONFIG_EXT3_FS=y
 # CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
-CONFIG_INOTIFY=y
 CONFIG_PROC_KCORE=y
 CONFIG_TMPFS=y
 CONFIG_NFS_FS=y
-CONFIG_NFS_V3=y
 CONFIG_NFS_V4=y
 CONFIG_ROOT_NFS=y
-CONFIG_PARTITION_ADVANCED=y
 CONFIG_CRC_T10DIF=y
-# CONFIG_RCU_CPU_STALL_DETECTOR is not set
-CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_CRYPTO_ECB=m
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_SHA256=y
diff --git a/arch/powerpc/configs/mpc85xx_defconfig b/arch/powerpc/configs/mpc85xx_defconfig
index 03ee911c4577..8b5bda27d248 100644
--- a/arch/powerpc/configs/mpc85xx_defconfig
+++ b/arch/powerpc/configs/mpc85xx_defconfig
@@ -5,7 +5,9 @@ CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_AUDIT=y
-CONFIG_SPARSE_IRQ=y
+CONFIG_IRQ_DOMAIN_DEBUG=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=14
@@ -17,6 +19,8 @@ CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 # CONFIG_BLK_DEV_BSG is not set
+CONFIG_PARTITION_ADVANCED=y
+CONFIG_MAC_PARTITION=y
 CONFIG_MPC8540_ADS=y
 CONFIG_MPC8560_ADS=y
 CONFIG_MPC85xx_CDS=y
@@ -40,8 +44,6 @@ CONFIG_SBC8548=y
 CONFIG_QUICC_ENGINE=y
 CONFIG_QE_GPIO=y
 CONFIG_HIGHMEM=y
-CONFIG_NO_HZ=y
-CONFIG_HIGH_RES_TIMERS=y
 CONFIG_BINFMT_MISC=m
 CONFIG_MATH_EMULATION=y
 CONFIG_FORCE_MAX_ZONEORDER=12
@@ -74,36 +76,25 @@ CONFIG_INET_ESP=y
 CONFIG_IPV6=y
 CONFIG_IP_SCTP=m
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
 CONFIG_MTD=y
 CONFIG_MTD_CMDLINE_PARTS=y
 CONFIG_MTD_CHAR=y
 CONFIG_MTD_BLOCK=y
-CONFIG_MTD_CFI=y
 CONFIG_FTL=y
-CONFIG_MTD_GEN_PROBE=y
-CONFIG_MTD_MAP_BANK_WIDTH_1=y
-CONFIG_MTD_MAP_BANK_WIDTH_2=y
-CONFIG_MTD_MAP_BANK_WIDTH_4=y
-CONFIG_MTD_CFI_I1=y
-CONFIG_MTD_CFI_I2=y
+CONFIG_MTD_CFI=y
 CONFIG_MTD_CFI_INTELEXT=y
 CONFIG_MTD_CFI_AMDSTD=y
-CONFIG_MTD_CFI_UTIL=y
 CONFIG_MTD_PHYSMAP_OF=y
-CONFIG_MTD_PARTITIONS=y
-CONFIG_MTD_OF_PARTS=y
+CONFIG_MTD_M25P80=y
 CONFIG_MTD_NAND=y
 CONFIG_MTD_NAND_FSL_ELBC=y
 CONFIG_MTD_NAND_FSL_IFC=y
-CONFIG_MTD_NAND_IDS=y
-CONFIG_MTD_NAND_ECC=y
-CONFIG_MTD_M25P80=y
 CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_NBD=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=131072
-CONFIG_MISC_DEVICES=y
 CONFIG_EEPROM_LEGACY=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_CHR_DEV_ST=y
@@ -115,6 +106,7 @@ CONFIG_ATA=y
 CONFIG_SATA_AHCI=y
 CONFIG_SATA_FSL=y
 CONFIG_PATA_ALI=y
+CONFIG_PATA_VIA=y
 CONFIG_NETDEVICES=y
 CONFIG_DUMMY=y
 CONFIG_FS_ENET=y
@@ -134,7 +126,6 @@ CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
 CONFIG_SERIAL_8250_NR_UARTS=2
 CONFIG_SERIAL_8250_RUNTIME_UARTS=2
-CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_DETECT_IRQ=y
 CONFIG_SERIAL_8250_RSA=y
@@ -183,7 +174,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_FSL=y
@@ -229,18 +219,13 @@ CONFIG_QNX4FS_FS=m
 CONFIG_SYSV_FS=m
 CONFIG_UFS_FS=m
 CONFIG_NFS_FS=y
-CONFIG_NFS_V3=y
 CONFIG_NFS_V4=y
 CONFIG_ROOT_NFS=y
 CONFIG_NFSD=y
-CONFIG_PARTITION_ADVANCED=y
-CONFIG_MAC_PARTITION=y
 CONFIG_CRC_T10DIF=y
 CONFIG_DEBUG_FS=y
 CONFIG_DETECT_HUNG_TASK=y
 CONFIG_DEBUG_INFO=y
-CONFIG_SYSCTL_SYSCALL_CHECK=y
-CONFIG_IRQ_DOMAIN_DEBUG=y
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_SHA256=y
 CONFIG_CRYPTO_SHA512=y
diff --git a/arch/powerpc/configs/mpc85xx_smp_defconfig b/arch/powerpc/configs/mpc85xx_smp_defconfig
index fdfa84dc908f..b0974e7e98ae 100644
--- a/arch/powerpc/configs/mpc85xx_smp_defconfig
+++ b/arch/powerpc/configs/mpc85xx_smp_defconfig
@@ -7,7 +7,9 @@ CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_AUDIT=y
-CONFIG_SPARSE_IRQ=y
+CONFIG_IRQ_DOMAIN_DEBUG=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=14
@@ -19,6 +21,8 @@ CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 # CONFIG_BLK_DEV_BSG is not set
+CONFIG_PARTITION_ADVANCED=y
+CONFIG_MAC_PARTITION=y
 CONFIG_MPC8540_ADS=y
 CONFIG_MPC8560_ADS=y
 CONFIG_MPC85xx_CDS=y
@@ -42,8 +46,6 @@ CONFIG_SBC8548=y
 CONFIG_QUICC_ENGINE=y
 CONFIG_QE_GPIO=y
 CONFIG_HIGHMEM=y
-CONFIG_NO_HZ=y
-CONFIG_HIGH_RES_TIMERS=y
 CONFIG_BINFMT_MISC=m
 CONFIG_MATH_EMULATION=y
 CONFIG_IRQ_ALL_CPUS=y
@@ -77,36 +79,25 @@ CONFIG_INET_ESP=y
 CONFIG_IPV6=y
 CONFIG_IP_SCTP=m
 CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_DEVTMPFS=y
 CONFIG_MTD=y
 CONFIG_MTD_CMDLINE_PARTS=y
 CONFIG_MTD_CHAR=y
 CONFIG_MTD_BLOCK=y
-CONFIG_MTD_CFI=y
 CONFIG_FTL=y
-CONFIG_MTD_GEN_PROBE=y
-CONFIG_MTD_MAP_BANK_WIDTH_1=y
-CONFIG_MTD_MAP_BANK_WIDTH_2=y
-CONFIG_MTD_MAP_BANK_WIDTH_4=y
-CONFIG_MTD_CFI_I1=y
-CONFIG_MTD_CFI_I2=y
+CONFIG_MTD_CFI=y
 CONFIG_MTD_CFI_INTELEXT=y
 CONFIG_MTD_CFI_AMDSTD=y
-CONFIG_MTD_CFI_UTIL=y
 CONFIG_MTD_PHYSMAP_OF=y
-CONFIG_MTD_PARTITIONS=y
-CONFIG_MTD_OF_PARTS=y
+CONFIG_MTD_M25P80=y
 CONFIG_MTD_NAND=y
 CONFIG_MTD_NAND_FSL_ELBC=y
 CONFIG_MTD_NAND_FSL_IFC=y
-CONFIG_MTD_NAND_IDS=y
-CONFIG_MTD_NAND_ECC=y
-CONFIG_MTD_M25P80=y
 CONFIG_PROC_DEVICETREE=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_NBD=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=131072
-CONFIG_MISC_DEVICES=y
 CONFIG_EEPROM_LEGACY=y
 CONFIG_BLK_DEV_SD=y
 CONFIG_CHR_DEV_ST=y
@@ -137,7 +128,6 @@ CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
 CONFIG_SERIAL_8250_NR_UARTS=2
 CONFIG_SERIAL_8250_RUNTIME_UARTS=2
-CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_DETECT_IRQ=y
 CONFIG_SERIAL_8250_RSA=y
@@ -186,7 +176,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_FSL=y
@@ -232,18 +221,13 @@ CONFIG_QNX4FS_FS=m
 CONFIG_SYSV_FS=m
 CONFIG_UFS_FS=m
 CONFIG_NFS_FS=y
-CONFIG_NFS_V3=y
 CONFIG_NFS_V4=y
 CONFIG_ROOT_NFS=y
 CONFIG_NFSD=y
-CONFIG_PARTITION_ADVANCED=y
-CONFIG_MAC_PARTITION=y
 CONFIG_CRC_T10DIF=y
 CONFIG_DEBUG_FS=y
 CONFIG_DETECT_HUNG_TASK=y
 CONFIG_DEBUG_INFO=y
-CONFIG_SYSCTL_SYSCALL_CHECK=y
-CONFIG_IRQ_DOMAIN_DEBUG=y
 CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_SHA256=y
 CONFIG_CRYPTO_SHA512=y
diff --git a/arch/powerpc/include/asm/cputable.h b/arch/powerpc/include/asm/cputable.h
index 50d82c8a037f..b3c083de17ad 100644
--- a/arch/powerpc/include/asm/cputable.h
+++ b/arch/powerpc/include/asm/cputable.h
@@ -553,9 +553,7 @@ static inline int cpu_has_feature(unsigned long feature)
                 & feature);
 }
 
-#ifdef CONFIG_HAVE_HW_BREAKPOINT
 #define HBP_NUM 1
-#endif /* CONFIG_HAVE_HW_BREAKPOINT */
 
 #endif /* !__ASSEMBLY__ */
 
diff --git a/arch/powerpc/include/asm/kvm_host.h b/arch/powerpc/include/asm/kvm_host.h
index 50ea12fd7bf5..a8bf5c673a3c 100644
--- a/arch/powerpc/include/asm/kvm_host.h
+++ b/arch/powerpc/include/asm/kvm_host.h
@@ -33,6 +33,7 @@
 #include <asm/kvm_asm.h>
 #include <asm/processor.h>
 #include <asm/page.h>
+#include <asm/cacheflush.h>
 
 #define KVM_MAX_VCPUS           NR_CPUS
 #define KVM_MAX_VCORES          NR_CPUS
diff --git a/arch/powerpc/include/asm/kvm_ppc.h b/arch/powerpc/include/asm/kvm_ppc.h
index 0124937a23b9..e006f0bdea95 100644
--- a/arch/powerpc/include/asm/kvm_ppc.h
+++ b/arch/powerpc/include/asm/kvm_ppc.h
@@ -219,4 +219,16 @@ void kvmppc_claim_lpid(long lpid);
 void kvmppc_free_lpid(long lpid);
 void kvmppc_init_lpid(unsigned long nr_lpids);
 
+static inline void kvmppc_mmu_flush_icache(pfn_t pfn)
+{
+        /* Clear i-cache for new pages */
+        struct page *page;
+        page = pfn_to_page(pfn);
+        if (!test_bit(PG_arch_1, &page->flags)) {
+                flush_dcache_icache_page(page);
+                set_bit(PG_arch_1, &page->flags);
+        }
+}
+
+
 #endif /* __POWERPC_KVM_PPC_H__ */
diff --git a/arch/powerpc/include/asm/mpic_msgr.h b/arch/powerpc/include/asm/mpic_msgr.h
index 326d33ca55cd..d4f471fb1031 100644
--- a/arch/powerpc/include/asm/mpic_msgr.h
+++ b/arch/powerpc/include/asm/mpic_msgr.h
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 #include <linux/spinlock.h>
 #include <asm/smp.h>
+#include <asm/io.h>
 
 struct mpic_msgr {
         u32 __iomem *base;
diff --git a/arch/powerpc/kernel/dma-iommu.c b/arch/powerpc/kernel/dma-iommu.c
index 2d7bb8ced136..e4897523de41 100644
--- a/arch/powerpc/kernel/dma-iommu.c
+++ b/arch/powerpc/kernel/dma-iommu.c
@@ -83,11 +83,10 @@ static int dma_iommu_dma_supported(struct device *dev, u64 mask)
                 return 0;
         }
 
-        if ((tbl->it_offset + tbl->it_size) > (mask >> IOMMU_PAGE_SHIFT)) {
-                dev_info(dev, "Warning: IOMMU window too big for device mask\n");
-                dev_info(dev, "mask: 0x%08llx, table end: 0x%08lx\n",
-                                mask, (tbl->it_offset + tbl->it_size) <<
-                                IOMMU_PAGE_SHIFT);
+        if (tbl->it_offset > (mask >> IOMMU_PAGE_SHIFT)) {
+                dev_info(dev, "Warning: IOMMU offset too big for device mask\n");
+                dev_info(dev, "mask: 0x%08llx, table offset: 0x%08lx\n",
+                                mask, tbl->it_offset << IOMMU_PAGE_SHIFT);
                 return 0;
         } else
                 return 1;
diff --git a/arch/powerpc/kernel/hw_breakpoint.c b/arch/powerpc/kernel/hw_breakpoint.c
index f3a82dde61db..956a4c496de9 100644
--- a/arch/powerpc/kernel/hw_breakpoint.c
+++ b/arch/powerpc/kernel/hw_breakpoint.c
@@ -253,7 +253,7 @@ int __kprobes hw_breakpoint_handler(struct die_args *args)
 
         /* Do not emulate user-space instructions, instead single-step them */
         if (user_mode(regs)) {
-                bp->ctx->task->thread.last_hit_ubp = bp;
+                current->thread.last_hit_ubp = bp;
                 regs->msr |= MSR_SE;
                 goto out;
         }
diff --git a/arch/powerpc/kernel/kgdb.c b/arch/powerpc/kernel/kgdb.c
index 782bd0a3c2f0..c470a40b29f5 100644
--- a/arch/powerpc/kernel/kgdb.c
+++ b/arch/powerpc/kernel/kgdb.c
@@ -25,6 +25,7 @@
 #include <asm/processor.h>
 #include <asm/machdep.h>
 #include <asm/debug.h>
+#include <linux/slab.h>
 
 /*
  * This table contains the mapping between PowerPC hardware trap types, and
@@ -101,6 +102,21 @@ static int computeSignal(unsigned int tt)
         return SIGHUP;          /* default for things we don't know about */
 }
 
+/**
+ *
+ *      kgdb_skipexception - Bail out of KGDB when we've been triggered.
+ *      @exception: Exception vector number
+ *      @regs: Current &struct pt_regs.
+ *
+ *      On some architectures we need to skip a breakpoint exception when
+ *      it occurs after a breakpoint has been removed.
+ *
+ */
+int kgdb_skipexception(int exception, struct pt_regs *regs)
+{
+        return kgdb_isremovedbreak(regs->nip);
+}
+
 static int kgdb_call_nmi_hook(struct pt_regs *regs)
 {
         kgdb_nmicallback(raw_smp_processor_id(), regs);
@@ -138,6 +154,8 @@ static int kgdb_handle_breakpoint(struct pt_regs *regs)
 static int kgdb_singlestep(struct pt_regs *regs)
 {
         struct thread_info *thread_info, *exception_thread_info;
+        struct thread_info *backup_current_thread_info = \
+                (struct thread_info *)kmalloc(sizeof(struct thread_info), GFP_KERNEL);
 
         if (user_mode(regs))
                 return 0;
@@ -155,13 +173,17 @@ static int kgdb_singlestep(struct pt_regs *regs)
         thread_info = (struct thread_info *)(regs->gpr[1] & ~(THREAD_SIZE-1));
         exception_thread_info = current_thread_info();
 
-        if (thread_info != exception_thread_info)
+        if (thread_info != exception_thread_info) {
+                /* Save the original current_thread_info. */
+                memcpy(backup_current_thread_info, exception_thread_info, sizeof *thread_info);
                 memcpy(exception_thread_info, thread_info, sizeof *thread_info);
+        }
 
         kgdb_handle_exception(0, SIGTRAP, 0, regs);
 
         if (thread_info != exception_thread_info)
-                memcpy(thread_info, exception_thread_info, sizeof *thread_info);
+                /* Restore current_thread_info lastly. */
+                memcpy(exception_thread_info, backup_current_thread_info, sizeof *thread_info);
 
         return 1;
 }
@@ -410,7 +432,6 @@ int kgdb_arch_handle_exception(int vector, int signo, int err_code,
 #else
                         linux_regs->msr |= MSR_SE;
 #endif
-                        kgdb_single_step = 1;
                         atomic_set(&kgdb_cpu_doing_single_step,
                                    raw_smp_processor_id());
                 }
diff --git a/arch/powerpc/kernel/syscalls.c b/arch/powerpc/kernel/syscalls.c
index f2496f2faecc..4e3cc47f26b9 100644
--- a/arch/powerpc/kernel/syscalls.c
+++ b/arch/powerpc/kernel/syscalls.c
@@ -107,11 +107,11 @@ long ppc64_personality(unsigned long personality)
         long ret;
 
         if (personality(current->personality) == PER_LINUX32
-            && personality == PER_LINUX)
-                personality = PER_LINUX32;
+            && personality(personality) == PER_LINUX)
+                personality = (personality & ~PER_MASK) | PER_LINUX32;
         ret = sys_personality(personality);
-        if (ret == PER_LINUX32)
-                ret = PER_LINUX;
+        if (personality(ret) == PER_LINUX32)
+                ret = (ret & ~PER_MASK) | PER_LINUX;
         return ret;
 }
 #endif
diff --git a/arch/powerpc/kvm/book3s_32_mmu_host.c b/arch/powerpc/kvm/book3s_32_mmu_host.c
index f922c29bb234..837f13e7b6bf 100644
--- a/arch/powerpc/kvm/book3s_32_mmu_host.c
+++ b/arch/powerpc/kvm/book3s_32_mmu_host.c
@@ -211,6 +211,9 @@ next_pteg:
                 pteg1 |= PP_RWRX;
         }
 
+        if (orig_pte->may_execute)
+                kvmppc_mmu_flush_icache(hpaddr >> PAGE_SHIFT);
+
         local_irq_disable();
 
         if (pteg[rr]) {
diff --git a/arch/powerpc/kvm/book3s_64_mmu_host.c b/arch/powerpc/kvm/book3s_64_mmu_host.c
index 10fc8ec9d2a8..0688b6b39585 100644
--- a/arch/powerpc/kvm/book3s_64_mmu_host.c
+++ b/arch/powerpc/kvm/book3s_64_mmu_host.c
@@ -126,6 +126,8 @@ int kvmppc_mmu_map_page(struct kvm_vcpu *vcpu, struct kvmppc_pte *orig_pte)
 
         if (!orig_pte->may_execute)
                 rflags |= HPTE_R_N;
+        else
+                kvmppc_mmu_flush_icache(hpaddr >> PAGE_SHIFT);
 
         hash = hpt_hash(va, PTE_SIZE, MMU_SEGSIZE_256M);
 
diff --git a/arch/powerpc/kvm/book3s_hv_rmhandlers.S b/arch/powerpc/kvm/book3s_hv_rmhandlers.S
index 5a84c8d3d040..44b72feaff7d 100644
--- a/arch/powerpc/kvm/book3s_hv_rmhandlers.S
+++ b/arch/powerpc/kvm/book3s_hv_rmhandlers.S
@@ -1421,13 +1421,13 @@ _GLOBAL(kvmppc_h_cede)
         sync                    /* order setting ceded vs. testing prodded */
         lbz     r5,VCPU_PRODDED(r3)
         cmpwi   r5,0
-        bne     1f
+        bne     kvm_cede_prodded
         li      r0,0            /* set trap to 0 to say hcall is handled */
         stw     r0,VCPU_TRAP(r3)
         li      r0,H_SUCCESS
         std     r0,VCPU_GPR(R3)(r3)
 BEGIN_FTR_SECTION
-        b       2f              /* just send it up to host on 970 */
+        b       kvm_cede_exit   /* just send it up to host on 970 */
 END_FTR_SECTION_IFCLR(CPU_FTR_ARCH_206)
 
         /*
@@ -1446,7 +1446,7 @@ END_FTR_SECTION_IFCLR(CPU_FTR_ARCH_206)
         or      r4,r4,r0
         PPC_POPCNTW(R7,R4)
         cmpw    r7,r8
-        bge     2f
+        bge     kvm_cede_exit
         stwcx.  r4,0,r6
         bne     31b
         li      r0,1
@@ -1555,7 +1555,8 @@ kvm_end_cede:
         b       hcall_real_fallback
 
         /* cede when already previously prodded case */
-1:      li      r0,0
+kvm_cede_prodded:
+        li      r0,0
         stb     r0,VCPU_PRODDED(r3)
         sync                    /* order testing prodded vs. clearing ceded */
         stb     r0,VCPU_CEDED(r3)
@@ -1563,7 +1564,8 @@ kvm_end_cede:
         blr
 
         /* we've ceded but we want to give control to the host */
-2:      li      r3,H_TOO_HARD
+kvm_cede_exit:
+        li      r3,H_TOO_HARD
         blr
 
 secondary_too_late:
diff --git a/arch/powerpc/kvm/e500_tlb.c b/arch/powerpc/kvm/e500_tlb.c
index c510fc961302..a2b66717813d 100644
--- a/arch/powerpc/kvm/e500_tlb.c
+++ b/arch/powerpc/kvm/e500_tlb.c
@@ -322,11 +322,11 @@ static inline void kvmppc_e500_ref_release(struct tlbe_ref *ref)
 static void clear_tlb1_bitmap(struct kvmppc_vcpu_e500 *vcpu_e500)
 {
         if (vcpu_e500->g2h_tlb1_map)
-                memset(vcpu_e500->g2h_tlb1_map,
-                       sizeof(u64) * vcpu_e500->gtlb_params[1].entries, 0);
+                memset(vcpu_e500->g2h_tlb1_map, 0,
+                       sizeof(u64) * vcpu_e500->gtlb_params[1].entries);
         if (vcpu_e500->h2g_tlb1_rmap)
-                memset(vcpu_e500->h2g_tlb1_rmap,
-                       sizeof(unsigned int) * host_tlb_params[1].entries, 0);
+                memset(vcpu_e500->h2g_tlb1_rmap, 0,
+                       sizeof(unsigned int) * host_tlb_params[1].entries);
 }
 
 static void clear_tlb_privs(struct kvmppc_vcpu_e500 *vcpu_e500)
@@ -539,6 +539,9 @@ static inline void kvmppc_e500_shadow_map(struct kvmppc_vcpu_e500 *vcpu_e500,
 
         kvmppc_e500_setup_stlbe(&vcpu_e500->vcpu, gtlbe, tsize,
                                 ref, gvaddr, stlbe);
+
+        /* Clear i-cache for new pages */
+        kvmppc_mmu_flush_icache(pfn);
 }
 
 /* XXX only map the one-one case, for now use TLB0 */
diff --git a/arch/powerpc/lib/copyuser_power7.S b/arch/powerpc/lib/copyuser_power7.S
index f9ede7c6606e..0d24ff15f5f6 100644
--- a/arch/powerpc/lib/copyuser_power7.S
+++ b/arch/powerpc/lib/copyuser_power7.S
@@ -288,7 +288,7 @@ err1;	stb	r0,0(r3)
         std     r0,16(r1)
         stdu    r1,-STACKFRAMESIZE(r1)
         bl      .enter_vmx_usercopy
-        cmpwi   r3,0
+        cmpwi   cr1,r3,0
         ld      r0,STACKFRAMESIZE+16(r1)
         ld      r3,STACKFRAMESIZE+48(r1)
         ld      r4,STACKFRAMESIZE+56(r1)
@@ -326,38 +326,7 @@ err1;	stb	r0,0(r3)
         dcbt    r0,r8,0b01010   /* GO */
 .machine pop
 
-        /*
-         * We prefetch both the source and destination using enhanced touch
-         * instructions. We use a stream ID of 0 for the load side and
-         * 1 for the store side.
-         */
-        clrrdi  r6,r4,7
-        clrrdi  r9,r3,7
-        ori     r9,r9,1         /* stream=1 */
-
-        srdi    r7,r5,7         /* length in cachelines, capped at 0x3FF */
-        cmpldi  cr1,r7,0x3FF
-        ble     cr1,1f
-        li      r7,0x3FF
-1:      lis     r0,0x0E00       /* depth=7 */
-        sldi    r7,r7,7
-        or      r7,r7,r0
-        ori     r10,r7,1        /* stream=1 */
-
-        lis     r8,0x8000       /* GO=1 */
-        clrldi  r8,r8,32
-
-.machine push
-.machine "power4"
-        dcbt    r0,r6,0b01000
-        dcbt    r0,r7,0b01010
-        dcbtst  r0,r9,0b01000
-        dcbtst  r0,r10,0b01010
-        eieio
-        dcbt    r0,r8,0b01010   /* GO */
-.machine pop
-
-        beq     .Lunwind_stack_nonvmx_copy
+        beq     cr1,.Lunwind_stack_nonvmx_copy
 
         /*
          * If source and destination are not relatively aligned we use a
diff --git a/arch/powerpc/lib/memcpy_power7.S b/arch/powerpc/lib/memcpy_power7.S
index 0efdc51bc716..7ba6c96de778 100644
--- a/arch/powerpc/lib/memcpy_power7.S
+++ b/arch/powerpc/lib/memcpy_power7.S
@@ -222,7 +222,7 @@ _GLOBAL(memcpy_power7)
         std     r0,16(r1)
         stdu    r1,-STACKFRAMESIZE(r1)
         bl      .enter_vmx_copy
-        cmpwi   r3,0
+        cmpwi   cr1,r3,0
         ld      r0,STACKFRAMESIZE+16(r1)
         ld      r3,STACKFRAMESIZE+48(r1)
         ld      r4,STACKFRAMESIZE+56(r1)
@@ -260,7 +260,7 @@ _GLOBAL(memcpy_power7)
         dcbt    r0,r8,0b01010   /* GO */
 .machine pop
 
-        beq     .Lunwind_stack_nonvmx_copy
+        beq     cr1,.Lunwind_stack_nonvmx_copy
 
         /*
          * If source and destination are not relatively aligned we use a
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index baaafde7d135..fbdad0e3929a 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -469,6 +469,7 @@ void flush_dcache_icache_page(struct page *page)
         __flush_dcache_icache_phys(page_to_pfn(page) << PAGE_SHIFT);
 #endif
 }
+EXPORT_SYMBOL(flush_dcache_icache_page);
 
 void clear_user_page(void *page, unsigned long vaddr, struct page *pg)
 {
diff --git a/arch/powerpc/perf/core-book3s.c b/arch/powerpc/perf/core-book3s.c
index 77b49ddda9d3..7cd2dbd6e4c4 100644
--- a/arch/powerpc/perf/core-book3s.c
+++ b/arch/powerpc/perf/core-book3s.c
@@ -1431,7 +1431,7 @@ static void perf_event_interrupt(struct pt_regs *regs)
                 if (!event->hw.idx || is_limited_pmc(event->hw.idx))
                         continue;
                 val = read_pmc(event->hw.idx);
-                if ((int)val < 0) {
+                if (pmc_overflow(val)) {
                         /* event has overflowed */
                         found = 1;
                         record_and_restart(event, val, regs);
diff --git a/arch/powerpc/sysdev/fsl_pci.c b/arch/powerpc/sysdev/fsl_pci.c
index a7b2a600d0a4..c37f46136321 100644
--- a/arch/powerpc/sysdev/fsl_pci.c
+++ b/arch/powerpc/sysdev/fsl_pci.c
@@ -465,7 +465,7 @@ int __init fsl_add_bridge(struct device_node *dev, int is_primary)
                         iounmap(hose->cfg_data);
                 iounmap(hose->cfg_addr);
                 pcibios_free_controller(hose);
-                return 0;
+                return -ENODEV;
         }
 
         setup_pci_cmd(hose);
@@ -827,6 +827,7 @@ struct device_node *fsl_pci_primary;
 
 void __devinit fsl_pci_init(void)
 {
+        int ret;
         struct device_node *node;
         struct pci_controller *hose;
         dma_addr_t max = 0xffffffff;
@@ -855,10 +856,12 @@ void __devinit fsl_pci_init(void)
                         if (!fsl_pci_primary)
                                 fsl_pci_primary = node;
 
-                        fsl_add_bridge(node, fsl_pci_primary == node);
-                        hose = pci_find_hose_for_OF_device(node);
-                        max = min(max, hose->dma_window_base_cur +
-                                        hose->dma_window_size);
+                        ret = fsl_add_bridge(node, fsl_pci_primary == node);
+                        if (ret == 0) {
+                                hose = pci_find_hose_for_OF_device(node);
+                                max = min(max, hose->dma_window_base_cur +
+                                                hose->dma_window_size);
+                        }
                 }
         }
 
diff --git a/arch/powerpc/sysdev/mpic_msgr.c b/arch/powerpc/sysdev/mpic_msgr.c
index 483d8fa72e8b..e961f8c4a8f0 100644
--- a/arch/powerpc/sysdev/mpic_msgr.c
+++ b/arch/powerpc/sysdev/mpic_msgr.c
@@ -14,6 +14,9 @@
 #include <linux/list.h>
 #include <linux/of_platform.h>
 #include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/slab.h>
 #include <asm/prom.h>
 #include <asm/hw_irq.h>
 #include <asm/ppc-pci.h>
diff --git a/arch/powerpc/xmon/xmon.c b/arch/powerpc/xmon/xmon.c
index eab3492a45c5..9b49c65ee7a4 100644
--- a/arch/powerpc/xmon/xmon.c
+++ b/arch/powerpc/xmon/xmon.c
@@ -17,6 +17,7 @@
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/kallsyms.h>
+#include <linux/kmsg_dump.h>
 #include <linux/cpumask.h>
 #include <linux/export.h>
 #include <linux/sysrq.h>
@@ -894,13 +895,13 @@ cmds(struct pt_regs *excp)
 #endif
                 default:
                         printf("Unrecognized command: ");
-                        do {
+                        do {
                                 if (' ' < cmd && cmd <= '~')
                                         putchar(cmd);
                                 else
                                         printf("\\x%x", cmd);
                                 cmd = inchar();
-                        } while (cmd != '\n'); 
+                        } while (cmd != '\n');
                         printf(" (type ? for help)\n");
                         break;
                 }
@@ -1097,7 +1098,7 @@ static long check_bp_loc(unsigned long addr)
         return 1;
 }
 
-static char *breakpoint_help_string = 
+static char *breakpoint_help_string =
     "Breakpoint command usage:\n"
     "b                show breakpoints\n"
     "b <addr> [cnt]   set breakpoint at given instr addr\n"
@@ -1193,7 +1194,7 @@ bpt_cmds(void)
 
         default:
                 termch = cmd;
-                cmd = skipbl();
+                cmd = skipbl();
                 if (cmd == '?') {
                         printf(breakpoint_help_string);
                         break;
@@ -1359,7 +1360,7 @@ static void xmon_show_stack(unsigned long sp, unsigned long lr,
                                        sp + REGS_OFFSET);
                                 break;
                         }
-                        printf("--- Exception: %lx %s at ", regs.trap,
+                        printf("--- Exception: %lx %s at ", regs.trap,
                                getvecname(TRAP(&regs)));
                         pc = regs.nip;
                         lr = regs.link;
@@ -1623,14 +1624,14 @@ static void super_regs(void)
 
         cmd = skipbl();
         if (cmd == '\n') {
-                unsigned long sp, toc;
+                unsigned long sp, toc;
                 asm("mr %0,1" : "=r" (sp) :);
                 asm("mr %0,2" : "=r" (toc) :);
 
                 printf("msr  = "REG"  sprg0= "REG"\n",
                        mfmsr(), mfspr(SPRN_SPRG0));
                 printf("pvr  = "REG"  sprg1= "REG"\n",
-                       mfspr(SPRN_PVR), mfspr(SPRN_SPRG1)); 
+                       mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
                 printf("dec  = "REG"  sprg2= "REG"\n",
                        mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
                 printf("sp   = "REG"  sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
@@ -1783,7 +1784,7 @@ byterev(unsigned char *val, int size)
 static int brev;
 static int mnoread;
 
-static char *memex_help_string = 
+static char *memex_help_string =
     "Memory examine command usage:\n"
     "m [addr] [flags] examine/change memory\n"
     "  addr is optional.  will start where left off.\n"
@@ -1798,7 +1799,7 @@ static char *memex_help_string =
     "NOTE: flags are saved as defaults\n"
     "";
 
-static char *memex_subcmd_help_string = 
+static char *memex_subcmd_help_string =
     "Memory examine subcommands:\n"
     "  hexval   write this val to current location\n"
     "  'string' write chars from string to this location\n"
@@ -2064,7 +2065,7 @@ prdump(unsigned long adrs, long ndump)
                 nr = mread(adrs, temp, r);
                 adrs += nr;
                 for (m = 0; m < r; ++m) {
-                        if ((m & (sizeof(long) - 1)) == 0 && m > 0)
+                        if ((m & (sizeof(long) - 1)) == 0 && m > 0)
                                 putchar(' ');
                         if (m < nr)
                                 printf("%.2x", temp[m]);
@@ -2072,7 +2073,7 @@ prdump(unsigned long adrs, long ndump)
                                 printf("%s", fault_chars[fault_type]);
                 }
                 for (; m < 16; ++m) {
-                        if ((m & (sizeof(long) - 1)) == 0)
+                        if ((m & (sizeof(long) - 1)) == 0)
                                 putchar(' ');
                         printf("  ");
                 }
@@ -2148,45 +2149,28 @@ print_address(unsigned long addr)
 void
 dump_log_buf(void)
 {
-        const unsigned long size = 128;
-        unsigned long end, addr;
-        unsigned char buf[size + 1];
-
-        addr = 0;
-        buf[size] = '\0';
-
-        if (setjmp(bus_error_jmp) != 0) {
-                printf("Unable to lookup symbol __log_buf!\n");
-                return;
-        }
-
-        catch_memory_errors = 1;
-        sync();
-        addr = kallsyms_lookup_name("__log_buf");
-
-        if (! addr)
-                printf("Symbol __log_buf not found!\n");
-        else {
-                end = addr + (1 << CONFIG_LOG_BUF_SHIFT);
-                while (addr < end) {
-                        if (! mread(addr, buf, size)) {
-                                printf("Can't read memory at address 0x%lx\n", addr);
-                                break;
-                        }
-
-                        printf("%s", buf);
-
-                        if (strlen(buf) < size)
-                                break;
-
-                        addr += size;
-                }
-        }
-
-        sync();
-        /* wait a little while to see if we get a machine check */
-        __delay(200);
-        catch_memory_errors = 0;
+        struct kmsg_dumper dumper = { .active = 1 };
+        unsigned char buf[128];
+        size_t len;
+
+        if (setjmp(bus_error_jmp) != 0) {
+                printf("Error dumping printk buffer!\n");
+                return;
+        }
+
+        catch_memory_errors = 1;
+        sync();
+
+        kmsg_dump_rewind_nolock(&dumper);
+        while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
+                buf[len] = '\0';
+                printf("%s", buf);
+        }
+
+        sync();
+        /* wait a little while to see if we get a machine check */
+        __delay(200);
+        catch_memory_errors = 0;
 }
 
 /*
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 49ebfb62c86a..f5ab543396da 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -123,6 +123,7 @@ config S390
         select GENERIC_TIME_VSYSCALL
         select GENERIC_CLOCKEVENTS
         select KTIME_SCALAR if 32BIT
+        select HAVE_ARCH_SECCOMP_FILTER
 
 config SCHED_OMIT_FRAME_POINTER
         def_bool y
diff --git a/arch/s390/include/asm/elf.h b/arch/s390/include/asm/elf.h
index 32e8449640fa..9b94a160fe7f 100644
--- a/arch/s390/include/asm/elf.h
+++ b/arch/s390/include/asm/elf.h
@@ -180,7 +180,8 @@ extern char elf_platform[];
 #define ELF_PLATFORM (elf_platform)
 
 #ifndef CONFIG_64BIT
-#define SET_PERSONALITY(ex) set_personality(PER_LINUX)
+#define SET_PERSONALITY(ex) \
+        set_personality(PER_LINUX | (current->personality & (~PER_MASK)))
 #else /* CONFIG_64BIT */
 #define SET_PERSONALITY(ex)                                     \
 do {                                                            \
diff --git a/arch/s390/include/asm/posix_types.h b/arch/s390/include/asm/posix_types.h
index 7bcc14e395f0..bf2a2ad2f800 100644
--- a/arch/s390/include/asm/posix_types.h
+++ b/arch/s390/include/asm/posix_types.h
@@ -13,6 +13,7 @@
  */
 
 typedef unsigned long   __kernel_size_t;
+typedef long            __kernel_ssize_t;
 #define __kernel_size_t __kernel_size_t
 
 typedef unsigned short  __kernel_old_dev_t;
@@ -25,7 +26,6 @@ typedef unsigned short  __kernel_mode_t;
 typedef unsigned short  __kernel_ipc_pid_t;
 typedef unsigned short  __kernel_uid_t;
 typedef unsigned short  __kernel_gid_t;
-typedef int             __kernel_ssize_t;
 typedef int             __kernel_ptrdiff_t;
 
 #else /* __s390x__ */
@@ -35,7 +35,6 @@ typedef unsigned int    __kernel_mode_t;
 typedef int             __kernel_ipc_pid_t;
 typedef unsigned int    __kernel_uid_t;
 typedef unsigned int    __kernel_gid_t;
-typedef long            __kernel_ssize_t;
 typedef long            __kernel_ptrdiff_t;
 typedef unsigned long   __kernel_sigset_t;      /* at least 32 bits */
 
diff --git a/arch/s390/include/asm/smp.h b/arch/s390/include/asm/smp.h
index a0a8340daafa..ce26ac3cb162 100644
--- a/arch/s390/include/asm/smp.h
+++ b/arch/s390/include/asm/smp.h
@@ -44,6 +44,7 @@ static inline void smp_call_online_cpu(void (*func)(void *), void *data)
 }
 
 static inline int smp_find_processor_id(int address) { return 0; }
+static inline int smp_store_status(int cpu) { return 0; }
 static inline int smp_vcpu_scheduled(int cpu) { return 1; }
 static inline void smp_yield_cpu(int cpu) { }
 static inline void smp_yield(void) { }
diff --git a/arch/s390/include/asm/sparsemem.h b/arch/s390/include/asm/sparsemem.h
index 0fb34027d3f6..a60d085ddb4d 100644
--- a/arch/s390/include/asm/sparsemem.h
+++ b/arch/s390/include/asm/sparsemem.h
@@ -4,13 +4,11 @@
 #ifdef CONFIG_64BIT
 
 #define SECTION_SIZE_BITS       28
-#define MAX_PHYSADDR_BITS       46
 #define MAX_PHYSMEM_BITS        46
 
 #else
 
 #define SECTION_SIZE_BITS       25
-#define MAX_PHYSADDR_BITS       31
 #define MAX_PHYSMEM_BITS        31
 
 #endif /* CONFIG_64BIT */
diff --git a/arch/s390/include/asm/syscall.h b/arch/s390/include/asm/syscall.h
index fb214dd9b7e0..fe7b99759e12 100644
--- a/arch/s390/include/asm/syscall.h
+++ b/arch/s390/include/asm/syscall.h
@@ -12,6 +12,7 @@
 #ifndef _ASM_SYSCALL_H
 #define _ASM_SYSCALL_H  1
 
+#include <linux/audit.h>
 #include <linux/sched.h>
 #include <linux/err.h>
 #include <asm/ptrace.h>
@@ -87,4 +88,13 @@ static inline void syscall_set_arguments(struct task_struct *task,
                 regs->orig_gpr2 = args[0];
 }
 
+static inline int syscall_get_arch(struct task_struct *task,
+                                   struct pt_regs *regs)
+{
+#ifdef CONFIG_COMPAT
+        if (test_tsk_thread_flag(task, TIF_31BIT))
+                return AUDIT_ARCH_S390;
+#endif
+        return sizeof(long) == 8 ? AUDIT_ARCH_S390X : AUDIT_ARCH_S390;
+}
 #endif  /* _ASM_SYSCALL_H */
diff --git a/arch/s390/kernel/compat_linux.c b/arch/s390/kernel/compat_linux.c
index d1225089a4bb..f606d935f495 100644
--- a/arch/s390/kernel/compat_linux.c
+++ b/arch/s390/kernel/compat_linux.c
@@ -620,7 +620,6 @@ asmlinkage unsigned long old32_mmap(struct mmap_arg_struct_emu31 __user *arg)
                 return -EFAULT;
         if (a.offset & ~PAGE_MASK)
                 return -EINVAL;
-        a.addr = (unsigned long) compat_ptr(a.addr);
         return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd,
                               a.offset >> PAGE_SHIFT);
 }
@@ -631,7 +630,6 @@ asmlinkage long sys32_mmap2(struct mmap_arg_struct_emu31 __user *arg)
 
         if (copy_from_user(&a, arg, sizeof(a)))
                 return -EFAULT;
-        a.addr = (unsigned long) compat_ptr(a.addr);
         return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, a.offset);
 }
 
diff --git a/arch/s390/kernel/compat_wrapper.S b/arch/s390/kernel/compat_wrapper.S
index e835d6d5b7fd..2d82cfcbce5b 100644
--- a/arch/s390/kernel/compat_wrapper.S
+++ b/arch/s390/kernel/compat_wrapper.S
@@ -1635,7 +1635,7 @@ ENTRY(compat_sys_process_vm_readv_wrapper)
         llgfr   %r6,%r6                 # unsigned long
         llgf    %r0,164(%r15)           # unsigned long
         stg     %r0,160(%r15)
-        jg      sys_process_vm_readv
+        jg      compat_sys_process_vm_readv
 
 ENTRY(compat_sys_process_vm_writev_wrapper)
         lgfr    %r2,%r2                 # compat_pid_t
@@ -1645,4 +1645,4 @@ ENTRY(compat_sys_process_vm_writev_wrapper)
         llgfr   %r6,%r6                 # unsigned long
         llgf    %r0,164(%r15)           # unsigned long
         stg     %r0,160(%r15)
-        jg      sys_process_vm_writev
+        jg      compat_sys_process_vm_writev
diff --git a/arch/s390/kernel/ptrace.c b/arch/s390/kernel/ptrace.c
index f4eb37680b91..e4be113fbac6 100644
--- a/arch/s390/kernel/ptrace.c
+++ b/arch/s390/kernel/ptrace.c
@@ -719,7 +719,11 @@ asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
         long ret = 0;
 
         /* Do the secure computing check first. */
-        secure_computing_strict(regs->gprs[2]);
+        if (secure_computing(regs->gprs[2])) {
+                /* seccomp failures shouldn't expose any additional code. */
+                ret = -1;
+                goto out;
+        }
 
         /*
          * The sysc_tracesys code in entry.S stored the system
@@ -745,6 +749,7 @@ asmlinkage long do_syscall_trace_enter(struct pt_regs *regs)
                             regs->gprs[2], regs->orig_gpr2,
                             regs->gprs[3], regs->gprs[4],
                             regs->gprs[5]);
+out:
         return ret ?: regs->gprs[2];
 }
 
diff --git a/arch/s390/kernel/sys_s390.c b/arch/s390/kernel/sys_s390.c
index b4a29eee41b8..d0964d22adb5 100644
--- a/arch/s390/kernel/sys_s390.c
+++ b/arch/s390/kernel/sys_s390.c
@@ -81,11 +81,12 @@ SYSCALL_DEFINE1(s390_personality, unsigned int, personality)
 {
         unsigned int ret;
 
-        if (current->personality == PER_LINUX32 && personality == PER_LINUX)
-                personality = PER_LINUX32;
+        if (personality(current->personality) == PER_LINUX32 &&
+            personality(personality) == PER_LINUX)
+                personality |= PER_LINUX32;
         ret = sys_personality(personality);
-        if (ret == PER_LINUX32)
-                ret = PER_LINUX;
+        if (personality(ret) == PER_LINUX32)
+                ret &= ~PER_LINUX32;
 
         return ret;
 }
diff --git a/arch/sh/drivers/dma/dma-sh.c b/arch/sh/drivers/dma/dma-sh.c
index 4c171f13b0e8..b22565623142 100644
--- a/arch/sh/drivers/dma/dma-sh.c
+++ b/arch/sh/drivers/dma/dma-sh.c
@@ -335,7 +335,7 @@ static int dmae_irq_init(void)
 
         for (n = 0; n < NR_DMAE; n++) {
                 int i = request_irq(get_dma_error_irq(n), dma_err,
-                                    IRQF_SHARED, dmae_name[n], NULL);
+                                    IRQF_SHARED, dmae_name[n], (void *)dmae_name[n]);
                 if (unlikely(i < 0)) {
                         printk(KERN_ERR "%s request_irq fail\n", dmae_name[n]);
                         return i;
diff --git a/arch/sh/include/cpu-sh2a/cpu/sh7269.h b/arch/sh/include/cpu-sh2a/cpu/sh7269.h
index 48d14498e774..2a0ca8780f0d 100644
--- a/arch/sh/include/cpu-sh2a/cpu/sh7269.h
+++ b/arch/sh/include/cpu-sh2a/cpu/sh7269.h
@@ -183,18 +183,30 @@ enum {
         GPIO_FN_DV_DATA1, GPIO_FN_DV_DATA0,
         GPIO_FN_LCD_CLK, GPIO_FN_LCD_EXTCLK,
         GPIO_FN_LCD_VSYNC, GPIO_FN_LCD_HSYNC, GPIO_FN_LCD_DE,
-        GPIO_FN_LCD_DATA23, GPIO_FN_LCD_DATA22,
-        GPIO_FN_LCD_DATA21, GPIO_FN_LCD_DATA20,
-        GPIO_FN_LCD_DATA19, GPIO_FN_LCD_DATA18,
-        GPIO_FN_LCD_DATA17, GPIO_FN_LCD_DATA16,
-        GPIO_FN_LCD_DATA15, GPIO_FN_LCD_DATA14,
-        GPIO_FN_LCD_DATA13, GPIO_FN_LCD_DATA12,
-        GPIO_FN_LCD_DATA11, GPIO_FN_LCD_DATA10,
-        GPIO_FN_LCD_DATA9, GPIO_FN_LCD_DATA8,
-        GPIO_FN_LCD_DATA7, GPIO_FN_LCD_DATA6,
-        GPIO_FN_LCD_DATA5, GPIO_FN_LCD_DATA4,
-        GPIO_FN_LCD_DATA3, GPIO_FN_LCD_DATA2,
-        GPIO_FN_LCD_DATA1, GPIO_FN_LCD_DATA0,
+        GPIO_FN_LCD_DATA23_PG23, GPIO_FN_LCD_DATA22_PG22,
+        GPIO_FN_LCD_DATA21_PG21, GPIO_FN_LCD_DATA20_PG20,
+        GPIO_FN_LCD_DATA19_PG19, GPIO_FN_LCD_DATA18_PG18,
+        GPIO_FN_LCD_DATA17_PG17, GPIO_FN_LCD_DATA16_PG16,
+        GPIO_FN_LCD_DATA15_PG15, GPIO_FN_LCD_DATA14_PG14,
+        GPIO_FN_LCD_DATA13_PG13, GPIO_FN_LCD_DATA12_PG12,
+        GPIO_FN_LCD_DATA11_PG11, GPIO_FN_LCD_DATA10_PG10,
+        GPIO_FN_LCD_DATA9_PG9, GPIO_FN_LCD_DATA8_PG8,
+        GPIO_FN_LCD_DATA7_PG7, GPIO_FN_LCD_DATA6_PG6,
+        GPIO_FN_LCD_DATA5_PG5, GPIO_FN_LCD_DATA4_PG4,
+        GPIO_FN_LCD_DATA3_PG3, GPIO_FN_LCD_DATA2_PG2,
+        GPIO_FN_LCD_DATA1_PG1, GPIO_FN_LCD_DATA0_PG0,
+        GPIO_FN_LCD_DATA23_PJ23, GPIO_FN_LCD_DATA22_PJ22,
+        GPIO_FN_LCD_DATA21_PJ21, GPIO_FN_LCD_DATA20_PJ20,
+        GPIO_FN_LCD_DATA19_PJ19, GPIO_FN_LCD_DATA18_PJ18,
+        GPIO_FN_LCD_DATA17_PJ17, GPIO_FN_LCD_DATA16_PJ16,
+        GPIO_FN_LCD_DATA15_PJ15, GPIO_FN_LCD_DATA14_PJ14,
+        GPIO_FN_LCD_DATA13_PJ13, GPIO_FN_LCD_DATA12_PJ12,
+        GPIO_FN_LCD_DATA11_PJ11, GPIO_FN_LCD_DATA10_PJ10,
+        GPIO_FN_LCD_DATA9_PJ9, GPIO_FN_LCD_DATA8_PJ8,
+        GPIO_FN_LCD_DATA7_PJ7, GPIO_FN_LCD_DATA6_PJ6,
+        GPIO_FN_LCD_DATA5_PJ5, GPIO_FN_LCD_DATA4_PJ4,
+        GPIO_FN_LCD_DATA3_PJ3, GPIO_FN_LCD_DATA2_PJ2,
+        GPIO_FN_LCD_DATA1_PJ1, GPIO_FN_LCD_DATA0_PJ0,
         GPIO_FN_LCD_M_DISP,
 };
 
diff --git a/arch/sh/kernel/cpu/sh2a/pinmux-sh7269.c b/arch/sh/kernel/cpu/sh2a/pinmux-sh7269.c
index f25127c46eca..039e4587dd9b 100644
--- a/arch/sh/kernel/cpu/sh2a/pinmux-sh7269.c
+++ b/arch/sh/kernel/cpu/sh2a/pinmux-sh7269.c
@@ -758,12 +758,22 @@ enum {
         DV_DATA3_MARK, DV_DATA2_MARK, DV_DATA1_MARK, DV_DATA0_MARK,
         LCD_CLK_MARK, LCD_EXTCLK_MARK,
         LCD_VSYNC_MARK, LCD_HSYNC_MARK, LCD_DE_MARK,
-        LCD_DATA23_MARK, LCD_DATA22_MARK, LCD_DATA21_MARK, LCD_DATA20_MARK,
-        LCD_DATA19_MARK, LCD_DATA18_MARK, LCD_DATA17_MARK, LCD_DATA16_MARK,
-        LCD_DATA15_MARK, LCD_DATA14_MARK, LCD_DATA13_MARK, LCD_DATA12_MARK,
-        LCD_DATA11_MARK, LCD_DATA10_MARK, LCD_DATA9_MARK, LCD_DATA8_MARK,
-        LCD_DATA7_MARK, LCD_DATA6_MARK, LCD_DATA5_MARK, LCD_DATA4_MARK,
-        LCD_DATA3_MARK, LCD_DATA2_MARK, LCD_DATA1_MARK, LCD_DATA0_MARK,
+        LCD_DATA23_PG23_MARK, LCD_DATA22_PG22_MARK, LCD_DATA21_PG21_MARK,
+        LCD_DATA20_PG20_MARK, LCD_DATA19_PG19_MARK, LCD_DATA18_PG18_MARK,
+        LCD_DATA17_PG17_MARK, LCD_DATA16_PG16_MARK, LCD_DATA15_PG15_MARK,
+        LCD_DATA14_PG14_MARK, LCD_DATA13_PG13_MARK, LCD_DATA12_PG12_MARK,
+        LCD_DATA11_PG11_MARK, LCD_DATA10_PG10_MARK, LCD_DATA9_PG9_MARK,
+        LCD_DATA8_PG8_MARK, LCD_DATA7_PG7_MARK, LCD_DATA6_PG6_MARK,
+        LCD_DATA5_PG5_MARK, LCD_DATA4_PG4_MARK, LCD_DATA3_PG3_MARK,
+        LCD_DATA2_PG2_MARK, LCD_DATA1_PG1_MARK, LCD_DATA0_PG0_MARK,
+        LCD_DATA23_PJ23_MARK, LCD_DATA22_PJ22_MARK, LCD_DATA21_PJ21_MARK,
+        LCD_DATA20_PJ20_MARK, LCD_DATA19_PJ19_MARK, LCD_DATA18_PJ18_MARK,
+        LCD_DATA17_PJ17_MARK, LCD_DATA16_PJ16_MARK, LCD_DATA15_PJ15_MARK,
+        LCD_DATA14_PJ14_MARK, LCD_DATA13_PJ13_MARK, LCD_DATA12_PJ12_MARK,
+        LCD_DATA11_PJ11_MARK, LCD_DATA10_PJ10_MARK, LCD_DATA9_PJ9_MARK,
+        LCD_DATA8_PJ8_MARK, LCD_DATA7_PJ7_MARK, LCD_DATA6_PJ6_MARK,
+        LCD_DATA5_PJ5_MARK, LCD_DATA4_PJ4_MARK, LCD_DATA3_PJ3_MARK,
+        LCD_DATA2_PJ2_MARK, LCD_DATA1_PJ1_MARK, LCD_DATA0_PJ0_MARK,
         LCD_TCON6_MARK, LCD_TCON5_MARK, LCD_TCON4_MARK,
         LCD_TCON3_MARK, LCD_TCON2_MARK, LCD_TCON1_MARK, LCD_TCON0_MARK,
         LCD_M_DISP_MARK,
@@ -1036,6 +1046,7 @@ static pinmux_enum_t pinmux_data[] = {
 
         PINMUX_DATA(PF1_DATA, PF1MD_000),
         PINMUX_DATA(BACK_MARK, PF1MD_001),
+        PINMUX_DATA(SSL10_MARK, PF1MD_011),
         PINMUX_DATA(TIOC4B_MARK, PF1MD_100),
         PINMUX_DATA(DACK0_MARK, PF1MD_101),
 
@@ -1049,47 +1060,50 @@ static pinmux_enum_t pinmux_data[] = {
         PINMUX_DATA(PG27_DATA, PG27MD_00),
         PINMUX_DATA(LCD_TCON2_MARK, PG27MD_10),
         PINMUX_DATA(LCD_EXTCLK_MARK, PG27MD_11),
+        PINMUX_DATA(LCD_DE_MARK, PG27MD_11),
 
         PINMUX_DATA(PG26_DATA, PG26MD_00),
         PINMUX_DATA(LCD_TCON1_MARK, PG26MD_10),
+        PINMUX_DATA(LCD_HSYNC_MARK, PG26MD_10),
 
         PINMUX_DATA(PG25_DATA, PG25MD_00),
         PINMUX_DATA(LCD_TCON0_MARK, PG25MD_10),
+        PINMUX_DATA(LCD_VSYNC_MARK, PG25MD_10),
 
         PINMUX_DATA(PG24_DATA, PG24MD_00),
         PINMUX_DATA(LCD_CLK_MARK, PG24MD_10),
 
         PINMUX_DATA(PG23_DATA, PG23MD_000),
-        PINMUX_DATA(LCD_DATA23_MARK, PG23MD_010),
+        PINMUX_DATA(LCD_DATA23_PG23_MARK, PG23MD_010),
         PINMUX_DATA(LCD_TCON6_MARK, PG23MD_011),
         PINMUX_DATA(TXD5_MARK, PG23MD_100),
 
         PINMUX_DATA(PG22_DATA, PG22MD_000),
-        PINMUX_DATA(LCD_DATA22_MARK, PG22MD_010),
+        PINMUX_DATA(LCD_DATA22_PG22_MARK, PG22MD_010),
         PINMUX_DATA(LCD_TCON5_MARK, PG22MD_011),
         PINMUX_DATA(RXD5_MARK, PG22MD_100),
 
         PINMUX_DATA(PG21_DATA, PG21MD_000),
         PINMUX_DATA(DV_DATA7_MARK, PG21MD_001),
-        PINMUX_DATA(LCD_DATA21_MARK, PG21MD_010),
+        PINMUX_DATA(LCD_DATA21_PG21_MARK, PG21MD_010),
         PINMUX_DATA(LCD_TCON4_MARK, PG21MD_011),
         PINMUX_DATA(TXD4_MARK, PG21MD_100),
 
         PINMUX_DATA(PG20_DATA, PG20MD_000),
         PINMUX_DATA(DV_DATA6_MARK, PG20MD_001),
-        PINMUX_DATA(LCD_DATA20_MARK, PG21MD_010),
+        PINMUX_DATA(LCD_DATA20_PG20_MARK, PG21MD_010),
         PINMUX_DATA(LCD_TCON3_MARK, PG20MD_011),
         PINMUX_DATA(RXD4_MARK, PG20MD_100),
 
         PINMUX_DATA(PG19_DATA, PG19MD_000),
         PINMUX_DATA(DV_DATA5_MARK, PG19MD_001),
-        PINMUX_DATA(LCD_DATA19_MARK, PG19MD_010),
+        PINMUX_DATA(LCD_DATA19_PG19_MARK, PG19MD_010),
         PINMUX_DATA(SPDIF_OUT_MARK, PG19MD_011),
         PINMUX_DATA(SCK5_MARK, PG19MD_100),
 
         PINMUX_DATA(PG18_DATA, PG18MD_000),
         PINMUX_DATA(DV_DATA4_MARK, PG18MD_001),
-        PINMUX_DATA(LCD_DATA18_MARK, PG18MD_010),
+        PINMUX_DATA(LCD_DATA18_PG18_MARK, PG18MD_010),
         PINMUX_DATA(SPDIF_IN_MARK, PG18MD_011),
         PINMUX_DATA(SCK4_MARK, PG18MD_100),
 
@@ -1097,103 +1111,103 @@ static pinmux_enum_t pinmux_data[] = {
 // we're going with 2 bits
         PINMUX_DATA(PG17_DATA, PG17MD_00),
         PINMUX_DATA(WE3ICIOWRAHDQMUU_MARK, PG17MD_01),
-        PINMUX_DATA(LCD_DATA17_MARK, PG17MD_10),
+        PINMUX_DATA(LCD_DATA17_PG17_MARK, PG17MD_10),
 
 // TODO hardware manual has PG16 3 bits wide in reg picture and 2 bits in description
 // we're going with 2 bits
         PINMUX_DATA(PG16_DATA, PG16MD_00),
         PINMUX_DATA(WE2ICIORDDQMUL_MARK, PG16MD_01),
-        PINMUX_DATA(LCD_DATA16_MARK, PG16MD_10),
+        PINMUX_DATA(LCD_DATA16_PG16_MARK, PG16MD_10),
 
         PINMUX_DATA(PG15_DATA, PG15MD_00),
         PINMUX_DATA(D31_MARK, PG15MD_01),
-        PINMUX_DATA(LCD_DATA15_MARK, PG15MD_10),
+        PINMUX_DATA(LCD_DATA15_PG15_MARK, PG15MD_10),
         PINMUX_DATA(PINT7_PG_MARK, PG15MD_11),
 
         PINMUX_DATA(PG14_DATA, PG14MD_00),
         PINMUX_DATA(D30_MARK, PG14MD_01),
-        PINMUX_DATA(LCD_DATA14_MARK, PG14MD_10),
+        PINMUX_DATA(LCD_DATA14_PG14_MARK, PG14MD_10),
         PINMUX_DATA(PINT6_PG_MARK, PG14MD_11),
 
         PINMUX_DATA(PG13_DATA, PG13MD_00),
         PINMUX_DATA(D29_MARK, PG13MD_01),
-        PINMUX_DATA(LCD_DATA13_MARK, PG13MD_10),
+        PINMUX_DATA(LCD_DATA13_PG13_MARK, PG13MD_10),
         PINMUX_DATA(PINT5_PG_MARK, PG13MD_11),
 
         PINMUX_DATA(PG12_DATA, PG12MD_00),
         PINMUX_DATA(D28_MARK, PG12MD_01),
-        PINMUX_DATA(LCD_DATA12_MARK, PG12MD_10),
+        PINMUX_DATA(LCD_DATA12_PG12_MARK, PG12MD_10),
         PINMUX_DATA(PINT4_PG_MARK, PG12MD_11),
 
         PINMUX_DATA(PG11_DATA, PG11MD_000),
         PINMUX_DATA(D27_MARK, PG11MD_001),
-        PINMUX_DATA(LCD_DATA11_MARK, PG11MD_010),
+        PINMUX_DATA(LCD_DATA11_PG11_MARK, PG11MD_010),
         PINMUX_DATA(PINT3_PG_MARK, PG11MD_011),
         PINMUX_DATA(TIOC3D_MARK, PG11MD_100),
 
         PINMUX_DATA(PG10_DATA, PG10MD_000),
         PINMUX_DATA(D26_MARK, PG10MD_001),
-        PINMUX_DATA(LCD_DATA10_MARK, PG10MD_010),
+        PINMUX_DATA(LCD_DATA10_PG10_MARK, PG10MD_010),
         PINMUX_DATA(PINT2_PG_MARK, PG10MD_011),
         PINMUX_DATA(TIOC3C_MARK, PG10MD_100),
 
         PINMUX_DATA(PG9_DATA, PG9MD_000),
         PINMUX_DATA(D25_MARK, PG9MD_001),
-        PINMUX_DATA(LCD_DATA9_MARK, PG9MD_010),
+        PINMUX_DATA(LCD_DATA9_PG9_MARK, PG9MD_010),
         PINMUX_DATA(PINT1_PG_MARK, PG9MD_011),
         PINMUX_DATA(TIOC3B_MARK, PG9MD_100),
 
         PINMUX_DATA(PG8_DATA, PG8MD_000),
         PINMUX_DATA(D24_MARK, PG8MD_001),
-        PINMUX_DATA(LCD_DATA8_MARK, PG8MD_010),
+        PINMUX_DATA(LCD_DATA8_PG8_MARK, PG8MD_010),
         PINMUX_DATA(PINT0_PG_MARK, PG8MD_011),
         PINMUX_DATA(TIOC3A_MARK, PG8MD_100),
 
         PINMUX_DATA(PG7_DATA, PG7MD_000),
         PINMUX_DATA(D23_MARK, PG7MD_001),
-        PINMUX_DATA(LCD_DATA7_MARK, PG7MD_010),
+        PINMUX_DATA(LCD_DATA7_PG7_MARK, PG7MD_010),
         PINMUX_DATA(IRQ7_PG_MARK, PG7MD_011),
         PINMUX_DATA(TIOC2B_MARK, PG7MD_100),
 
         PINMUX_DATA(PG6_DATA, PG6MD_000),
         PINMUX_DATA(D22_MARK, PG6MD_001),
-        PINMUX_DATA(LCD_DATA6_MARK, PG6MD_010),
+        PINMUX_DATA(LCD_DATA6_PG6_MARK, PG6MD_010),
         PINMUX_DATA(IRQ6_PG_MARK, PG6MD_011),
         PINMUX_DATA(TIOC2A_MARK, PG6MD_100),
 
         PINMUX_DATA(PG5_DATA, PG5MD_000),
         PINMUX_DATA(D21_MARK, PG5MD_001),
-        PINMUX_DATA(LCD_DATA5_MARK, PG5MD_010),
+        PINMUX_DATA(LCD_DATA5_PG5_MARK, PG5MD_010),
         PINMUX_DATA(IRQ5_PG_MARK, PG5MD_011),
         PINMUX_DATA(TIOC1B_MARK, PG5MD_100),
 
         PINMUX_DATA(PG4_DATA, PG4MD_000),
         PINMUX_DATA(D20_MARK, PG4MD_001),
-        PINMUX_DATA(LCD_DATA4_MARK, PG4MD_010),
+        PINMUX_DATA(LCD_DATA4_PG4_MARK, PG4MD_010),
         PINMUX_DATA(IRQ4_PG_MARK, PG4MD_011),
         PINMUX_DATA(TIOC1A_MARK, PG4MD_100),
 
         PINMUX_DATA(PG3_DATA, PG3MD_000),
         PINMUX_DATA(D19_MARK, PG3MD_001),
-        PINMUX_DATA(LCD_DATA3_MARK, PG3MD_010),
+        PINMUX_DATA(LCD_DATA3_PG3_MARK, PG3MD_010),
         PINMUX_DATA(IRQ3_PG_MARK, PG3MD_011),
         PINMUX_DATA(TIOC0D_MARK, PG3MD_100),
 
         PINMUX_DATA(PG2_DATA, PG2MD_000),
         PINMUX_DATA(D18_MARK, PG2MD_001),
-        PINMUX_DATA(LCD_DATA2_MARK, PG2MD_010),
+        PINMUX_DATA(LCD_DATA2_PG2_MARK, PG2MD_010),
         PINMUX_DATA(IRQ2_PG_MARK, PG2MD_011),
         PINMUX_DATA(TIOC0C_MARK, PG2MD_100),
 
         PINMUX_DATA(PG1_DATA, PG1MD_000),
         PINMUX_DATA(D17_MARK, PG1MD_001),
-        PINMUX_DATA(LCD_DATA1_MARK, PG1MD_010),
+        PINMUX_DATA(LCD_DATA1_PG1_MARK, PG1MD_010),
         PINMUX_DATA(IRQ1_PG_MARK, PG1MD_011),
         PINMUX_DATA(TIOC0B_MARK, PG1MD_100),
 
         PINMUX_DATA(PG0_DATA, PG0MD_000),
         PINMUX_DATA(D16_MARK, PG0MD_001),
-        PINMUX_DATA(LCD_DATA0_MARK, PG0MD_010),
+        PINMUX_DATA(LCD_DATA0_PG0_MARK, PG0MD_010),
         PINMUX_DATA(IRQ0_PG_MARK, PG0MD_011),
         PINMUX_DATA(TIOC0A_MARK, PG0MD_100),
 
@@ -1275,14 +1289,14 @@ static pinmux_enum_t pinmux_data[] = {
 
         PINMUX_DATA(PJ23_DATA, PJ23MD_000),
         PINMUX_DATA(DV_DATA23_MARK, PJ23MD_001),
-        PINMUX_DATA(LCD_DATA23_MARK, PJ23MD_010),
+        PINMUX_DATA(LCD_DATA23_PJ23_MARK, PJ23MD_010),
         PINMUX_DATA(LCD_TCON6_MARK, PJ23MD_011),
         PINMUX_DATA(IRQ3_PJ_MARK, PJ23MD_100),
         PINMUX_DATA(CTX1_MARK, PJ23MD_101),
 
         PINMUX_DATA(PJ22_DATA, PJ22MD_000),
         PINMUX_DATA(DV_DATA22_MARK, PJ22MD_001),
-        PINMUX_DATA(LCD_DATA22_MARK, PJ22MD_010),
+        PINMUX_DATA(LCD_DATA22_PJ22_MARK, PJ22MD_010),
         PINMUX_DATA(LCD_TCON5_MARK, PJ22MD_011),
         PINMUX_DATA(IRQ2_PJ_MARK, PJ22MD_100),
         PINMUX_DATA(CRX1_MARK, PJ22MD_101),
@@ -1290,14 +1304,14 @@ static pinmux_enum_t pinmux_data[] = {
 
         PINMUX_DATA(PJ21_DATA, PJ21MD_000),
         PINMUX_DATA(DV_DATA21_MARK, PJ21MD_001),
-        PINMUX_DATA(LCD_DATA21_MARK, PJ21MD_010),
+        PINMUX_DATA(LCD_DATA21_PJ21_MARK, PJ21MD_010),
         PINMUX_DATA(LCD_TCON4_MARK, PJ21MD_011),
         PINMUX_DATA(IRQ1_PJ_MARK, PJ21MD_100),
         PINMUX_DATA(CTX2_MARK, PJ21MD_101),
 
         PINMUX_DATA(PJ20_DATA, PJ20MD_000),
         PINMUX_DATA(DV_DATA20_MARK, PJ20MD_001),
-        PINMUX_DATA(LCD_DATA20_MARK, PJ20MD_010),
+        PINMUX_DATA(LCD_DATA20_PJ20_MARK, PJ20MD_010),
         PINMUX_DATA(LCD_TCON3_MARK, PJ20MD_011),
         PINMUX_DATA(IRQ0_PJ_MARK, PJ20MD_100),
         PINMUX_DATA(CRX2_MARK, PJ20MD_101),
@@ -1305,7 +1319,7 @@ static pinmux_enum_t pinmux_data[] = {
 
         PINMUX_DATA(PJ19_DATA, PJ19MD_000),
         PINMUX_DATA(DV_DATA19_MARK, PJ19MD_001),
-        PINMUX_DATA(LCD_DATA19_MARK, PJ19MD_010),
+        PINMUX_DATA(LCD_DATA19_PJ19_MARK, PJ19MD_010),
         PINMUX_DATA(MISO0_PJ19_MARK, PJ19MD_011),
         PINMUX_DATA(TIOC0D_MARK, PJ19MD_100),
         PINMUX_DATA(SIOFRXD_MARK, PJ19MD_101),
@@ -1313,126 +1327,126 @@ static pinmux_enum_t pinmux_data[] = {
 
         PINMUX_DATA(PJ18_DATA, PJ18MD_000),
         PINMUX_DATA(DV_DATA18_MARK, PJ18MD_001),
-        PINMUX_DATA(LCD_DATA18_MARK, PJ18MD_010),
+        PINMUX_DATA(LCD_DATA18_PJ18_MARK, PJ18MD_010),
         PINMUX_DATA(MOSI0_PJ18_MARK, PJ18MD_011),
         PINMUX_DATA(TIOC0C_MARK, PJ18MD_100),
         PINMUX_DATA(SIOFTXD_MARK, PJ18MD_101),
 
         PINMUX_DATA(PJ17_DATA, PJ17MD_000),
         PINMUX_DATA(DV_DATA17_MARK, PJ17MD_001),
-        PINMUX_DATA(LCD_DATA17_MARK, PJ17MD_010),
+        PINMUX_DATA(LCD_DATA17_PJ17_MARK, PJ17MD_010),
         PINMUX_DATA(SSL00_PJ17_MARK, PJ17MD_011),
         PINMUX_DATA(TIOC0B_MARK, PJ17MD_100),
         PINMUX_DATA(SIOFSYNC_MARK, PJ17MD_101),
 
         PINMUX_DATA(PJ16_DATA, PJ16MD_000),
         PINMUX_DATA(DV_DATA16_MARK, PJ16MD_001),
-        PINMUX_DATA(LCD_DATA16_MARK, PJ16MD_010),
+        PINMUX_DATA(LCD_DATA16_PJ16_MARK, PJ16MD_010),
         PINMUX_DATA(RSPCK0_PJ16_MARK, PJ16MD_011),
         PINMUX_DATA(TIOC0A_MARK, PJ16MD_100),
         PINMUX_DATA(SIOFSCK_MARK, PJ16MD_101),
 
         PINMUX_DATA(PJ15_DATA, PJ15MD_000),
         PINMUX_DATA(DV_DATA15_MARK, PJ15MD_001),
-        PINMUX_DATA(LCD_DATA15_MARK, PJ15MD_010),
+        PINMUX_DATA(LCD_DATA15_PJ15_MARK, PJ15MD_010),
         PINMUX_DATA(PINT7_PJ_MARK, PJ15MD_011),
         PINMUX_DATA(PWM2H_MARK, PJ15MD_100),
         PINMUX_DATA(TXD7_MARK, PJ15MD_101),
 
         PINMUX_DATA(PJ14_DATA, PJ14MD_000),
         PINMUX_DATA(DV_DATA14_MARK, PJ14MD_001),
-        PINMUX_DATA(LCD_DATA14_MARK, PJ14MD_010),
+        PINMUX_DATA(LCD_DATA14_PJ14_MARK, PJ14MD_010),
         PINMUX_DATA(PINT6_PJ_MARK, PJ14MD_011),
         PINMUX_DATA(PWM2G_MARK, PJ14MD_100),
         PINMUX_DATA(TXD6_MARK, PJ14MD_101),
 
         PINMUX_DATA(PJ13_DATA, PJ13MD_000),
         PINMUX_DATA(DV_DATA13_MARK, PJ13MD_001),
-        PINMUX_DATA(LCD_DATA13_MARK, PJ13MD_010),
+        PINMUX_DATA(LCD_DATA13_PJ13_MARK, PJ13MD_010),
         PINMUX_DATA(PINT5_PJ_MARK, PJ13MD_011),
         PINMUX_DATA(PWM2F_MARK, PJ13MD_100),
         PINMUX_DATA(TXD5_MARK, PJ13MD_101),
 
         PINMUX_DATA(PJ12_DATA, PJ12MD_000),
         PINMUX_DATA(DV_DATA12_MARK, PJ12MD_001),
-        PINMUX_DATA(LCD_DATA12_MARK, PJ12MD_010),
+        PINMUX_DATA(LCD_DATA12_PJ12_MARK, PJ12MD_010),
         PINMUX_DATA(PINT4_PJ_MARK, PJ12MD_011),
         PINMUX_DATA(PWM2E_MARK, PJ12MD_100),
         PINMUX_DATA(SCK7_MARK, PJ12MD_101),
 
         PINMUX_DATA(PJ11_DATA, PJ11MD_000),
         PINMUX_DATA(DV_DATA11_MARK, PJ11MD_001),
-        PINMUX_DATA(LCD_DATA11_MARK, PJ11MD_010),
+        PINMUX_DATA(LCD_DATA11_PJ11_MARK, PJ11MD_010),
         PINMUX_DATA(PINT3_PJ_MARK, PJ11MD_011),
         PINMUX_DATA(PWM2D_MARK, PJ11MD_100),
         PINMUX_DATA(SCK6_MARK, PJ11MD_101),
 
         PINMUX_DATA(PJ10_DATA, PJ10MD_000),
         PINMUX_DATA(DV_DATA10_MARK, PJ10MD_001),
-        PINMUX_DATA(LCD_DATA10_MARK, PJ10MD_010),
+        PINMUX_DATA(LCD_DATA10_PJ10_MARK, PJ10MD_010),
         PINMUX_DATA(PINT2_PJ_MARK, PJ10MD_011),
         PINMUX_DATA(PWM2C_MARK, PJ10MD_100),
         PINMUX_DATA(SCK5_MARK, PJ10MD_101),
 
         PINMUX_DATA(PJ9_DATA, PJ9MD_000),
         PINMUX_DATA(DV_DATA9_MARK, PJ9MD_001),
-        PINMUX_DATA(LCD_DATA9_MARK, PJ9MD_010),
+        PINMUX_DATA(LCD_DATA9_PJ9_MARK, PJ9MD_010),
         PINMUX_DATA(PINT1_PJ_MARK, PJ9MD_011),
         PINMUX_DATA(PWM2B_MARK, PJ9MD_100),
         PINMUX_DATA(RTS5_MARK, PJ9MD_101),
 
         PINMUX_DATA(PJ8_DATA, PJ8MD_000),
         PINMUX_DATA(DV_DATA8_MARK, PJ8MD_001),
-        PINMUX_DATA(LCD_DATA8_MARK, PJ8MD_010),
+        PINMUX_DATA(LCD_DATA8_PJ8_MARK, PJ8MD_010),
         PINMUX_DATA(PINT0_PJ_MARK, PJ8MD_011),
         PINMUX_DATA(PWM2A_MARK, PJ8MD_100),
         PINMUX_DATA(CTS5_MARK, PJ8MD_101),
 
         PINMUX_DATA(PJ7_DATA, PJ7MD_000),
         PINMUX_DATA(DV_DATA7_MARK, PJ7MD_001),
-        PINMUX_DATA(LCD_DATA7_MARK, PJ7MD_010),
+        PINMUX_DATA(LCD_DATA7_PJ7_MARK, PJ7MD_010),
         PINMUX_DATA(SD_D2_MARK, PJ7MD_011),
         PINMUX_DATA(PWM1H_MARK, PJ7MD_100),
 
         PINMUX_DATA(PJ6_DATA, PJ6MD_000),
         PINMUX_DATA(DV_DATA6_MARK, PJ6MD_001),
-        PINMUX_DATA(LCD_DATA6_MARK, PJ6MD_010),
+        PINMUX_DATA(LCD_DATA6_PJ6_MARK, PJ6MD_010),
         PINMUX_DATA(SD_D3_MARK, PJ6MD_011),
         PINMUX_DATA(PWM1G_MARK, PJ6MD_100),
 
         PINMUX_DATA(PJ5_DATA, PJ5MD_000),
         PINMUX_DATA(DV_DATA5_MARK, PJ5MD_001),
-        PINMUX_DATA(LCD_DATA5_MARK, PJ5MD_010),
+        PINMUX_DATA(LCD_DATA5_PJ5_MARK, PJ5MD_010),
         PINMUX_DATA(SD_CMD_MARK, PJ5MD_011),
         PINMUX_DATA(PWM1F_MARK, PJ5MD_100),
 
         PINMUX_DATA(PJ4_DATA, PJ4MD_000),
         PINMUX_DATA(DV_DATA4_MARK, PJ4MD_001),
-        PINMUX_DATA(LCD_DATA4_MARK, PJ4MD_010),
+        PINMUX_DATA(LCD_DATA4_PJ4_MARK, PJ4MD_010),
         PINMUX_DATA(SD_CLK_MARK, PJ4MD_011),
         PINMUX_DATA(PWM1E_MARK, PJ4MD_100),
 
         PINMUX_DATA(PJ3_DATA, PJ3MD_000),
         PINMUX_DATA(DV_DATA3_MARK, PJ3MD_001),
-        PINMUX_DATA(LCD_DATA3_MARK, PJ3MD_010),
+        PINMUX_DATA(LCD_DATA3_PJ3_MARK, PJ3MD_010),
         PINMUX_DATA(SD_D0_MARK, PJ3MD_011),
         PINMUX_DATA(PWM1D_MARK, PJ3MD_100),
 
         PINMUX_DATA(PJ2_DATA, PJ2MD_000),
         PINMUX_DATA(DV_DATA2_MARK, PJ2MD_001),
-        PINMUX_DATA(LCD_DATA2_MARK, PJ2MD_010),
+        PINMUX_DATA(LCD_DATA2_PJ2_MARK, PJ2MD_010),
         PINMUX_DATA(SD_D1_MARK, PJ2MD_011),
         PINMUX_DATA(PWM1C_MARK, PJ2MD_100),
 
         PINMUX_DATA(PJ1_DATA, PJ1MD_000),
         PINMUX_DATA(DV_DATA1_MARK, PJ1MD_001),
-        PINMUX_DATA(LCD_DATA1_MARK, PJ1MD_010),
+        PINMUX_DATA(LCD_DATA1_PJ1_MARK, PJ1MD_010),
         PINMUX_DATA(SD_WP_MARK, PJ1MD_011),
         PINMUX_DATA(PWM1B_MARK, PJ1MD_100),
 
         PINMUX_DATA(PJ0_DATA, PJ0MD_000),
         PINMUX_DATA(DV_DATA0_MARK, PJ0MD_001),
-        PINMUX_DATA(LCD_DATA0_MARK, PJ0MD_010),
+        PINMUX_DATA(LCD_DATA0_PJ0_MARK, PJ0MD_010),
         PINMUX_DATA(SD_CD_MARK, PJ0MD_011),
         PINMUX_DATA(PWM1A_MARK, PJ0MD_100),
 };
@@ -1877,30 +1891,55 @@ static struct pinmux_gpio pinmux_gpios[] = {
         PINMUX_GPIO(GPIO_FN_LCD_HSYNC, LCD_HSYNC_MARK),
         PINMUX_GPIO(GPIO_FN_LCD_DE, LCD_DE_MARK),
 
-        PINMUX_GPIO(GPIO_FN_LCD_DATA23, LCD_DATA23_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA22, LCD_DATA22_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA21, LCD_DATA21_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA20, LCD_DATA20_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA19, LCD_DATA19_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA18, LCD_DATA18_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA17, LCD_DATA17_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA16, LCD_DATA16_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA15, LCD_DATA15_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA14, LCD_DATA14_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA13, LCD_DATA13_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA12, LCD_DATA12_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA11, LCD_DATA11_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA10, LCD_DATA10_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA9, LCD_DATA9_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA8, LCD_DATA8_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA7, LCD_DATA7_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA6, LCD_DATA6_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA5, LCD_DATA5_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA4, LCD_DATA4_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA3, LCD_DATA3_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA2, LCD_DATA2_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA1, LCD_DATA1_MARK),
-        PINMUX_GPIO(GPIO_FN_LCD_DATA0, LCD_DATA0_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA23_PG23, LCD_DATA23_PG23_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA22_PG22, LCD_DATA22_PG22_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA21_PG21, LCD_DATA21_PG21_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA20_PG20, LCD_DATA20_PG20_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA19_PG19, LCD_DATA19_PG19_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA18_PG18, LCD_DATA18_PG18_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA17_PG17, LCD_DATA17_PG17_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA16_PG16, LCD_DATA16_PG16_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA15_PG15, LCD_DATA15_PG15_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA14_PG14, LCD_DATA14_PG14_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA13_PG13, LCD_DATA13_PG13_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA12_PG12, LCD_DATA12_PG12_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA11_PG11, LCD_DATA11_PG11_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA10_PG10, LCD_DATA10_PG10_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA9_PG9, LCD_DATA9_PG9_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA8_PG8, LCD_DATA8_PG8_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA7_PG7, LCD_DATA7_PG7_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA6_PG6, LCD_DATA6_PG6_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA5_PG5, LCD_DATA5_PG5_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA4_PG4, LCD_DATA4_PG4_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA3_PG3, LCD_DATA3_PG3_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA2_PG2, LCD_DATA2_PG2_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA1_PG1, LCD_DATA1_PG1_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA0_PG0, LCD_DATA0_PG0_MARK),
+
+        PINMUX_GPIO(GPIO_FN_LCD_DATA23_PJ23, LCD_DATA23_PJ23_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA22_PJ22, LCD_DATA22_PJ22_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA21_PJ21, LCD_DATA21_PJ21_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA20_PJ20, LCD_DATA20_PJ20_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA19_PJ19, LCD_DATA19_PJ19_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA18_PJ18, LCD_DATA18_PJ18_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA17_PJ17, LCD_DATA17_PJ17_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA16_PJ16, LCD_DATA16_PJ16_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA15_PJ15, LCD_DATA15_PJ15_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA14_PJ14, LCD_DATA14_PJ14_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA13_PJ13, LCD_DATA13_PJ13_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA12_PJ12, LCD_DATA12_PJ12_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA11_PJ11, LCD_DATA11_PJ11_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA10_PJ10, LCD_DATA10_PJ10_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA9_PJ9, LCD_DATA9_PJ9_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA8_PJ8, LCD_DATA8_PJ8_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA7_PJ7, LCD_DATA7_PJ7_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA6_PJ6, LCD_DATA6_PJ6_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA5_PJ5, LCD_DATA5_PJ5_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA4_PJ4, LCD_DATA4_PJ4_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA3_PJ3, LCD_DATA3_PJ3_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA2_PJ2, LCD_DATA2_PJ2_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA1_PJ1, LCD_DATA1_PJ1_MARK),
+        PINMUX_GPIO(GPIO_FN_LCD_DATA0_PJ0, LCD_DATA0_PJ0_MARK),
 
         PINMUX_GPIO(GPIO_FN_LCD_M_DISP, LCD_M_DISP_MARK),
 };
diff --git a/arch/sparc/kernel/sys_sparc_64.c b/arch/sparc/kernel/sys_sparc_64.c
index 0dc1f5786081..11c6c9603e71 100644
--- a/arch/sparc/kernel/sys_sparc_64.c
+++ b/arch/sparc/kernel/sys_sparc_64.c
@@ -502,12 +502,12 @@ SYSCALL_DEFINE1(sparc64_personality, unsigned long, personality)
 {
         int ret;
 
-        if (current->personality == PER_LINUX32 &&
-            personality == PER_LINUX)
-                personality = PER_LINUX32;
+        if (personality(current->personality) == PER_LINUX32 &&
+            personality(personality) == PER_LINUX)
+                personality |= PER_LINUX32;
         ret = sys_personality(personality);
-        if (ret == PER_LINUX32)
-                ret = PER_LINUX;
+        if (personality(ret) == PER_LINUX32)
+                ret &= ~PER_LINUX32;
 
         return ret;
 }
diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 6026fdd1b2ed..d58edf5fefdb 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2020,6 +2020,9 @@ EXPORT_SYMBOL(_PAGE_CACHE);
 #ifdef CONFIG_SPARSEMEM_VMEMMAP
 unsigned long vmemmap_table[VMEMMAP_SIZE];
 
+static long __meminitdata addr_start, addr_end;
+static int __meminitdata node_start;
+
 int __meminit vmemmap_populate(struct page *start, unsigned long nr, int node)
 {
         unsigned long vstart = (unsigned long) start;
@@ -2050,15 +2053,30 @@ int __meminit vmemmap_populate(struct page *start, unsigned long nr, int node)
 
                         *vmem_pp = pte_base | __pa(block);
 
-                        printk(KERN_INFO "[%p-%p] page_structs=%lu "
-                               "node=%d entry=%lu/%lu\n", start, block, nr,
-                               node,
-                               addr >> VMEMMAP_CHUNK_SHIFT,
-                               VMEMMAP_SIZE);
+                        /* check to see if we have contiguous blocks */
+                        if (addr_end != addr || node_start != node) {
+                                if (addr_start)
+                                        printk(KERN_DEBUG " [%lx-%lx] on node %d\n",
+                                               addr_start, addr_end-1, node_start);
+                                addr_start = addr;
+                                node_start = node;
+                        }
+                        addr_end = addr + VMEMMAP_CHUNK;
                 }
         }
         return 0;
 }
+
+void __meminit vmemmap_populate_print_last(void)
+{
+        if (addr_start) {
+                printk(KERN_DEBUG " [%lx-%lx] on node %d\n",
+                       addr_start, addr_end-1, node_start);
+                addr_start = 0;
+                addr_end = 0;
+                node_start = 0;
+        }
+}
 #endif /* CONFIG_SPARSEMEM_VMEMMAP */
 
 static void prot_init_common(unsigned long page_none,
diff --git a/arch/x86/Makefile b/arch/x86/Makefile
index b0c5276861ec..682e9c210baa 100644
--- a/arch/x86/Makefile
+++ b/arch/x86/Makefile
@@ -27,6 +27,10 @@ ifeq ($(CONFIG_X86_32),y)
 
         KBUILD_CFLAGS += -msoft-float -mregparm=3 -freg-struct-return
 
+        # Never want PIC in a 32-bit kernel, prevent breakage with GCC built
+        # with nonstandard options
+        KBUILD_CFLAGS += -fno-pic
+
         # prevent gcc from keeping the stack 16 byte aligned
         KBUILD_CFLAGS += $(call cc-option,-mpreferred-stack-boundary=2)
 
diff --git a/arch/x86/boot/Makefile b/arch/x86/boot/Makefile
index 5a747dd884db..f7535bedc33f 100644
--- a/arch/x86/boot/Makefile
+++ b/arch/x86/boot/Makefile
@@ -57,7 +57,7 @@ KBUILD_CFLAGS	:= $(LINUXINCLUDE) -g -Os -D_SETUP -D__KERNEL__ \
                    -Wall -Wstrict-prototypes \
                    -march=i386 -mregparm=3 \
                    -include $(srctree)/$(src)/code16gcc.h \
-                   -fno-strict-aliasing -fomit-frame-pointer \
+                   -fno-strict-aliasing -fomit-frame-pointer -fno-pic \
                    $(call cc-option, -ffreestanding) \
                    $(call cc-option, -fno-toplevel-reorder,\
                         $(call cc-option, -fno-unit-at-a-time)) \
diff --git a/arch/x86/include/asm/spinlock.h b/arch/x86/include/asm/spinlock.h
index b315a33867f2..33692eaabab5 100644
--- a/arch/x86/include/asm/spinlock.h
+++ b/arch/x86/include/asm/spinlock.h
@@ -12,8 +12,7 @@
  * Simple spin lock operations.  There are two variants, one clears IRQ's
  * on the local processor, one does not.
  *
- * These are fair FIFO ticket locks, which are currently limited to 256
- * CPUs.
+ * These are fair FIFO ticket locks, which support up to 2^16 CPUs.
  *
  * (the type definitions are in asm/spinlock_types.h)
  */
diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c
index afb7ff79a29f..ced4534baed5 100644
--- a/arch/x86/kernel/alternative.c
+++ b/arch/x86/kernel/alternative.c
@@ -165,7 +165,7 @@ static const unsigned char * const k7_nops[ASM_NOP_MAX+2] =
 #endif
 
 #ifdef P6_NOP1
-static const unsigned char  __initconst_or_module p6nops[] =
+static const unsigned char p6nops[] =
 {
         P6_NOP1,
         P6_NOP2,
diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
index a6c64aaddf9a..c265593ec2cd 100644
--- a/arch/x86/kernel/apic/io_apic.c
+++ b/arch/x86/kernel/apic/io_apic.c
@@ -1356,6 +1356,16 @@ static void setup_ioapic_irq(unsigned int irq, struct irq_cfg *cfg,
         if (!IO_APIC_IRQ(irq))
                 return;
 
+        /*
+         * For legacy irqs, cfg->domain starts with cpu 0. Now that IO-APIC
+         * can handle this irq and the apic driver is finialized at this point,
+         * update the cfg->domain.
+         */
+        if (irq < legacy_pic->nr_legacy_irqs &&
+            cpumask_equal(cfg->domain, cpumask_of(0)))
+                apic->vector_allocation_domain(0, cfg->domain,
+                                               apic->target_cpus());
+
         if (assign_irq_vector(irq, cfg, apic->target_cpus()))
                 return;
 
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index 46d8786d655e..a5fbc3c5fccc 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -144,6 +144,8 @@ static int __init x86_xsave_setup(char *s)
 {
         setup_clear_cpu_cap(X86_FEATURE_XSAVE);
         setup_clear_cpu_cap(X86_FEATURE_XSAVEOPT);
+        setup_clear_cpu_cap(X86_FEATURE_AVX);
+        setup_clear_cpu_cap(X86_FEATURE_AVX2);
         return 1;
 }
 __setup("noxsave", x86_xsave_setup);
diff --git a/arch/x86/kernel/cpu/perf_event_intel.c b/arch/x86/kernel/cpu/perf_event_intel.c
index 382366977d4c..7f2739e03e79 100644
--- a/arch/x86/kernel/cpu/perf_event_intel.c
+++ b/arch/x86/kernel/cpu/perf_event_intel.c
@@ -1522,8 +1522,16 @@ static struct perf_guest_switch_msr *intel_guest_get_msrs(int *nr)
         arr[0].msr = MSR_CORE_PERF_GLOBAL_CTRL;
         arr[0].host = x86_pmu.intel_ctrl & ~cpuc->intel_ctrl_guest_mask;
         arr[0].guest = x86_pmu.intel_ctrl & ~cpuc->intel_ctrl_host_mask;
+        /*
+         * If PMU counter has PEBS enabled it is not enough to disable counter
+         * on a guest entry since PEBS memory write can overshoot guest entry
+         * and corrupt guest memory. Disabling PEBS solves the problem.
+         */
+        arr[1].msr = MSR_IA32_PEBS_ENABLE;
+        arr[1].host = cpuc->pebs_enabled;
+        arr[1].guest = 0;
 
-        *nr = 1;
+        *nr = 2;
         return arr;
 }
 
diff --git a/arch/x86/kernel/cpu/perf_event_intel_uncore.c b/arch/x86/kernel/cpu/perf_event_intel_uncore.c
index 7563fda9f033..0a5571080e74 100644
--- a/arch/x86/kernel/cpu/perf_event_intel_uncore.c
+++ b/arch/x86/kernel/cpu/perf_event_intel_uncore.c
@@ -796,7 +796,6 @@ static struct intel_uncore_type *nhm_msr_uncores[] = {
 
 DEFINE_UNCORE_FORMAT_ATTR(event5, event, "config:1-5");
 DEFINE_UNCORE_FORMAT_ATTR(counter, counter, "config:6-7");
-DEFINE_UNCORE_FORMAT_ATTR(mm_cfg, mm_cfg, "config:63");
 DEFINE_UNCORE_FORMAT_ATTR(match, match, "config1:0-63");
 DEFINE_UNCORE_FORMAT_ATTR(mask, mask, "config2:0-63");
 
@@ -902,16 +901,21 @@ static struct attribute_group nhmex_uncore_cbox_format_group = {
         .attrs = nhmex_uncore_cbox_formats_attr,
 };
 
+/* msr offset for each instance of cbox */
+static unsigned nhmex_cbox_msr_offsets[] = {
+        0x0, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x240, 0x2c0,
+};
+
 static struct intel_uncore_type nhmex_uncore_cbox = {
         .name                   = "cbox",
         .num_counters           = 6,
-        .num_boxes              = 8,
+        .num_boxes              = 10,
         .perf_ctr_bits          = 48,
         .event_ctl              = NHMEX_C0_MSR_PMON_EV_SEL0,
         .perf_ctr               = NHMEX_C0_MSR_PMON_CTR0,
         .event_mask             = NHMEX_PMON_RAW_EVENT_MASK,
         .box_ctl                = NHMEX_C0_MSR_PMON_GLOBAL_CTL,
-        .msr_offset             = NHMEX_C_MSR_OFFSET,
+        .msr_offsets            = nhmex_cbox_msr_offsets,
         .pair_ctr_ctl           = 1,
         .ops                    = &nhmex_uncore_ops,
         .format_group           = &nhmex_uncore_cbox_format_group
@@ -1032,24 +1036,22 @@ static struct intel_uncore_type nhmex_uncore_bbox = {
 
 static int nhmex_sbox_hw_config(struct intel_uncore_box *box, struct perf_event *event)
 {
-        struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
-        struct hw_perf_event_extra *reg2 = &event->hw.branch_reg;
+        struct hw_perf_event *hwc = &event->hw;
+        struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
+        struct hw_perf_event_extra *reg2 = &hwc->branch_reg;
 
-        if (event->attr.config & NHMEX_S_PMON_MM_CFG_EN) {
-                reg1->config = event->attr.config1;
-                reg2->config = event->attr.config2;
-        } else {
-                reg1->config = ~0ULL;
-                reg2->config = ~0ULL;
-        }
+        /* only TO_R_PROG_EV event uses the match/mask register */
+        if ((hwc->config & NHMEX_PMON_CTL_EV_SEL_MASK) !=
+            NHMEX_S_EVENT_TO_R_PROG_EV)
+                return 0;
 
         if (box->pmu->pmu_idx == 0)
                 reg1->reg = NHMEX_S0_MSR_MM_CFG;
         else
                 reg1->reg = NHMEX_S1_MSR_MM_CFG;
-
         reg1->idx = 0;
-
+        reg1->config = event->attr.config1;
+        reg2->config = event->attr.config2;
         return 0;
 }
 
@@ -1059,8 +1061,8 @@ static void nhmex_sbox_msr_enable_event(struct intel_uncore_box *box, struct per
         struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
         struct hw_perf_event_extra *reg2 = &hwc->branch_reg;
 
-        wrmsrl(reg1->reg, 0);
-        if (reg1->config != ~0ULL || reg2->config != ~0ULL) {
+        if (reg1->idx != EXTRA_REG_NONE) {
+                wrmsrl(reg1->reg, 0);
                 wrmsrl(reg1->reg + 1, reg1->config);
                 wrmsrl(reg1->reg + 2, reg2->config);
                 wrmsrl(reg1->reg, NHMEX_S_PMON_MM_CFG_EN);
@@ -1074,7 +1076,6 @@ static struct attribute *nhmex_uncore_sbox_formats_attr[] = {
         &format_attr_edge.attr,
         &format_attr_inv.attr,
         &format_attr_thresh8.attr,
-        &format_attr_mm_cfg.attr,
         &format_attr_match.attr,
         &format_attr_mask.attr,
         NULL,
@@ -1142,6 +1143,9 @@ static struct extra_reg nhmex_uncore_mbox_extra_regs[] = {
         EVENT_EXTRA_END
 };
 
+/* Nehalem-EX or Westmere-EX ? */
+bool uncore_nhmex;
+
 static bool nhmex_mbox_get_shared_reg(struct intel_uncore_box *box, int idx, u64 config)
 {
         struct intel_uncore_extra_reg *er;
@@ -1171,18 +1175,29 @@ static bool nhmex_mbox_get_shared_reg(struct intel_uncore_box *box, int idx, u64
                 return false;
 
         /* mask of the shared fields */
-        mask = NHMEX_M_PMON_ZDP_CTL_FVC_MASK;
+        if (uncore_nhmex)
+                mask = NHMEX_M_PMON_ZDP_CTL_FVC_MASK;
+        else
+                mask = WSMEX_M_PMON_ZDP_CTL_FVC_MASK;
         er = &box->shared_regs[EXTRA_REG_NHMEX_M_ZDP_CTL_FVC];
 
         raw_spin_lock_irqsave(&er->lock, flags);
         /* add mask of the non-shared field if it's in use */
-        if (__BITS_VALUE(atomic_read(&er->ref), idx, 8))
-                mask |= NHMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
+        if (__BITS_VALUE(atomic_read(&er->ref), idx, 8)) {
+                if (uncore_nhmex)
+                        mask |= NHMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
+                else
+                        mask |= WSMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
+        }
 
         if (!atomic_read(&er->ref) || !((er->config ^ config) & mask)) {
                 atomic_add(1 << (idx * 8), &er->ref);
-                mask = NHMEX_M_PMON_ZDP_CTL_FVC_MASK |
-                        NHMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
+                if (uncore_nhmex)
+                        mask = NHMEX_M_PMON_ZDP_CTL_FVC_MASK |
+                                NHMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
+                else
+                        mask = WSMEX_M_PMON_ZDP_CTL_FVC_MASK |
+                                WSMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
                 er->config &= ~mask;
                 er->config |= (config & mask);
                 ret = true;
@@ -1216,7 +1231,10 @@ u64 nhmex_mbox_alter_er(struct perf_event *event, int new_idx, bool modify)
 
         /* get the non-shared control bits and shift them */
         idx = orig_idx - EXTRA_REG_NHMEX_M_ZDP_CTL_FVC;
-        config &= NHMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
+        if (uncore_nhmex)
+                config &= NHMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
+        else
+                config &= WSMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(idx);
         if (new_idx > orig_idx) {
                 idx = new_idx - orig_idx;
                 config <<= 3 * idx;
@@ -1226,6 +1244,10 @@ u64 nhmex_mbox_alter_er(struct perf_event *event, int new_idx, bool modify)
         }
 
         /* add the shared control bits back */
+        if (uncore_nhmex)
+                config |= NHMEX_M_PMON_ZDP_CTL_FVC_MASK & reg1->config;
+        else
+                config |= WSMEX_M_PMON_ZDP_CTL_FVC_MASK & reg1->config;
         config |= NHMEX_M_PMON_ZDP_CTL_FVC_MASK & reg1->config;
         if (modify) {
                 /* adjust the main event selector */
@@ -1264,7 +1286,8 @@ again:
         }
 
         /* for the match/mask registers */
-        if ((uncore_box_is_fake(box) || !reg2->alloc) &&
+        if (reg2->idx != EXTRA_REG_NONE &&
+            (uncore_box_is_fake(box) || !reg2->alloc) &&
             !nhmex_mbox_get_shared_reg(box, reg2->idx, reg2->config))
                 goto fail;
 
@@ -1278,7 +1301,8 @@ again:
                 if (idx[0] != 0xff && idx[0] != __BITS_VALUE(reg1->idx, 0, 8))
                         nhmex_mbox_alter_er(event, idx[0], true);
                 reg1->alloc |= alloc;
-                reg2->alloc = 1;
+                if (reg2->idx != EXTRA_REG_NONE)
+                        reg2->alloc = 1;
         }
         return NULL;
 fail:
@@ -1342,9 +1366,6 @@ static int nhmex_mbox_hw_config(struct intel_uncore_box *box, struct perf_event
         struct extra_reg *er;
         unsigned msr;
         int reg_idx = 0;
-
-        if (WARN_ON_ONCE(reg1->idx != -1))
-                return -EINVAL;
         /*
          * The mbox events may require 2 extra MSRs at the most. But only
          * the lower 32 bits in these MSRs are significant, so we can use
@@ -1355,11 +1376,6 @@ static int nhmex_mbox_hw_config(struct intel_uncore_box *box, struct perf_event
                         continue;
                 if (event->attr.config1 & ~er->valid_mask)
                         return -EINVAL;
-                if (er->idx == __BITS_VALUE(reg1->idx, 0, 8) ||
-                    er->idx == __BITS_VALUE(reg1->idx, 1, 8))
-                        continue;
-                if (WARN_ON_ONCE(reg_idx >= 2))
-                        return -EINVAL;
 
                 msr = er->msr + type->msr_offset * box->pmu->pmu_idx;
                 if (WARN_ON_ONCE(msr >= 0xffff || er->idx >= 0xff))
@@ -1368,6 +1384,8 @@ static int nhmex_mbox_hw_config(struct intel_uncore_box *box, struct perf_event
                 /* always use the 32~63 bits to pass the PLD config */
                 if (er->idx == EXTRA_REG_NHMEX_M_PLD)
                         reg_idx = 1;
+                else if (WARN_ON_ONCE(reg_idx > 0))
+                        return -EINVAL;
 
                 reg1->idx &= ~(0xff << (reg_idx * 8));
                 reg1->reg &= ~(0xffff << (reg_idx * 16));
@@ -1376,17 +1394,21 @@ static int nhmex_mbox_hw_config(struct intel_uncore_box *box, struct perf_event
                 reg1->config = event->attr.config1;
                 reg_idx++;
         }
-        /* use config2 to pass the filter config */
-        reg2->idx = EXTRA_REG_NHMEX_M_FILTER;
-        if (event->attr.config2 & NHMEX_M_PMON_MM_CFG_EN)
-                reg2->config = event->attr.config2;
-        else
-                reg2->config = ~0ULL;
-        if (box->pmu->pmu_idx == 0)
-                reg2->reg = NHMEX_M0_MSR_PMU_MM_CFG;
-        else
-                reg2->reg = NHMEX_M1_MSR_PMU_MM_CFG;
-
+        /*
+         * The mbox only provides ability to perform address matching
+         * for the PLD events.
+         */
+        if (reg_idx == 2) {
+                reg2->idx = EXTRA_REG_NHMEX_M_FILTER;
+                if (event->attr.config2 & NHMEX_M_PMON_MM_CFG_EN)
+                        reg2->config = event->attr.config2;
+                else
+                        reg2->config = ~0ULL;
+                if (box->pmu->pmu_idx == 0)
+                        reg2->reg = NHMEX_M0_MSR_PMU_MM_CFG;
+                else
+                        reg2->reg = NHMEX_M1_MSR_PMU_MM_CFG;
+        }
         return 0;
 }
 
@@ -1422,34 +1444,36 @@ static void nhmex_mbox_msr_enable_event(struct intel_uncore_box *box, struct per
                 wrmsrl(__BITS_VALUE(reg1->reg, 1, 16),
                         nhmex_mbox_shared_reg_config(box, idx));
 
-        wrmsrl(reg2->reg, 0);
-        if (reg2->config != ~0ULL) {
-                wrmsrl(reg2->reg + 1,
-                        reg2->config & NHMEX_M_PMON_ADDR_MATCH_MASK);
-                wrmsrl(reg2->reg + 2, NHMEX_M_PMON_ADDR_MASK_MASK &
-                        (reg2->config >> NHMEX_M_PMON_ADDR_MASK_SHIFT));
-                wrmsrl(reg2->reg, NHMEX_M_PMON_MM_CFG_EN);
+        if (reg2->idx != EXTRA_REG_NONE) {
+                wrmsrl(reg2->reg, 0);
+                if (reg2->config != ~0ULL) {
+                        wrmsrl(reg2->reg + 1,
+                                reg2->config & NHMEX_M_PMON_ADDR_MATCH_MASK);
+                        wrmsrl(reg2->reg + 2, NHMEX_M_PMON_ADDR_MASK_MASK &
+                                (reg2->config >> NHMEX_M_PMON_ADDR_MASK_SHIFT));
+                        wrmsrl(reg2->reg, NHMEX_M_PMON_MM_CFG_EN);
+                }
         }
 
         wrmsrl(hwc->config_base, hwc->config | NHMEX_PMON_CTL_EN_BIT0);
 }
 
-DEFINE_UNCORE_FORMAT_ATTR(count_mode,   count_mode,     "config:2-3");
-DEFINE_UNCORE_FORMAT_ATTR(storage_mode, storage_mode,   "config:4-5");
-DEFINE_UNCORE_FORMAT_ATTR(wrap_mode,    wrap_mode,      "config:6");
-DEFINE_UNCORE_FORMAT_ATTR(flag_mode,    flag_mode,      "config:7");
-DEFINE_UNCORE_FORMAT_ATTR(inc_sel,      inc_sel,        "config:9-13");
-DEFINE_UNCORE_FORMAT_ATTR(set_flag_sel, set_flag_sel,   "config:19-21");
-DEFINE_UNCORE_FORMAT_ATTR(filter_cfg,   filter_cfg,     "config2:63");
-DEFINE_UNCORE_FORMAT_ATTR(filter_match, filter_match,   "config2:0-33");
-DEFINE_UNCORE_FORMAT_ATTR(filter_mask,  filter_mask,    "config2:34-61");
-DEFINE_UNCORE_FORMAT_ATTR(dsp,          dsp,            "config1:0-31");
-DEFINE_UNCORE_FORMAT_ATTR(thr,          thr,            "config1:0-31");
-DEFINE_UNCORE_FORMAT_ATTR(fvc,          fvc,            "config1:0-31");
-DEFINE_UNCORE_FORMAT_ATTR(pgt,          pgt,            "config1:0-31");
-DEFINE_UNCORE_FORMAT_ATTR(map,          map,            "config1:0-31");
-DEFINE_UNCORE_FORMAT_ATTR(iss,          iss,            "config1:0-31");
-DEFINE_UNCORE_FORMAT_ATTR(pld,          pld,            "config1:32-63");
+DEFINE_UNCORE_FORMAT_ATTR(count_mode,           count_mode,     "config:2-3");
+DEFINE_UNCORE_FORMAT_ATTR(storage_mode,         storage_mode,   "config:4-5");
+DEFINE_UNCORE_FORMAT_ATTR(wrap_mode,            wrap_mode,      "config:6");
+DEFINE_UNCORE_FORMAT_ATTR(flag_mode,            flag_mode,      "config:7");
+DEFINE_UNCORE_FORMAT_ATTR(inc_sel,              inc_sel,        "config:9-13");
+DEFINE_UNCORE_FORMAT_ATTR(set_flag_sel,         set_flag_sel,   "config:19-21");
+DEFINE_UNCORE_FORMAT_ATTR(filter_cfg_en,        filter_cfg_en,  "config2:63");
+DEFINE_UNCORE_FORMAT_ATTR(filter_match,         filter_match,   "config2:0-33");
+DEFINE_UNCORE_FORMAT_ATTR(filter_mask,          filter_mask,    "config2:34-61");
+DEFINE_UNCORE_FORMAT_ATTR(dsp,                  dsp,            "config1:0-31");
+DEFINE_UNCORE_FORMAT_ATTR(thr,                  thr,            "config1:0-31");
+DEFINE_UNCORE_FORMAT_ATTR(fvc,                  fvc,            "config1:0-31");
+DEFINE_UNCORE_FORMAT_ATTR(pgt,                  pgt,            "config1:0-31");
+DEFINE_UNCORE_FORMAT_ATTR(map,                  map,            "config1:0-31");
+DEFINE_UNCORE_FORMAT_ATTR(iss,                  iss,            "config1:0-31");
+DEFINE_UNCORE_FORMAT_ATTR(pld,                  pld,            "config1:32-63");
 
 static struct attribute *nhmex_uncore_mbox_formats_attr[] = {
         &format_attr_count_mode.attr,
@@ -1458,7 +1482,7 @@ static struct attribute *nhmex_uncore_mbox_formats_attr[] = {
         &format_attr_flag_mode.attr,
         &format_attr_inc_sel.attr,
         &format_attr_set_flag_sel.attr,
-        &format_attr_filter_cfg.attr,
+        &format_attr_filter_cfg_en.attr,
         &format_attr_filter_match.attr,
         &format_attr_filter_mask.attr,
         &format_attr_dsp.attr,
@@ -1482,6 +1506,12 @@ static struct uncore_event_desc nhmex_uncore_mbox_events[] = {
         { /* end: all zeroes */ },
 };
 
+static struct uncore_event_desc wsmex_uncore_mbox_events[] = {
+        INTEL_UNCORE_EVENT_DESC(bbox_cmds_read, "inc_sel=0xd,fvc=0x5000"),
+        INTEL_UNCORE_EVENT_DESC(bbox_cmds_write, "inc_sel=0xd,fvc=0x5040"),
+        { /* end: all zeroes */ },
+};
+
 static struct intel_uncore_ops nhmex_uncore_mbox_ops = {
         NHMEX_UNCORE_OPS_COMMON_INIT(),
         .enable_event   = nhmex_mbox_msr_enable_event,
@@ -1513,7 +1543,7 @@ void nhmex_rbox_alter_er(struct intel_uncore_box *box, struct perf_event *event)
         struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
         int port;
 
-        /* adjust the main event selector */
+        /* adjust the main event selector and extra register index */
         if (reg1->idx % 2) {
                 reg1->idx--;
                 hwc->config -= 1 << NHMEX_R_PMON_CTL_EV_SEL_SHIFT;
@@ -1522,29 +1552,17 @@ void nhmex_rbox_alter_er(struct intel_uncore_box *box, struct perf_event *event)
                 hwc->config += 1 << NHMEX_R_PMON_CTL_EV_SEL_SHIFT;
         }
 
-        /* adjust address or config of extra register */
+        /* adjust extra register config */
         port = reg1->idx / 6 + box->pmu->pmu_idx * 4;
         switch (reg1->idx % 6) {
-        case 0:
-                reg1->reg = NHMEX_R_MSR_PORTN_IPERF_CFG0(port);
-                break;
-        case 1:
-                reg1->reg = NHMEX_R_MSR_PORTN_IPERF_CFG1(port);
-                break;
         case 2:
-                /* the 8~15 bits to the 0~7 bits */
+                /* shift the 8~15 bits to the 0~7 bits */
                 reg1->config >>= 8;
                 break;
         case 3:
-                /* the 0~7 bits to the 8~15 bits */
+                /* shift the 0~7 bits to the 8~15 bits */
                 reg1->config <<= 8;
                 break;
-        case 4:
-                reg1->reg = NHMEX_R_MSR_PORTN_XBR_SET1_MM_CFG(port);
-                break;
-        case 5:
-                reg1->reg = NHMEX_R_MSR_PORTN_XBR_SET2_MM_CFG(port);
-                break;
         };
 }
 
@@ -1671,7 +1689,7 @@ static int nhmex_rbox_hw_config(struct intel_uncore_box *box, struct perf_event
         struct hw_perf_event *hwc = &event->hw;
         struct hw_perf_event_extra *reg1 = &event->hw.extra_reg;
         struct hw_perf_event_extra *reg2 = &event->hw.branch_reg;
-        int port, idx;
+        int idx;
 
         idx = (event->hw.config & NHMEX_R_PMON_CTL_EV_SEL_MASK) >>
                 NHMEX_R_PMON_CTL_EV_SEL_SHIFT;
@@ -1681,27 +1699,11 @@ static int nhmex_rbox_hw_config(struct intel_uncore_box *box, struct perf_event
         reg1->idx = idx;
         reg1->config = event->attr.config1;
 
-        port = idx / 6 + box->pmu->pmu_idx * 4;
-        idx %= 6;
-        switch (idx) {
-        case 0:
-                reg1->reg = NHMEX_R_MSR_PORTN_IPERF_CFG0(port);
-                break;
-        case 1:
-                reg1->reg = NHMEX_R_MSR_PORTN_IPERF_CFG1(port);
-                break;
-        case 2:
-        case 3:
-                reg1->reg = NHMEX_R_MSR_PORTN_QLX_CFG(port);
-                break;
+        switch (idx % 6) {
         case 4:
         case 5:
-                if (idx == 4)
-                        reg1->reg = NHMEX_R_MSR_PORTN_XBR_SET1_MM_CFG(port);
-                else
-                        reg1->reg = NHMEX_R_MSR_PORTN_XBR_SET2_MM_CFG(port);
-                reg2->config = event->attr.config2;
                 hwc->config |= event->attr.config & (~0ULL << 32);
+                reg2->config = event->attr.config2;
                 break;
         };
         return 0;
@@ -1727,28 +1729,34 @@ static void nhmex_rbox_msr_enable_event(struct intel_uncore_box *box, struct per
         struct hw_perf_event *hwc = &event->hw;
         struct hw_perf_event_extra *reg1 = &hwc->extra_reg;
         struct hw_perf_event_extra *reg2 = &hwc->branch_reg;
-        int idx, er_idx;
+        int idx, port;
 
-        idx = reg1->idx % 6;
-        er_idx = idx;
-        if (er_idx > 2)
-                er_idx--;
-        er_idx += (reg1->idx / 6) * 5;
+        idx = reg1->idx;
+        port = idx / 6 + box->pmu->pmu_idx * 4;
 
-        switch (idx) {
+        switch (idx % 6) {
         case 0:
+                wrmsrl(NHMEX_R_MSR_PORTN_IPERF_CFG0(port), reg1->config);
+                break;
         case 1:
-                wrmsrl(reg1->reg, reg1->config);
+                wrmsrl(NHMEX_R_MSR_PORTN_IPERF_CFG1(port), reg1->config);
                 break;
         case 2:
         case 3:
-                wrmsrl(reg1->reg, nhmex_rbox_shared_reg_config(box, er_idx));
+                wrmsrl(NHMEX_R_MSR_PORTN_QLX_CFG(port),
+                        nhmex_rbox_shared_reg_config(box, 2 + (idx / 6) * 5));
                 break;
         case 4:
+                wrmsrl(NHMEX_R_MSR_PORTN_XBR_SET1_MM_CFG(port),
+                        hwc->config >> 32);
+                wrmsrl(NHMEX_R_MSR_PORTN_XBR_SET1_MATCH(port), reg1->config);
+                wrmsrl(NHMEX_R_MSR_PORTN_XBR_SET1_MASK(port), reg2->config);
+                break;
         case 5:
-                wrmsrl(reg1->reg, reg1->config);
-                wrmsrl(reg1->reg + 1, hwc->config >> 32);
-                wrmsrl(reg1->reg + 2, reg2->config);
+                wrmsrl(NHMEX_R_MSR_PORTN_XBR_SET2_MM_CFG(port),
+                        hwc->config >> 32);
+                wrmsrl(NHMEX_R_MSR_PORTN_XBR_SET2_MATCH(port), reg1->config);
+                wrmsrl(NHMEX_R_MSR_PORTN_XBR_SET2_MASK(port), reg2->config);
                 break;
         };
 
@@ -1756,8 +1764,8 @@ static void nhmex_rbox_msr_enable_event(struct intel_uncore_box *box, struct per
                 (hwc->config & NHMEX_R_PMON_CTL_EV_SEL_MASK));
 }
 
-DEFINE_UNCORE_FORMAT_ATTR(xbr_match, xbr_match, "config:32-63");
-DEFINE_UNCORE_FORMAT_ATTR(xbr_mm_cfg, xbr_mm_cfg, "config1:0-63");
+DEFINE_UNCORE_FORMAT_ATTR(xbr_mm_cfg, xbr_mm_cfg, "config:32-63");
+DEFINE_UNCORE_FORMAT_ATTR(xbr_match, xbr_match, "config1:0-63");
 DEFINE_UNCORE_FORMAT_ATTR(xbr_mask, xbr_mask, "config2:0-63");
 DEFINE_UNCORE_FORMAT_ATTR(qlx_cfg, qlx_cfg, "config1:0-15");
 DEFINE_UNCORE_FORMAT_ATTR(iperf_cfg, iperf_cfg, "config1:0-31");
@@ -2303,6 +2311,7 @@ int uncore_pmu_event_init(struct perf_event *event)
         event->hw.idx = -1;
         event->hw.last_tag = ~0ULL;
         event->hw.extra_reg.idx = EXTRA_REG_NONE;
+        event->hw.branch_reg.idx = EXTRA_REG_NONE;
 
         if (event->attr.config == UNCORE_FIXED_EVENT) {
                 /* no fixed counter */
@@ -2373,7 +2382,7 @@ static void __init uncore_type_exit(struct intel_uncore_type *type)
         type->attr_groups[1] = NULL;
 }
 
-static void uncore_types_exit(struct intel_uncore_type **types)
+static void __init uncore_types_exit(struct intel_uncore_type **types)
 {
         int i;
         for (i = 0; types[i]; i++)
@@ -2814,7 +2823,13 @@ static int __init uncore_cpu_init(void)
                         snbep_uncore_cbox.num_boxes = max_cores;
                 msr_uncores = snbep_msr_uncores;
                 break;
-        case 46:
+        case 46: /* Nehalem-EX */
+                uncore_nhmex = true;
+        case 47: /* Westmere-EX aka. Xeon E7 */
+                if (!uncore_nhmex)
+                        nhmex_uncore_mbox.event_descs = wsmex_uncore_mbox_events;
+                if (nhmex_uncore_cbox.num_boxes > max_cores)
+                        nhmex_uncore_cbox.num_boxes = max_cores;
                 msr_uncores = nhmex_msr_uncores;
                 break;
         default:
diff --git a/arch/x86/kernel/cpu/perf_event_intel_uncore.h b/arch/x86/kernel/cpu/perf_event_intel_uncore.h
index c9e5dc56630a..5b81c1856aac 100644
--- a/arch/x86/kernel/cpu/perf_event_intel_uncore.h
+++ b/arch/x86/kernel/cpu/perf_event_intel_uncore.h
@@ -230,6 +230,7 @@
 #define NHMEX_S1_MSR_MASK                       0xe5a
 
 #define NHMEX_S_PMON_MM_CFG_EN                  (0x1ULL << 63)
+#define NHMEX_S_EVENT_TO_R_PROG_EV              0
 
 /* NHM-EX Mbox */
 #define NHMEX_M0_MSR_GLOBAL_CTL                 0xca0
@@ -275,18 +276,12 @@
                  NHMEX_M_PMON_CTL_INC_SEL_MASK |        \
                  NHMEX_M_PMON_CTL_SET_FLAG_SEL_MASK)
 
-
-#define NHMEX_M_PMON_ZDP_CTL_FVC_FVID_MASK      0x1f
-#define NHMEX_M_PMON_ZDP_CTL_FVC_BCMD_MASK      (0x7 << 5)
-#define NHMEX_M_PMON_ZDP_CTL_FVC_RSP_MASK       (0x7 << 8)
-#define NHMEX_M_PMON_ZDP_CTL_FVC_PBOX_INIT_ERR  (1 << 23)
-#define NHMEX_M_PMON_ZDP_CTL_FVC_MASK                   \
-                (NHMEX_M_PMON_ZDP_CTL_FVC_FVID_MASK |   \
-                 NHMEX_M_PMON_ZDP_CTL_FVC_BCMD_MASK |   \
-                 NHMEX_M_PMON_ZDP_CTL_FVC_RSP_MASK  |   \
-                 NHMEX_M_PMON_ZDP_CTL_FVC_PBOX_INIT_ERR)
+#define NHMEX_M_PMON_ZDP_CTL_FVC_MASK           (((1 << 11) - 1) | (1 << 23))
 #define NHMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(n)  (0x7 << (11 + 3 * (n)))
 
+#define WSMEX_M_PMON_ZDP_CTL_FVC_MASK           (((1 << 12) - 1) | (1 << 24))
+#define WSMEX_M_PMON_ZDP_CTL_FVC_EVENT_MASK(n)  (0x7 << (12 + 3 * (n)))
+
 /*
  * use the 9~13 bits to select event If the 7th bit is not set,
  * otherwise use the 19~21 bits to select event.
@@ -368,6 +363,7 @@ struct intel_uncore_type {
         unsigned num_shared_regs:8;
         unsigned single_fixed:1;
         unsigned pair_ctr_ctl:1;
+        unsigned *msr_offsets;
         struct event_constraint unconstrainted;
         struct event_constraint *constraints;
         struct intel_uncore_pmu *pmus;
@@ -485,29 +481,31 @@ unsigned uncore_pci_perf_ctr(struct intel_uncore_box *box, int idx)
         return idx * 8 + box->pmu->type->perf_ctr;
 }
 
-static inline
-unsigned uncore_msr_box_ctl(struct intel_uncore_box *box)
+static inline unsigned uncore_msr_box_offset(struct intel_uncore_box *box)
+{
+        struct intel_uncore_pmu *pmu = box->pmu;
+        return pmu->type->msr_offsets ?
+                pmu->type->msr_offsets[pmu->pmu_idx] :
+                pmu->type->msr_offset * pmu->pmu_idx;
+}
+
+static inline unsigned uncore_msr_box_ctl(struct intel_uncore_box *box)
 {
         if (!box->pmu->type->box_ctl)
                 return 0;
-        return box->pmu->type->box_ctl +
-                box->pmu->type->msr_offset * box->pmu->pmu_idx;
+        return box->pmu->type->box_ctl + uncore_msr_box_offset(box);
 }
 
-static inline
-unsigned uncore_msr_fixed_ctl(struct intel_uncore_box *box)
+static inline unsigned uncore_msr_fixed_ctl(struct intel_uncore_box *box)
 {
         if (!box->pmu->type->fixed_ctl)
                 return 0;
-        return box->pmu->type->fixed_ctl +
-                box->pmu->type->msr_offset * box->pmu->pmu_idx;
+        return box->pmu->type->fixed_ctl + uncore_msr_box_offset(box);
 }
 
-static inline
-unsigned uncore_msr_fixed_ctr(struct intel_uncore_box *box)
+static inline unsigned uncore_msr_fixed_ctr(struct intel_uncore_box *box)
 {
-        return box->pmu->type->fixed_ctr +
-                box->pmu->type->msr_offset * box->pmu->pmu_idx;
+        return box->pmu->type->fixed_ctr + uncore_msr_box_offset(box);
 }
 
 static inline
@@ -515,7 +513,7 @@ unsigned uncore_msr_event_ctl(struct intel_uncore_box *box, int idx)
 {
         return box->pmu->type->event_ctl +
                 (box->pmu->type->pair_ctr_ctl ? 2 * idx : idx) +
-                box->pmu->type->msr_offset * box->pmu->pmu_idx;
+                uncore_msr_box_offset(box);
 }
 
 static inline
@@ -523,7 +521,7 @@ unsigned uncore_msr_perf_ctr(struct intel_uncore_box *box, int idx)
 {
         return box->pmu->type->perf_ctr +
                 (box->pmu->type->pair_ctr_ctl ? 2 * idx : idx) +
-                box->pmu->type->msr_offset * box->pmu->pmu_idx;
+                uncore_msr_box_offset(box);
 }
 
 static inline
diff --git a/arch/x86/kernel/irq.c b/arch/x86/kernel/irq.c
index 7ad683d78645..d44f7829968e 100644
--- a/arch/x86/kernel/irq.c
+++ b/arch/x86/kernel/irq.c
@@ -270,7 +270,7 @@ void fixup_irqs(void)
 
                 if (cpumask_any_and(affinity, cpu_online_mask) >= nr_cpu_ids) {
                         break_affinity = 1;
-                        affinity = cpu_all_mask;
+                        affinity = cpu_online_mask;
                 }
 
                 chip = irq_data_get_irq_chip(data);
diff --git a/arch/x86/kernel/microcode_amd.c b/arch/x86/kernel/microcode_amd.c
index 8a2ce8fd41c0..82746f942cd8 100644
--- a/arch/x86/kernel/microcode_amd.c
+++ b/arch/x86/kernel/microcode_amd.c
@@ -143,11 +143,12 @@ static int get_matching_microcode(int cpu, const u8 *ucode_ptr,
                                   unsigned int *current_size)
 {
         struct microcode_header_amd *mc_hdr;
-        unsigned int actual_size;
+        unsigned int actual_size, patch_size;
         u16 equiv_cpu_id;
 
         /* size of the current patch we're staring at */
-        *current_size = *(u32 *)(ucode_ptr + 4) + SECTION_HDR_SIZE;
+        patch_size = *(u32 *)(ucode_ptr + 4);
+        *current_size = patch_size + SECTION_HDR_SIZE;
 
         equiv_cpu_id = find_equiv_id();
         if (!equiv_cpu_id)
@@ -174,7 +175,7 @@ static int get_matching_microcode(int cpu, const u8 *ucode_ptr,
         /*
          * now that the header looks sane, verify its size
          */
-        actual_size = verify_ucode_size(cpu, *current_size, leftover_size);
+        actual_size = verify_ucode_size(cpu, patch_size, leftover_size);
         if (!actual_size)
                 return 0;
 
diff --git a/arch/x86/kvm/emulate.c b/arch/x86/kvm/emulate.c
index 97d9a9914ba8..a3b57a27be88 100644
--- a/arch/x86/kvm/emulate.c
+++ b/arch/x86/kvm/emulate.c
@@ -475,13 +475,26 @@ register_address(struct x86_emulate_ctxt *ctxt, unsigned long reg)
         return address_mask(ctxt, reg);
 }
 
+static void masked_increment(ulong *reg, ulong mask, int inc)
+{
+        assign_masked(reg, *reg + inc, mask);
+}
+
 static inline void
 register_address_increment(struct x86_emulate_ctxt *ctxt, unsigned long *reg, int inc)
 {
+        ulong mask;
+
         if (ctxt->ad_bytes == sizeof(unsigned long))
-                *reg += inc;
+                mask = ~0UL;
         else
-                *reg = (*reg & ~ad_mask(ctxt)) | ((*reg + inc) & ad_mask(ctxt));
+                mask = ad_mask(ctxt);
+        masked_increment(reg, mask, inc);
+}
+
+static void rsp_increment(struct x86_emulate_ctxt *ctxt, int inc)
+{
+        masked_increment(&ctxt->regs[VCPU_REGS_RSP], stack_mask(ctxt), inc);
 }
 
 static inline void jmp_rel(struct x86_emulate_ctxt *ctxt, int rel)
@@ -1522,8 +1535,8 @@ static int push(struct x86_emulate_ctxt *ctxt, void *data, int bytes)
 {
         struct segmented_address addr;
 
-        register_address_increment(ctxt, &ctxt->regs[VCPU_REGS_RSP], -bytes);
-        addr.ea = register_address(ctxt, ctxt->regs[VCPU_REGS_RSP]);
+        rsp_increment(ctxt, -bytes);
+        addr.ea = ctxt->regs[VCPU_REGS_RSP] & stack_mask(ctxt);
         addr.seg = VCPU_SREG_SS;
 
         return segmented_write(ctxt, addr, data, bytes);
@@ -1542,13 +1555,13 @@ static int emulate_pop(struct x86_emulate_ctxt *ctxt,
         int rc;
         struct segmented_address addr;
 
-        addr.ea = register_address(ctxt, ctxt->regs[VCPU_REGS_RSP]);
+        addr.ea = ctxt->regs[VCPU_REGS_RSP] & stack_mask(ctxt);
         addr.seg = VCPU_SREG_SS;
         rc = segmented_read(ctxt, addr, dest, len);
         if (rc != X86EMUL_CONTINUE)
                 return rc;
 
-        register_address_increment(ctxt, &ctxt->regs[VCPU_REGS_RSP], len);
+        rsp_increment(ctxt, len);
         return rc;
 }
 
@@ -1688,8 +1701,7 @@ static int em_popa(struct x86_emulate_ctxt *ctxt)
 
         while (reg >= VCPU_REGS_RAX) {
                 if (reg == VCPU_REGS_RSP) {
-                        register_address_increment(ctxt, &ctxt->regs[VCPU_REGS_RSP],
-                                                        ctxt->op_bytes);
+                        rsp_increment(ctxt, ctxt->op_bytes);
                         --reg;
                 }
 
@@ -2825,7 +2837,7 @@ static int em_ret_near_imm(struct x86_emulate_ctxt *ctxt)
         rc = emulate_pop(ctxt, &ctxt->dst.val, ctxt->op_bytes);
         if (rc != X86EMUL_CONTINUE)
                 return rc;
-        register_address_increment(ctxt, &ctxt->regs[VCPU_REGS_RSP], ctxt->src.val);
+        rsp_increment(ctxt, ctxt->src.val);
         return X86EMUL_CONTINUE;
 }
 
diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c
index 01ca00423938..7fbd0d273ea8 100644
--- a/arch/x86/kvm/mmu.c
+++ b/arch/x86/kvm/mmu.c
@@ -4113,16 +4113,21 @@ static int mmu_shrink(struct shrinker *shrink, struct shrink_control *sc)
                 LIST_HEAD(invalid_list);
 
                 /*
+                 * Never scan more than sc->nr_to_scan VM instances.
+                 * Will not hit this condition practically since we do not try
+                 * to shrink more than one VM and it is very unlikely to see
+                 * !n_used_mmu_pages so many times.
+                 */
+                if (!nr_to_scan--)
+                        break;
+                /*
                  * n_used_mmu_pages is accessed without holding kvm->mmu_lock
                  * here. We may skip a VM instance errorneosly, but we do not
                  * want to shrink a VM that only started to populate its MMU
                  * anyway.
                  */
-                if (kvm->arch.n_used_mmu_pages > 0) {
-                        if (!nr_to_scan--)
-                                break;
+                if (!kvm->arch.n_used_mmu_pages)
                         continue;
-                }
 
                 idx = srcu_read_lock(&kvm->srcu);
                 spin_lock(&kvm->mmu_lock);
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 42bce48f6928..148ed666e311 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -806,7 +806,7 @@ EXPORT_SYMBOL_GPL(kvm_rdpmc);
  * kvm-specific. Those are put in the beginning of the list.
  */
 
-#define KVM_SAVE_MSRS_BEGIN     9
+#define KVM_SAVE_MSRS_BEGIN     10
 static u32 msrs_to_save[] = {
         MSR_KVM_SYSTEM_TIME, MSR_KVM_WALL_CLOCK,
         MSR_KVM_SYSTEM_TIME_NEW, MSR_KVM_WALL_CLOCK_NEW,
@@ -2000,6 +2000,9 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
         case MSR_KVM_STEAL_TIME:
                 data = vcpu->arch.st.msr_val;
                 break;
+        case MSR_KVM_PV_EOI_EN:
+                data = vcpu->arch.pv_eoi.msr_val;
+                break;
         case MSR_IA32_P5_MC_ADDR:
         case MSR_IA32_P5_MC_TYPE:
         case MSR_IA32_MCG_CAP:
diff --git a/arch/x86/mm/hugetlbpage.c b/arch/x86/mm/hugetlbpage.c
index f6679a7fb8ca..b91e48512425 100644
--- a/arch/x86/mm/hugetlbpage.c
+++ b/arch/x86/mm/hugetlbpage.c
@@ -56,9 +56,16 @@ static int vma_shareable(struct vm_area_struct *vma, unsigned long addr)
 }
 
 /*
- * search for a shareable pmd page for hugetlb.
+ * Search for a shareable pmd page for hugetlb. In any case calls pmd_alloc()
+ * and returns the corresponding pte. While this is not necessary for the
+ * !shared pmd case because we can allocate the pmd later as well, it makes the
+ * code much cleaner. pmd allocation is essential for the shared case because
+ * pud has to be populated inside the same i_mmap_mutex section - otherwise
+ * racing tasks could either miss the sharing (see huge_pte_offset) or select a
+ * bad pmd for sharing.
  */
-static void huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud)
+static pte_t *
+huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud)
 {
         struct vm_area_struct *vma = find_vma(mm, addr);
         struct address_space *mapping = vma->vm_file->f_mapping;
@@ -68,9 +75,10 @@ static void huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud)
         struct vm_area_struct *svma;
         unsigned long saddr;
         pte_t *spte = NULL;
+        pte_t *pte;
 
         if (!vma_shareable(vma, addr))
-                return;
+                return (pte_t *)pmd_alloc(mm, pud, addr);
 
         mutex_lock(&mapping->i_mmap_mutex);
         vma_prio_tree_foreach(svma, &iter, &mapping->i_mmap, idx, idx) {
@@ -97,7 +105,9 @@ static void huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud)
                 put_page(virt_to_page(spte));
         spin_unlock(&mm->page_table_lock);
 out:
+        pte = (pte_t *)pmd_alloc(mm, pud, addr);
         mutex_unlock(&mapping->i_mmap_mutex);
+        return pte;
 }
 
 /*
@@ -142,8 +152,9 @@ pte_t *huge_pte_alloc(struct mm_struct *mm,
                 } else {
                         BUG_ON(sz != PMD_SIZE);
                         if (pud_none(*pud))
-                                huge_pmd_share(mm, addr, pud);
-                        pte = (pte_t *) pmd_alloc(mm, pud, addr);
+                                pte = huge_pmd_share(mm, addr, pud);
+                        else
+                                pte = (pte_t *)pmd_alloc(mm, pud, addr);
                 }
         }
         BUG_ON(pte && !pte_none(*pte) && !pte_huge(*pte));
diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c
index 931930a96160..a718e0d23503 100644
--- a/arch/x86/mm/pageattr.c
+++ b/arch/x86/mm/pageattr.c
@@ -919,13 +919,11 @@ static int change_page_attr_set_clr(unsigned long *addr, int numpages,
 
         /*
          * On success we use clflush, when the CPU supports it to
-         * avoid the wbindv. If the CPU does not support it, in the
-         * error case, and during early boot (for EFI) we fall back
-         * to cpa_flush_all (which uses wbinvd):
+         * avoid the wbindv. If the CPU does not support it and in the
+         * error case we fall back to cpa_flush_all (which uses
+         * wbindv):
          */
-        if (early_boot_irqs_disabled)
-                __cpa_flush_all((void *)(long)cache);
-        else if (!ret && cpu_has_clflush) {
+        if (!ret && cpu_has_clflush) {
                 if (cpa.flags & (CPA_PAGES_ARRAY | CPA_ARRAY)) {
                         cpa_flush_array(addr, numpages, cache,
                                         cpa.flags, pages);
diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index 2dc29f51e75a..92660edaa1e7 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -234,7 +234,22 @@ static efi_status_t __init phys_efi_set_virtual_address_map(
         return status;
 }
 
-static int efi_set_rtc_mmss(unsigned long nowtime)
+static efi_status_t __init phys_efi_get_time(efi_time_t *tm,
+                                             efi_time_cap_t *tc)
+{
+        unsigned long flags;
+        efi_status_t status;
+
+        spin_lock_irqsave(&rtc_lock, flags);
+        efi_call_phys_prelog();
+        status = efi_call_phys2(efi_phys.get_time, virt_to_phys(tm),
+                                virt_to_phys(tc));
+        efi_call_phys_epilog();
+        spin_unlock_irqrestore(&rtc_lock, flags);
+        return status;
+}
+
+int efi_set_rtc_mmss(unsigned long nowtime)
 {
         int real_seconds, real_minutes;
         efi_status_t    status;
@@ -263,7 +278,7 @@ static int efi_set_rtc_mmss(unsigned long nowtime)
         return 0;
 }
 
-static unsigned long efi_get_time(void)
+unsigned long efi_get_time(void)
 {
         efi_status_t status;
         efi_time_t eft;
@@ -606,13 +621,18 @@ static int __init efi_runtime_init(void)
         }
         /*
          * We will only need *early* access to the following
-         * EFI runtime service before set_virtual_address_map
+         * two EFI runtime services before set_virtual_address_map
          * is invoked.
          */
+        efi_phys.get_time = (efi_get_time_t *)runtime->get_time;
         efi_phys.set_virtual_address_map =
                 (efi_set_virtual_address_map_t *)
                 runtime->set_virtual_address_map;
-
+        /*
+         * Make efi_get_time can be called before entering
+         * virtual mode.
+         */
+        efi.get_time = phys_efi_get_time;
         early_iounmap(runtime, sizeof(efi_runtime_services_t));
 
         return 0;
@@ -700,10 +720,12 @@ void __init efi_init(void)
                 efi_enabled = 0;
                 return;
         }
+#ifdef CONFIG_X86_32
         if (efi_native) {
                 x86_platform.get_wallclock = efi_get_time;
                 x86_platform.set_wallclock = efi_set_rtc_mmss;
         }
+#endif
 
 #if EFI_DEBUG
         print_efi_memmap();
diff --git a/arch/x86/realmode/rm/Makefile b/arch/x86/realmode/rm/Makefile
index b2d534cab25f..88692871823f 100644
--- a/arch/x86/realmode/rm/Makefile
+++ b/arch/x86/realmode/rm/Makefile
@@ -72,7 +72,7 @@ KBUILD_CFLAGS	:= $(LINUXINCLUDE) -m32 -g -Os -D_SETUP -D__KERNEL__ -D_WAKEUP \
                    -Wall -Wstrict-prototypes \
                    -march=i386 -mregparm=3 \
                    -include $(srctree)/$(src)/../../boot/code16gcc.h \
-                   -fno-strict-aliasing -fomit-frame-pointer \
+                   -fno-strict-aliasing -fomit-frame-pointer -fno-pic \
                    $(call cc-option, -ffreestanding) \
                    $(call cc-option, -fno-toplevel-reorder,\
                         $(call cc-option, -fno-unit-at-a-time)) \
diff --git a/arch/x86/syscalls/syscall_64.tbl b/arch/x86/syscalls/syscall_64.tbl
index 29aed7ac2c02..a582bfed95bb 100644
--- a/arch/x86/syscalls/syscall_64.tbl
+++ b/arch/x86/syscalls/syscall_64.tbl
@@ -60,8 +60,8 @@
 51      common  getsockname             sys_getsockname
 52      common  getpeername             sys_getpeername
 53      common  socketpair              sys_socketpair
-54      common  setsockopt              sys_setsockopt
-55      common  getsockopt              sys_getsockopt
+54      64      setsockopt              sys_setsockopt
+55      64      getsockopt              sys_getsockopt
 56      common  clone                   stub_clone
 57      common  fork                    stub_fork
 58      common  vfork                   stub_vfork
@@ -353,3 +353,5 @@
 538     x32     sendmmsg                compat_sys_sendmmsg
 539     x32     process_vm_readv        compat_sys_process_vm_readv
 540     x32     process_vm_writev       compat_sys_process_vm_writev
+541     x32     setsockopt              compat_sys_setsockopt
+542     x32     getsockopt              compat_sys_getsockopt
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index bf4bda6d3e9a..9642d4a38602 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -31,7 +31,6 @@
 #include <linux/pci.h>
 #include <linux/gfp.h>
 #include <linux/memblock.h>
-#include <linux/syscore_ops.h>
 
 #include <xen/xen.h>
 #include <xen/interface/xen.h>
@@ -1470,130 +1469,38 @@ asmlinkage void __init xen_start_kernel(void)
 #endif
 }
 
-#ifdef CONFIG_XEN_PVHVM
-/*
- * The pfn containing the shared_info is located somewhere in RAM. This
- * will cause trouble if the current kernel is doing a kexec boot into a
- * new kernel. The new kernel (and its startup code) can not know where
- * the pfn is, so it can not reserve the page. The hypervisor will
- * continue to update the pfn, and as a result memory corruption occours
- * in the new kernel.
- *
- * One way to work around this issue is to allocate a page in the
- * xen-platform pci device's BAR memory range. But pci init is done very
- * late and the shared_info page is already in use very early to read
- * the pvclock. So moving the pfn from RAM to MMIO is racy because some
- * code paths on other vcpus could access the pfn during the small
- * window when the old pfn is moved to the new pfn. There is even a
- * small window were the old pfn is not backed by a mfn, and during that
- * time all reads return -1.
- *
- * Because it is not known upfront where the MMIO region is located it
- * can not be used right from the start in xen_hvm_init_shared_info.
- *
- * To minimise trouble the move of the pfn is done shortly before kexec.
- * This does not eliminate the race because all vcpus are still online
- * when the syscore_ops will be called. But hopefully there is no work
- * pending at this point in time. Also the syscore_op is run last which
- * reduces the risk further.
- */
-
-static struct shared_info *xen_hvm_shared_info;
-
-static void xen_hvm_connect_shared_info(unsigned long pfn)
+void __ref xen_hvm_init_shared_info(void)
 {
+        int cpu;
         struct xen_add_to_physmap xatp;
+        static struct shared_info *shared_info_page = 0;
 
+        if (!shared_info_page)
+                shared_info_page = (struct shared_info *)
+                        extend_brk(PAGE_SIZE, PAGE_SIZE);
         xatp.domid = DOMID_SELF;
         xatp.idx = 0;
         xatp.space = XENMAPSPACE_shared_info;
-        xatp.gpfn = pfn;
+        xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT;
         if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp))
                 BUG();
 
-}
-static void xen_hvm_set_shared_info(struct shared_info *sip)
-{
-        int cpu;
-
-        HYPERVISOR_shared_info = sip;
+        HYPERVISOR_shared_info = (struct shared_info *)shared_info_page;
 
         /* xen_vcpu is a pointer to the vcpu_info struct in the shared_info
          * page, we use it in the event channel upcall and in some pvclock
          * related functions. We don't need the vcpu_info placement
          * optimizations because we don't use any pv_mmu or pv_irq op on
          * HVM.
-         * When xen_hvm_set_shared_info is run at boot time only vcpu 0 is
-         * online but xen_hvm_set_shared_info is run at resume time too and
+         * When xen_hvm_init_shared_info is run at boot time only vcpu 0 is
+         * online but xen_hvm_init_shared_info is run at resume time too and
          * in that case multiple vcpus might be online. */
         for_each_online_cpu(cpu) {
                 per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
         }
 }
 
-/* Reconnect the shared_info pfn to a mfn */
-void xen_hvm_resume_shared_info(void)
-{
-        xen_hvm_connect_shared_info(__pa(xen_hvm_shared_info) >> PAGE_SHIFT);
-}
-
-#ifdef CONFIG_KEXEC
-static struct shared_info *xen_hvm_shared_info_kexec;
-static unsigned long xen_hvm_shared_info_pfn_kexec;
-
-/* Remember a pfn in MMIO space for kexec reboot */
-void __devinit xen_hvm_prepare_kexec(struct shared_info *sip, unsigned long pfn)
-{
-        xen_hvm_shared_info_kexec = sip;
-        xen_hvm_shared_info_pfn_kexec = pfn;
-}
-
-static void xen_hvm_syscore_shutdown(void)
-{
-        struct xen_memory_reservation reservation = {
-                .domid = DOMID_SELF,
-                .nr_extents = 1,
-        };
-        unsigned long prev_pfn;
-        int rc;
-
-        if (!xen_hvm_shared_info_kexec)
-                return;
-
-        prev_pfn = __pa(xen_hvm_shared_info) >> PAGE_SHIFT;
-        set_xen_guest_handle(reservation.extent_start, &prev_pfn);
-
-        /* Move pfn to MMIO, disconnects previous pfn from mfn */
-        xen_hvm_connect_shared_info(xen_hvm_shared_info_pfn_kexec);
-
-        /* Update pointers, following hypercall is also a memory barrier */
-        xen_hvm_set_shared_info(xen_hvm_shared_info_kexec);
-
-        /* Allocate new mfn for previous pfn */
-        do {
-                rc = HYPERVISOR_memory_op(XENMEM_populate_physmap, &reservation);
-                if (rc == 0)
-                        msleep(123);
-        } while (rc == 0);
-
-        /* Make sure the previous pfn is really connected to a (new) mfn */
-        BUG_ON(rc != 1);
-}
-
-static struct syscore_ops xen_hvm_syscore_ops = {
-        .shutdown = xen_hvm_syscore_shutdown,
-};
-#endif
-
-/* Use a pfn in RAM, may move to MMIO before kexec. */
-static void __init xen_hvm_init_shared_info(void)
-{
-        /* Remember pointer for resume */
-        xen_hvm_shared_info = extend_brk(PAGE_SIZE, PAGE_SIZE);
-        xen_hvm_connect_shared_info(__pa(xen_hvm_shared_info) >> PAGE_SHIFT);
-        xen_hvm_set_shared_info(xen_hvm_shared_info);
-}
-
+#ifdef CONFIG_XEN_PVHVM
 static void __init init_hvm_pv_info(void)
 {
         int major, minor;
@@ -1644,9 +1551,6 @@ static void __init xen_hvm_guest_init(void)
         init_hvm_pv_info();
 
         xen_hvm_init_shared_info();
-#ifdef CONFIG_KEXEC
-        register_syscore_ops(&xen_hvm_syscore_ops);
-#endif
 
         if (xen_feature(XENFEAT_hvm_callback_vector))
                 xen_have_vector_callback = 1;
diff --git a/arch/x86/xen/p2m.c b/arch/x86/xen/p2m.c
index 64effdc6da94..d4b255463253 100644
--- a/arch/x86/xen/p2m.c
+++ b/arch/x86/xen/p2m.c
@@ -194,6 +194,13 @@ RESERVE_BRK(p2m_mid_mfn, PAGE_SIZE * (MAX_DOMAIN_PAGES / (P2M_PER_PAGE * P2M_MID
  * boundary violation will require three middle nodes. */
 RESERVE_BRK(p2m_mid_identity, PAGE_SIZE * 2 * 3);
 
+/* When we populate back during bootup, the amount of pages can vary. The
+ * max we have is seen is 395979, but that does not mean it can't be more.
+ * Some machines can have 3GB I/O holes even. With early_can_reuse_p2m_middle
+ * it can re-use Xen provided mfn_list array, so we only need to allocate at
+ * most three P2M top nodes. */
+RESERVE_BRK(p2m_populated, PAGE_SIZE * 3);
+
 static inline unsigned p2m_top_index(unsigned long pfn)
 {
         BUG_ON(pfn >= MAX_P2M_PFN);
@@ -570,12 +577,99 @@ static bool __init early_alloc_p2m(unsigned long pfn)
         }
         return true;
 }
+
+/*
+ * Skim over the P2M tree looking at pages that are either filled with
+ * INVALID_P2M_ENTRY or with 1:1 PFNs. If found, re-use that page and
+ * replace the P2M leaf with a p2m_missing or p2m_identity.
+ * Stick the old page in the new P2M tree location.
+ */
+bool __init early_can_reuse_p2m_middle(unsigned long set_pfn, unsigned long set_mfn)
+{
+        unsigned topidx;
+        unsigned mididx;
+        unsigned ident_pfns;
+        unsigned inv_pfns;
+        unsigned long *p2m;
+        unsigned long *mid_mfn_p;
+        unsigned idx;
+        unsigned long pfn;
+
+        /* We only look when this entails a P2M middle layer */
+        if (p2m_index(set_pfn))
+                return false;
+
+        for (pfn = 0; pfn <= MAX_DOMAIN_PAGES; pfn += P2M_PER_PAGE) {
+                topidx = p2m_top_index(pfn);
+
+                if (!p2m_top[topidx])
+                        continue;
+
+                if (p2m_top[topidx] == p2m_mid_missing)
+                        continue;
+
+                mididx = p2m_mid_index(pfn);
+                p2m = p2m_top[topidx][mididx];
+                if (!p2m)
+                        continue;
+
+                if ((p2m == p2m_missing) || (p2m == p2m_identity))
+                        continue;
+
+                if ((unsigned long)p2m == INVALID_P2M_ENTRY)
+                        continue;
+
+                ident_pfns = 0;
+                inv_pfns = 0;
+                for (idx = 0; idx < P2M_PER_PAGE; idx++) {
+                        /* IDENTITY_PFNs are 1:1 */
+                        if (p2m[idx] == IDENTITY_FRAME(pfn + idx))
+                                ident_pfns++;
+                        else if (p2m[idx] == INVALID_P2M_ENTRY)
+                                inv_pfns++;
+                        else
+                                break;
+                }
+                if ((ident_pfns == P2M_PER_PAGE) || (inv_pfns == P2M_PER_PAGE))
+                        goto found;
+        }
+        return false;
+found:
+        /* Found one, replace old with p2m_identity or p2m_missing */
+        p2m_top[topidx][mididx] = (ident_pfns ? p2m_identity : p2m_missing);
+        /* And the other for save/restore.. */
+        mid_mfn_p = p2m_top_mfn_p[topidx];
+        /* NOTE: Even if it is a p2m_identity it should still be point to
+         * a page filled with INVALID_P2M_ENTRY entries. */
+        mid_mfn_p[mididx] = virt_to_mfn(p2m_missing);
+
+        /* Reset where we want to stick the old page in. */
+        topidx = p2m_top_index(set_pfn);
+        mididx = p2m_mid_index(set_pfn);
+
+        /* This shouldn't happen */
+        if (WARN_ON(p2m_top[topidx] == p2m_mid_missing))
+                early_alloc_p2m(set_pfn);
+
+        if (WARN_ON(p2m_top[topidx][mididx] != p2m_missing))
+                return false;
+
+        p2m_init(p2m);
+        p2m_top[topidx][mididx] = p2m;
+        mid_mfn_p = p2m_top_mfn_p[topidx];
+        mid_mfn_p[mididx] = virt_to_mfn(p2m);
+
+        return true;
+}
 bool __init early_set_phys_to_machine(unsigned long pfn, unsigned long mfn)
 {
         if (unlikely(!__set_phys_to_machine(pfn, mfn)))  {
                 if (!early_alloc_p2m(pfn))
                         return false;
 
+                if (early_can_reuse_p2m_middle(pfn, mfn))
+                        return __set_phys_to_machine(pfn, mfn);
+
                 if (!early_alloc_p2m_middle(pfn, false /* boundary crossover OK!*/))
                         return false;
 
diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
index ead85576d54a..d11ca11d14fc 100644
--- a/arch/x86/xen/setup.c
+++ b/arch/x86/xen/setup.c
@@ -78,9 +78,16 @@ static void __init xen_add_extra_mem(u64 start, u64 size)
         memblock_reserve(start, size);
 
         xen_max_p2m_pfn = PFN_DOWN(start + size);
+        for (pfn = PFN_DOWN(start); pfn < xen_max_p2m_pfn; pfn++) {
+                unsigned long mfn = pfn_to_mfn(pfn);
+
+                if (WARN(mfn == pfn, "Trying to over-write 1-1 mapping (pfn: %lx)\n", pfn))
+                        continue;
+                WARN(mfn != INVALID_P2M_ENTRY, "Trying to remove %lx which has %lx mfn!\n",
+                        pfn, mfn);
 
-        for (pfn = PFN_DOWN(start); pfn <= xen_max_p2m_pfn; pfn++)
                 __set_phys_to_machine(pfn, INVALID_P2M_ENTRY);
+        }
 }
 
 static unsigned long __init xen_do_chunk(unsigned long start,
diff --git a/arch/x86/xen/suspend.c b/arch/x86/xen/suspend.c
index ae8a00c39de4..45329c8c226e 100644
--- a/arch/x86/xen/suspend.c
+++ b/arch/x86/xen/suspend.c
@@ -30,7 +30,7 @@ void xen_arch_hvm_post_suspend(int suspend_cancelled)
 {
 #ifdef CONFIG_XEN_PVHVM
         int cpu;
-        xen_hvm_resume_shared_info();
+        xen_hvm_init_shared_info();
         xen_callback_vector();
         xen_unplug_emulated_devices();
         if (xen_feature(XENFEAT_hvm_safe_pvclock)) {
diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h
index 1e4329e04e0f..202d4c150154 100644
--- a/arch/x86/xen/xen-ops.h
+++ b/arch/x86/xen/xen-ops.h
@@ -41,7 +41,7 @@ void xen_enable_syscall(void);
 void xen_vcpu_restore(void);
 
 void xen_callback_vector(void);
-void xen_hvm_resume_shared_info(void);
+void xen_hvm_init_shared_info(void);
 void xen_unplug_emulated_devices(void);
 
 void __init xen_build_dynamic_phys_to_machine(void);