136 files changed, 3539 insertions, 1069 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 1151a1dcfe41..7a8f2cd66c8b 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -108,6 +108,10 @@ static inline void acpi_initrd_override(void *data, size_t size)
 }
 #endif
 
+#define BAD_MADT_ENTRY(entry, end) (                                        \
+                (!entry) || (unsigned long)entry + sizeof(*entry) > end ||  \
+                ((struct acpi_subtable_header *)entry)->length < sizeof(*entry))
+
 char * __acpi_map_table (unsigned long phys_addr, unsigned long size);
 void __acpi_unmap_table(char *map, unsigned long size);
 int early_acpi_boot_init(void);
@@ -259,14 +263,9 @@ extern void acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d);
 extern void acpi_osi_setup(char *str);
 
 #ifdef CONFIG_ACPI_NUMA
-int acpi_get_pxm(acpi_handle handle);
-int acpi_get_node(acpi_handle *handle);
+int acpi_get_node(acpi_handle handle);
 #else
-static inline int acpi_get_pxm(acpi_handle handle)
-{
-        return 0;
-}
-static inline int acpi_get_node(acpi_handle *handle)
+static inline int acpi_get_node(acpi_handle handle)
 {
         return 0;
 }
diff --git a/include/linux/ahci_platform.h b/include/linux/ahci_platform.h
index 73a25005d88a..1f16d502600c 100644
--- a/include/linux/ahci_platform.h
+++ b/include/linux/ahci_platform.h
@@ -19,15 +19,37 @@
 
 struct device;
 struct ata_port_info;
+struct ahci_host_priv;
+struct platform_device;
 
+/*
+ * Note ahci_platform_data is deprecated, it is only kept around for use
+ * by the old da850 and spear13xx ahci code.
+ * New drivers should instead declare their own platform_driver struct, and
+ * use ahci_platform* functions in their own probe, suspend and resume methods.
+ */
 struct ahci_platform_data {
         int (*init)(struct device *dev, void __iomem *addr);
         void (*exit)(struct device *dev);
         int (*suspend)(struct device *dev);
         int (*resume)(struct device *dev);
-        const struct ata_port_info *ata_port_info;
-        unsigned int force_port_map;
-        unsigned int mask_port_map;
 };
 
+int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);
+void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);
+int ahci_platform_enable_resources(struct ahci_host_priv *hpriv);
+void ahci_platform_disable_resources(struct ahci_host_priv *hpriv);
+struct ahci_host_priv *ahci_platform_get_resources(
+        struct platform_device *pdev);
+int ahci_platform_init_host(struct platform_device *pdev,
+                            struct ahci_host_priv *hpriv,
+                            const struct ata_port_info *pi_template,
+                            unsigned int force_port_map,
+                            unsigned int mask_port_map);
+
+int ahci_platform_suspend_host(struct device *dev);
+int ahci_platform_resume_host(struct device *dev);
+int ahci_platform_suspend(struct device *dev);
+int ahci_platform_resume(struct device *dev);
+
 #endif /* _AHCI_PLATFORM_H */
diff --git a/include/linux/atmel-ssc.h b/include/linux/atmel-ssc.h
index 66a0e5384edd..571a12ebb018 100644
--- a/include/linux/atmel-ssc.h
+++ b/include/linux/atmel-ssc.h
@@ -18,6 +18,7 @@ struct ssc_device {
         struct clk              *clk;
         int                     user;
         int                     irq;
+        bool                    clk_from_rk_pin;
 };
 
 struct ssc_device * __must_check ssc_request(unsigned int ssc_num);
diff --git a/include/linux/audit.h b/include/linux/audit.h
index aa865a9a4c4f..ec1464df4c60 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -43,6 +43,7 @@ struct mq_attr;
 struct mqstat;
 struct audit_watch;
 struct audit_tree;
+struct sk_buff;
 
 struct audit_krule {
         int                     vers_ops;
@@ -463,7 +464,7 @@ extern int audit_filter_user(int type);
 extern int audit_filter_type(int type);
 extern int audit_rule_change(int type, __u32 portid, int seq,
                                 void *data, size_t datasz);
-extern int audit_list_rules_send(__u32 portid, int seq);
+extern int audit_list_rules_send(struct sk_buff *request_skb, int seq);
 
 extern u32 audit_enabled;
 #else /* CONFIG_AUDIT */
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index abc9ca778456..be5fd38bd5a0 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -196,6 +196,21 @@ static inline unsigned long __ffs64(u64 word)
 
 #ifdef __KERNEL__
 
+#ifndef set_mask_bits
+#define set_mask_bits(ptr, _mask, _bits)        \
+({                                                              \
+        const typeof(*ptr) mask = (_mask), bits = (_bits);      \
+        typeof(*ptr) old, new;                                  \
+                                                                \
+        do {                                                    \
+                old = ACCESS_ONCE(*ptr);                        \
+                new = (old & ~mask) | bits;                     \
+        } while (cmpxchg(ptr, old, new) != old);                \
+                                                                \
+        new;                                                    \
+})
+#endif
+
 #ifndef find_last_bit
 /**
  * find_last_bit - find the last set bit in a memory region
diff --git a/include/linux/blk-iopoll.h b/include/linux/blk-iopoll.h
index 308734d3d4a2..77ae77c0b704 100644
--- a/include/linux/blk-iopoll.h
+++ b/include/linux/blk-iopoll.h
@@ -43,6 +43,4 @@ extern void __blk_iopoll_complete(struct blk_iopoll *);
 extern void blk_iopoll_enable(struct blk_iopoll *);
 extern void blk_iopoll_disable(struct blk_iopoll *);
 
-extern int blk_iopoll_enabled;
-
 #endif
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 18ba8a627f46..0120451545d8 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -109,7 +109,7 @@ enum {
         BLK_MQ_F_SHOULD_SORT    = 1 << 1,
         BLK_MQ_F_SHOULD_IPI     = 1 << 2,
 
-        BLK_MQ_S_STOPPED        = 1 << 0,
+        BLK_MQ_S_STOPPED        = 0,
 
         BLK_MQ_MAX_DEPTH        = 2048,
 };
@@ -117,12 +117,12 @@ enum {
 struct request_queue *blk_mq_init_queue(struct blk_mq_reg *, void *);
 int blk_mq_register_disk(struct gendisk *);
 void blk_mq_unregister_disk(struct gendisk *);
-void blk_mq_init_commands(struct request_queue *, void (*init)(void *data, struct blk_mq_hw_ctx *, struct request *, unsigned int), void *data);
+int blk_mq_init_commands(struct request_queue *, int (*init)(void *data, struct blk_mq_hw_ctx *, struct request *, unsigned int), void *data);
+void blk_mq_free_commands(struct request_queue *, void (*free)(void *data, struct blk_mq_hw_ctx *, struct request *, unsigned int), void *data);
 
 void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule);
 
-void blk_mq_insert_request(struct request_queue *, struct request *,
-                bool, bool);
+void blk_mq_insert_request(struct request *, bool, bool, bool);
 void blk_mq_run_queues(struct request_queue *q, bool async);
 void blk_mq_free_request(struct request *rq);
 bool blk_mq_can_queue(struct blk_mq_hw_ctx *);
@@ -134,7 +134,13 @@ struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *, const int ctx_ind
 struct blk_mq_hw_ctx *blk_mq_alloc_single_hw_queue(struct blk_mq_reg *, unsigned int);
 void blk_mq_free_single_hw_queue(struct blk_mq_hw_ctx *, unsigned int);
 
-void blk_mq_end_io(struct request *rq, int error);
+bool blk_mq_end_io_partial(struct request *rq, int error,
+                unsigned int nr_bytes);
+static inline void blk_mq_end_io(struct request *rq, int error)
+{
+        bool done = !blk_mq_end_io_partial(rq, error, blk_rq_bytes(rq));
+        BUG_ON(!done);
+}
 
 void blk_mq_complete_request(struct request *rq);
 
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 4afa4f8f6090..1e1fa3f93d5f 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -99,6 +99,7 @@ struct request {
         union {
                 struct call_single_data csd;
                 struct work_struct mq_flush_work;
+                unsigned long fifo_time;
         };
 
         struct request_queue *q;
diff --git a/include/linux/ceph/ceph_fs.h b/include/linux/ceph/ceph_fs.h
index 2623cffc73a1..25bfb0eff772 100644
--- a/include/linux/ceph/ceph_fs.h
+++ b/include/linux/ceph/ceph_fs.h
@@ -373,8 +373,9 @@ extern const char *ceph_mds_op_name(int op);
 /*
  * Ceph setxattr request flags.
  */
-#define CEPH_XATTR_CREATE  1
-#define CEPH_XATTR_REPLACE 2
+#define CEPH_XATTR_CREATE  (1 << 0)
+#define CEPH_XATTR_REPLACE (1 << 1)
+#define CEPH_XATTR_REMOVE  (1 << 31)
 
 union ceph_mds_request_args {
         struct {
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 5c097596104b..9450f025fe0c 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -166,6 +166,8 @@ struct cgroup {
          *
          * The ID of the root cgroup is always 0, and a new cgroup
          * will be assigned with a smallest available ID.
+         *
+         * Allocating/Removing ID must be protected by cgroup_mutex.
          */
         int id;
 
diff --git a/include/linux/clk/ti.h b/include/linux/clk/ti.h
index 092b64168d7f..4a21a872dbbd 100644
--- a/include/linux/clk/ti.h
+++ b/include/linux/clk/ti.h
@@ -245,6 +245,10 @@ long omap2_dpll_round_rate(struct clk_hw *hw, unsigned long target_rate,
 void omap2_init_clk_clkdm(struct clk_hw *clk);
 unsigned long omap3_clkoutx2_recalc(struct clk_hw *hw,
                                     unsigned long parent_rate);
+int omap3_clkoutx2_set_rate(struct clk_hw *hw, unsigned long rate,
+                                        unsigned long parent_rate);
+long omap3_clkoutx2_round_rate(struct clk_hw *hw, unsigned long rate,
+                unsigned long *prate);
 int omap2_clkops_enable_clkdm(struct clk_hw *hw);
 void omap2_clkops_disable_clkdm(struct clk_hw *hw);
 int omap2_clk_disable_autoidle_all(void);
diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h
index 493aa021c7a9..2e4cb67f6e56 100644
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -62,6 +62,11 @@ enum clock_event_mode {
 #define CLOCK_EVT_FEAT_DYNIRQ           0x000020
 #define CLOCK_EVT_FEAT_PERCPU           0x000040
 
+/*
+ * Clockevent device is based on a hrtimer for broadcast
+ */
+#define CLOCK_EVT_FEAT_HRTIMER          0x000080
+
 /**
  * struct clock_event_device - clock event device descriptor
  * @event_handler:      Assigned by the framework to be called by the low
@@ -83,6 +88,7 @@ enum clock_event_mode {
  * @name:               ptr to clock event name
  * @rating:             variable to rate clock event devices
  * @irq:                IRQ number (only for non CPU local devices)
+ * @bound_on:           Bound on CPU
  * @cpumask:            cpumask to indicate for which CPUs this device works
  * @list:               list head for the management code
  * @owner:              module reference
@@ -113,6 +119,7 @@ struct clock_event_device {
         const char              *name;
         int                     rating;
         int                     irq;
+        int                     bound_on;
         const struct cpumask    *cpumask;
         struct list_head        list;
         struct module           *owner;
@@ -180,15 +187,17 @@ extern int tick_receive_broadcast(void);
 #endif
 
 #if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
+extern void tick_setup_hrtimer_broadcast(void);
 extern int tick_check_broadcast_expired(void);
 #else
 static inline int tick_check_broadcast_expired(void) { return 0; }
+static inline void tick_setup_hrtimer_broadcast(void) {};
 #endif
 
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
-extern void clockevents_notify(unsigned long reason, void *arg);
+extern int clockevents_notify(unsigned long reason, void *arg);
 #else
-static inline void clockevents_notify(unsigned long reason, void *arg) {}
+static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
 #endif
 
 #else /* CONFIG_GENERIC_CLOCKEVENTS_BUILD */
@@ -196,8 +205,9 @@ static inline void clockevents_notify(unsigned long reason, void *arg) {}
 static inline void clockevents_suspend(void) {}
 static inline void clockevents_resume(void) {}
 
-static inline void clockevents_notify(unsigned long reason, void *arg) {}
+static inline int clockevents_notify(unsigned long reason, void *arg) { return 0; }
 static inline int tick_check_broadcast_expired(void) { return 0; }
+static inline void tick_setup_hrtimer_broadcast(void) {};
 
 #endif
 
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 3f448c65511b..e6494261eaff 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -14,6 +14,7 @@
 #include <linux/if.h>
 #include <linux/fs.h>
 #include <linux/aio_abi.h>      /* for aio_context_t */
+#include <linux/unistd.h>
 
 #include <asm/compat.h>
 #include <asm/siginfo.h>
@@ -27,6 +28,9 @@
 #define __SC_DELOUSE(t,v) ((t)(unsigned long)(v))
 #endif
 
+#define COMPAT_SYSCALL_DEFINE0(name) \
+        asmlinkage long compat_sys_##name(void)
+
 #define COMPAT_SYSCALL_DEFINE1(name, ...) \
         COMPAT_SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
 #define COMPAT_SYSCALL_DEFINE2(name, ...) \
@@ -68,6 +72,8 @@ typedef struct compat_sigaltstack {
 typedef __compat_uid32_t        compat_uid_t;
 typedef __compat_gid32_t        compat_gid_t;
 
+typedef compat_ulong_t          compat_aio_context_t;
+
 struct compat_sel_arg_struct;
 struct rusage;
 
@@ -141,26 +147,23 @@ struct compat_sigaction {
 };
 
 /*
- * These functions operate strictly on struct compat_time*
- */
-extern int get_compat_timespec(struct timespec *,
-                               const struct compat_timespec __user *);
-extern int put_compat_timespec(const struct timespec *,
-                               struct compat_timespec __user *);
-extern int get_compat_timeval(struct timeval *,
-                              const struct compat_timeval __user *);
-extern int put_compat_timeval(const struct timeval *,
-                              struct compat_timeval __user *);
-/*
  * These functions operate on 32- or 64-bit specs depending on
- * COMPAT_USE_64BIT_TIME, hence the void user pointer arguments and the
- * naming as compat_get/put_ rather than get/put_compat_.
+ * COMPAT_USE_64BIT_TIME, hence the void user pointer arguments.
  */
 extern int compat_get_timespec(struct timespec *, const void __user *);
 extern int compat_put_timespec(const struct timespec *, void __user *);
 extern int compat_get_timeval(struct timeval *, const void __user *);
 extern int compat_put_timeval(const struct timeval *, void __user *);
 
+/*
+ * This function convert a timespec if necessary and returns a *user
+ * space* pointer.  If no conversion is necessary, it returns the
+ * initial pointer.  NULL is a legitimate argument and will always
+ * output NULL.
+ */
+extern int compat_convert_timespec(struct timespec __user **,
+                                   const void __user *);
+
 struct compat_iovec {
         compat_uptr_t   iov_base;
         compat_size_t   iov_len;
@@ -318,7 +321,7 @@ asmlinkage long compat_sys_semctl(int semid, int semnum, int cmd, int arg);
 asmlinkage long compat_sys_msgsnd(int msqid, compat_uptr_t msgp,
                 compat_ssize_t msgsz, int msgflg);
 asmlinkage long compat_sys_msgrcv(int msqid, compat_uptr_t msgp,
-                compat_ssize_t msgsz, long msgtyp, int msgflg);
+                compat_ssize_t msgsz, compat_long_t msgtyp, int msgflg);
 long compat_sys_msgctl(int first, int second, void __user *uptr);
 long compat_sys_shmctl(int first, int second, void __user *uptr);
 long compat_sys_semtimedop(int semid, struct sembuf __user *tsems,
@@ -337,6 +340,19 @@ asmlinkage ssize_t compat_sys_preadv(compat_ulong_t fd,
 asmlinkage ssize_t compat_sys_pwritev(compat_ulong_t fd,
                 const struct compat_iovec __user *vec,
                 compat_ulong_t vlen, u32 pos_low, u32 pos_high);
+
+#ifdef __ARCH_WANT_COMPAT_SYS_PREADV64
+asmlinkage long compat_sys_preadv64(unsigned long fd,
+                const struct compat_iovec __user *vec,
+                unsigned long vlen, loff_t pos);
+#endif
+
+#ifdef __ARCH_WANT_COMPAT_SYS_PWRITEV64
+asmlinkage long compat_sys_pwritev64(unsigned long fd,
+                const struct compat_iovec __user *vec,
+                unsigned long vlen, loff_t pos);
+#endif
+
 asmlinkage long compat_sys_lseek(unsigned int, compat_off_t, unsigned int);
 
 asmlinkage long compat_sys_execve(const char __user *filename, const compat_uptr_t __user *argv,
@@ -451,7 +467,7 @@ asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
 asmlinkage long compat_sys_timerfd_gettime(int ufd,
                                    struct compat_itimerspec __user *otmr);
 
-asmlinkage long compat_sys_move_pages(pid_t pid, unsigned long nr_page,
+asmlinkage long compat_sys_move_pages(pid_t pid, compat_ulong_t nr_pages,
                                       __u32 __user *pages,
                                       const int __user *nodes,
                                       int __user *status,
@@ -481,20 +497,20 @@ asmlinkage long compat_sys_statfs64(const char __user *pathname,
 asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
                                      struct compat_statfs64 __user *buf);
 asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
-                                   unsigned long arg);
+                                   compat_ulong_t arg);
 asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
-                                 unsigned long arg);
+                                 compat_ulong_t arg);
 asmlinkage long compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p);
-asmlinkage long compat_sys_io_getevents(aio_context_t ctx_id,
-                                        unsigned long min_nr,
-                                        unsigned long nr,
+asmlinkage long compat_sys_io_getevents(compat_aio_context_t ctx_id,
+                                        compat_long_t min_nr,
+                                        compat_long_t nr,
                                         struct io_event __user *events,
                                         struct compat_timespec __user *timeout);
-asmlinkage long compat_sys_io_submit(aio_context_t ctx_id, int nr,
+asmlinkage long compat_sys_io_submit(compat_aio_context_t ctx_id, int nr,
                                      u32 __user *iocb);
 asmlinkage long compat_sys_mount(const char __user *dev_name,
                                  const char __user *dir_name,
-                                 const char __user *type, unsigned long flags,
+                                 const char __user *type, compat_ulong_t flags,
                                  const void __user *data);
 asmlinkage long compat_sys_old_readdir(unsigned int fd,
                                        struct compat_old_linux_dirent __user *,
@@ -502,9 +518,11 @@ asmlinkage long compat_sys_old_readdir(unsigned int fd,
 asmlinkage long compat_sys_getdents(unsigned int fd,
                                     struct compat_linux_dirent __user *dirent,
                                     unsigned int count);
+#ifdef __ARCH_WANT_COMPAT_SYS_GETDENTS64
 asmlinkage long compat_sys_getdents64(unsigned int fd,
                                       struct linux_dirent64 __user *dirent,
                                       unsigned int count);
+#endif
 asmlinkage long compat_sys_vmsplice(int fd, const struct compat_iovec __user *,
                                     unsigned int nr_segs, unsigned int flags);
 asmlinkage long compat_sys_open(const char __user *filename, int flags,
@@ -549,9 +567,9 @@ asmlinkage long compat_sys_sendmmsg(int fd, struct compat_mmsghdr __user *mmsg,
                                     unsigned vlen, unsigned int flags);
 asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg,
                                    unsigned int flags);
-asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len,
+asmlinkage long compat_sys_recv(int fd, void __user *buf, compat_size_t len,
                                 unsigned flags);
-asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, size_t len,
+asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, compat_size_t len,
                             unsigned flags, struct sockaddr __user *addr,
                             int __user *addrlen);
 asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
@@ -615,16 +633,16 @@ asmlinkage long compat_sys_rt_sigqueueinfo(compat_pid_t pid, int sig,
                                 struct compat_siginfo __user *uinfo);
 asmlinkage long compat_sys_sysinfo(struct compat_sysinfo __user *info);
 asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
-                                 unsigned long arg);
+                                 compat_ulong_t arg);
 asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, u32 val,
                 struct compat_timespec __user *utime, u32 __user *uaddr2,
                 u32 val3);
 asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,
                                       char __user *optval, int __user *optlen);
-asmlinkage long compat_sys_kexec_load(unsigned long entry,
-                                      unsigned long nr_segments,
+asmlinkage long compat_sys_kexec_load(compat_ulong_t entry,
+                                      compat_ulong_t nr_segments,
                                       struct compat_kexec_segment __user *,
-                                      unsigned long flags);
+                                      compat_ulong_t flags);
 asmlinkage long compat_sys_mq_getsetattr(mqd_t mqdes,
                         const struct compat_mq_attr __user *u_mqstat,
                         struct compat_mq_attr __user *u_omqstat);
@@ -635,11 +653,11 @@ asmlinkage long compat_sys_mq_open(const char __user *u_name,
                         struct compat_mq_attr __user *u_attr);
 asmlinkage long compat_sys_mq_timedsend(mqd_t mqdes,
                         const char __user *u_msg_ptr,
-                        size_t msg_len, unsigned int msg_prio,
+                        compat_size_t msg_len, unsigned int msg_prio,
                         const struct compat_timespec __user *u_abs_timeout);
 asmlinkage ssize_t compat_sys_mq_timedreceive(mqd_t mqdes,
                         char __user *u_msg_ptr,
-                        size_t msg_len, unsigned int __user *u_msg_prio,
+                        compat_size_t msg_len, unsigned int __user *u_msg_prio,
                         const struct compat_timespec __user *u_abs_timeout);
 asmlinkage long compat_sys_socketcall(int call, u32 __user *args);
 asmlinkage long compat_sys_sysctl(struct compat_sysctl_args __user *args);
@@ -654,12 +672,12 @@ extern void __user *compat_alloc_user_space(unsigned long len);
 
 asmlinkage ssize_t compat_sys_process_vm_readv(compat_pid_t pid,
                 const struct compat_iovec __user *lvec,
-                unsigned long liovcnt, const struct compat_iovec __user *rvec,
-                unsigned long riovcnt, unsigned long flags);
+                compat_ulong_t liovcnt, const struct compat_iovec __user *rvec,
+                compat_ulong_t riovcnt, compat_ulong_t flags);
 asmlinkage ssize_t compat_sys_process_vm_writev(compat_pid_t pid,
                 const struct compat_iovec __user *lvec,
-                unsigned long liovcnt, const struct compat_iovec __user *rvec,
-                unsigned long riovcnt, unsigned long flags);
+                compat_ulong_t liovcnt, const struct compat_iovec __user *rvec,
+                compat_ulong_t riovcnt, compat_ulong_t flags);
 
 asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
                                     compat_off_t __user *offset, compat_size_t count);
diff --git a/include/linux/connector.h b/include/linux/connector.h
index b2b5a41b6a24..be9c4747d511 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -71,7 +71,7 @@ struct cn_dev {
 int cn_add_callback(struct cb_id *id, const char *name,
                     void (*callback)(struct cn_msg *, struct netlink_skb_parms *));
 void cn_del_callback(struct cb_id *);
-int cn_netlink_send(struct cn_msg *, u32, gfp_t);
+int cn_netlink_send(struct cn_msg *msg, u32 portid, u32 group, gfp_t gfp_mask);
 
 int cn_queue_add_callback(struct cn_queue_dev *dev, const char *name,
                           struct cb_id *id,
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 03e235ad1bba..03e962e23eaf 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -46,13 +46,6 @@ extern ssize_t arch_cpu_release(const char *, size_t);
 #endif
 struct notifier_block;
 
-#ifdef CONFIG_ARCH_HAS_CPU_AUTOPROBE
-extern int arch_cpu_uevent(struct device *dev, struct kobj_uevent_env *env);
-extern ssize_t arch_print_cpu_modalias(struct device *dev,
-                                       struct device_attribute *attr,
-                                       char *bufptr);
-#endif
-
 /*
  * CPU notifier priorities.
  */
diff --git a/include/linux/cpufeature.h b/include/linux/cpufeature.h
new file mode 100644
index 000000000000..c4d4eb8ac9fe
--- /dev/null
+++ b/include/linux/cpufeature.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2014 Linaro Ltd. <ard.biesheuvel@linaro.org>
+ *
+ * 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.
+ */
+
+#ifndef __LINUX_CPUFEATURE_H
+#define __LINUX_CPUFEATURE_H
+
+#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
+
+#include <linux/mod_devicetable.h>
+#include <asm/cpufeature.h>
+
+/*
+ * Macros imported from <asm/cpufeature.h>:
+ * - cpu_feature(x)             ordinal value of feature called 'x'
+ * - cpu_have_feature(u32 n)    whether feature #n is available
+ * - MAX_CPU_FEATURES           upper bound for feature ordinal values
+ * Optional:
+ * - CPU_FEATURE_TYPEFMT        format string fragment for printing the cpu type
+ * - CPU_FEATURE_TYPEVAL        set of values matching the format string above
+ */
+
+#ifndef CPU_FEATURE_TYPEFMT
+#define CPU_FEATURE_TYPEFMT     "%s"
+#endif
+
+#ifndef CPU_FEATURE_TYPEVAL
+#define CPU_FEATURE_TYPEVAL     ELF_PLATFORM
+#endif
+
+/*
+ * Use module_cpu_feature_match(feature, module_init_function) to
+ * declare that
+ * a) the module shall be probed upon discovery of CPU feature 'feature'
+ *    (typically at boot time using udev)
+ * b) the module must not be loaded if CPU feature 'feature' is not present
+ *    (not even by manual insmod).
+ *
+ * For a list of legal values for 'feature', please consult the file
+ * 'asm/cpufeature.h' of your favorite architecture.
+ */
+#define module_cpu_feature_match(x, __init)                     \
+static struct cpu_feature const cpu_feature_match_ ## x[] =     \
+        { { .feature = cpu_feature(x) }, { } };                 \
+MODULE_DEVICE_TABLE(cpu, cpu_feature_match_ ## x);              \
+                                                                \
+static int cpu_feature_match_ ## x ## _init(void)               \
+{                                                               \
+        if (!cpu_have_feature(cpu_feature(x)))                  \
+                return -ENODEV;                                 \
+        return __init();                                        \
+}                                                               \
+module_init(cpu_feature_match_ ## x ## _init)
+
+#endif
+#endif
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 4d89e0e6f9cc..c48e595f623e 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -16,6 +16,7 @@
 #include <linux/completion.h>
 #include <linux/kobject.h>
 #include <linux/notifier.h>
+#include <linux/spinlock.h>
 #include <linux/sysfs.h>
 
 /*********************************************************************
@@ -74,6 +75,8 @@ struct cpufreq_policy {
         unsigned int            max;    /* in kHz */
         unsigned int            cur;    /* in kHz, only needed if cpufreq
                                          * governors are used */
+        unsigned int            suspend_freq; /* freq to set during suspend */
+
         unsigned int            policy; /* see above */
         struct cpufreq_governor *governor; /* see below */
         void                    *governor_data;
@@ -83,6 +86,7 @@ struct cpufreq_policy {
                                          * called, but you're in IRQ context */
 
         struct cpufreq_real_policy      user_policy;
+        struct cpufreq_frequency_table  *freq_table;
 
         struct list_head        policy_list;
         struct kobject          kobj;
@@ -101,6 +105,11 @@ struct cpufreq_policy {
          *     __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT);
          */
         struct rw_semaphore     rwsem;
+
+        /* Synchronization for frequency transitions */
+        bool                    transition_ongoing; /* Tracks transition status */
+        spinlock_t              transition_lock;
+        wait_queue_head_t       transition_wait;
 };
 
 /* Only for ACPI */
@@ -224,6 +233,7 @@ struct cpufreq_driver {
         int     (*bios_limit)   (int cpu, unsigned int *limit);
 
         int     (*exit)         (struct cpufreq_policy *policy);
+        void    (*stop_cpu)     (struct cpufreq_policy *policy);
         int     (*suspend)      (struct cpufreq_policy *policy);
         int     (*resume)       (struct cpufreq_policy *policy);
         struct freq_attr        **attr;
@@ -296,6 +306,15 @@ cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
                         policy->cpuinfo.max_freq);
 }
 
+#ifdef CONFIG_CPU_FREQ
+void cpufreq_suspend(void);
+void cpufreq_resume(void);
+int cpufreq_generic_suspend(struct cpufreq_policy *policy);
+#else
+static inline void cpufreq_suspend(void) {}
+static inline void cpufreq_resume(void) {}
+#endif
+
 /*********************************************************************
  *                     CPUFREQ NOTIFIER INTERFACE                    *
  *********************************************************************/
@@ -306,8 +325,6 @@ cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
 /* Transition notifiers */
 #define CPUFREQ_PRECHANGE               (0)
 #define CPUFREQ_POSTCHANGE              (1)
-#define CPUFREQ_RESUMECHANGE            (8)
-#define CPUFREQ_SUSPENDCHANGE           (9)
 
 /* Policy Notifiers  */
 #define CPUFREQ_ADJUST                  (0)
@@ -322,9 +339,9 @@ cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy)
 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
 
-void cpufreq_notify_transition(struct cpufreq_policy *policy,
-                struct cpufreq_freqs *freqs, unsigned int state);
-void cpufreq_notify_post_transition(struct cpufreq_policy *policy,
+void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
+                struct cpufreq_freqs *freqs);
+void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
                 struct cpufreq_freqs *freqs, int transition_failed);
 
 #else /* CONFIG_CPU_FREQ */
@@ -463,7 +480,6 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
                 unsigned int freq);
 
-void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy);
 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
 
 #ifdef CONFIG_CPU_FREQ
@@ -490,9 +506,6 @@ struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
 /* the following are really really optional */
 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
 extern struct freq_attr *cpufreq_generic_attr[];
-void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
-                                      unsigned int cpu);
-void cpufreq_frequency_table_put_attr(unsigned int cpu);
 int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
                                       struct cpufreq_frequency_table *table);
 
@@ -500,10 +513,4 @@ unsigned int cpufreq_generic_get(unsigned int cpu);
 int cpufreq_generic_init(struct cpufreq_policy *policy,
                 struct cpufreq_frequency_table *table,
                 unsigned int transition_latency);
-static inline int cpufreq_generic_exit(struct cpufreq_policy *policy)
-{
-        cpufreq_frequency_table_put_attr(policy->cpu);
-        return 0;
-}
-
 #endif /* _LINUX_CPUFREQ_H */
diff --git a/include/linux/cputime.h b/include/linux/cputime.h
new file mode 100644
index 000000000000..f2eb2ee535ca
--- /dev/null
+++ b/include/linux/cputime.h
@@ -0,0 +1,16 @@
+#ifndef __LINUX_CPUTIME_H
+#define __LINUX_CPUTIME_H
+
+#include <asm/cputime.h>
+
+#ifndef cputime_to_nsecs
+# define cputime_to_nsecs(__ct) \
+        (cputime_to_usecs(__ct) * NSEC_PER_USEC)
+#endif
+
+#ifndef nsecs_to_cputime
+# define nsecs_to_cputime(__nsecs)      \
+        usecs_to_cputime((__nsecs) / NSEC_PER_USEC)
+#endif
+
+#endif /* __LINUX_CPUTIME_H */
diff --git a/include/linux/device.h b/include/linux/device.h
index 952b01033c32..233bbbeb768d 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -560,6 +560,8 @@ extern int device_create_file(struct device *device,
                               const struct device_attribute *entry);
 extern void device_remove_file(struct device *dev,
                                const struct device_attribute *attr);
+extern bool device_remove_file_self(struct device *dev,
+                                    const struct device_attribute *attr);
 extern int __must_check device_create_bin_file(struct device *dev,
                                         const struct bin_attribute *attr);
 extern void device_remove_bin_file(struct device *dev,
@@ -626,6 +628,7 @@ static inline void *devm_kcalloc(struct device *dev,
         return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
 }
 extern void devm_kfree(struct device *dev, void *p);
+extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp);
 
 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
 void __iomem *devm_request_and_ioremap(struct device *dev,
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index dfac5ed31120..f886985a28b2 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -171,7 +171,7 @@ struct dma_buf *dma_buf_export_named(void *priv, const struct dma_buf_ops *ops,
                                size_t size, int flags, const char *);
 
 #define dma_buf_export(priv, ops, size, flags)  \
-        dma_buf_export_named(priv, ops, size, flags, __FILE__)
+        dma_buf_export_named(priv, ops, size, flags, KBUILD_MODNAME)
 
 int dma_buf_fd(struct dma_buf *dmabuf, int flags);
 struct dma_buf *dma_buf_get(int fd);
diff --git a/include/linux/drbd.h b/include/linux/drbd.h
index de7d74ab3de6..3dbe9bd57a09 100644
--- a/include/linux/drbd.h
+++ b/include/linux/drbd.h
@@ -327,12 +327,6 @@ enum drbd_state_rv {
         SS_AFTER_LAST_ERROR = -22,    /* Keep this at bottom */
 };
 
-/* from drbd_strings.c */
-extern const char *drbd_conn_str(enum drbd_conns);
-extern const char *drbd_role_str(enum drbd_role);
-extern const char *drbd_disk_str(enum drbd_disk_state);
-extern const char *drbd_set_st_err_str(enum drbd_state_rv);
-
 #define SHARED_SECRET_MAX 64
 
 #define MDF_CONSISTENT          (1 << 0)
@@ -382,4 +376,6 @@ enum drbd_timeout_flag {
 #define DRBD_MD_INDEX_FLEX_EXT -2
 #define DRBD_MD_INDEX_FLEX_INT -3
 
+#define DRBD_CPU_MASK_SIZE 32
+
 #endif
diff --git a/include/linux/drbd_genl.h b/include/linux/drbd_genl.h
index e8c44572b8cb..4193f5f2636c 100644
--- a/include/linux/drbd_genl.h
+++ b/include/linux/drbd_genl.h
@@ -135,7 +135,7 @@ GENL_struct(DRBD_NLA_DISK_CONF, 3, disk_conf,
 )
 
 GENL_struct(DRBD_NLA_RESOURCE_OPTS, 4, res_opts,
-        __str_field_def(1,      DRBD_GENLA_F_MANDATORY, cpu_mask,       32)
+        __str_field_def(1,      DRBD_GENLA_F_MANDATORY, cpu_mask,       DRBD_CPU_MASK_SIZE)
         __u32_field_def(2,      DRBD_GENLA_F_MANDATORY, on_no_data, DRBD_ON_NO_DATA_DEF)
 )
 
@@ -276,9 +276,9 @@ GENL_op(
 )
 
         /* add DRBD minor devices as volumes to resources */
-GENL_op(DRBD_ADM_NEW_MINOR, 5, GENL_doit(drbd_adm_add_minor),
+GENL_op(DRBD_ADM_NEW_MINOR, 5, GENL_doit(drbd_adm_new_minor),
         GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_F_REQUIRED))
-GENL_op(DRBD_ADM_DEL_MINOR, 6, GENL_doit(drbd_adm_delete_minor),
+GENL_op(DRBD_ADM_DEL_MINOR, 6, GENL_doit(drbd_adm_del_minor),
         GENL_tla_expected(DRBD_NLA_CFG_CONTEXT, DRBD_F_REQUIRED))
 
         /* add or delete resources */
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 0a819e7a60c9..6c100ff0cae4 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -153,6 +153,102 @@ typedef struct {
         u8 sets_to_zero;
 } efi_time_cap_t;
 
+typedef struct {
+        efi_table_hdr_t hdr;
+        u32 raise_tpl;
+        u32 restore_tpl;
+        u32 allocate_pages;
+        u32 free_pages;
+        u32 get_memory_map;
+        u32 allocate_pool;
+        u32 free_pool;
+        u32 create_event;
+        u32 set_timer;
+        u32 wait_for_event;
+        u32 signal_event;
+        u32 close_event;
+        u32 check_event;
+        u32 install_protocol_interface;
+        u32 reinstall_protocol_interface;
+        u32 uninstall_protocol_interface;
+        u32 handle_protocol;
+        u32 __reserved;
+        u32 register_protocol_notify;
+        u32 locate_handle;
+        u32 locate_device_path;
+        u32 install_configuration_table;
+        u32 load_image;
+        u32 start_image;
+        u32 exit;
+        u32 unload_image;
+        u32 exit_boot_services;
+        u32 get_next_monotonic_count;
+        u32 stall;
+        u32 set_watchdog_timer;
+        u32 connect_controller;
+        u32 disconnect_controller;
+        u32 open_protocol;
+        u32 close_protocol;
+        u32 open_protocol_information;
+        u32 protocols_per_handle;
+        u32 locate_handle_buffer;
+        u32 locate_protocol;
+        u32 install_multiple_protocol_interfaces;
+        u32 uninstall_multiple_protocol_interfaces;
+        u32 calculate_crc32;
+        u32 copy_mem;
+        u32 set_mem;
+        u32 create_event_ex;
+} __packed efi_boot_services_32_t;
+
+typedef struct {
+        efi_table_hdr_t hdr;
+        u64 raise_tpl;
+        u64 restore_tpl;
+        u64 allocate_pages;
+        u64 free_pages;
+        u64 get_memory_map;
+        u64 allocate_pool;
+        u64 free_pool;
+        u64 create_event;
+        u64 set_timer;
+        u64 wait_for_event;
+        u64 signal_event;
+        u64 close_event;
+        u64 check_event;
+        u64 install_protocol_interface;
+        u64 reinstall_protocol_interface;
+        u64 uninstall_protocol_interface;
+        u64 handle_protocol;
+        u64 __reserved;
+        u64 register_protocol_notify;
+        u64 locate_handle;
+        u64 locate_device_path;
+        u64 install_configuration_table;
+        u64 load_image;
+        u64 start_image;
+        u64 exit;
+        u64 unload_image;
+        u64 exit_boot_services;
+        u64 get_next_monotonic_count;
+        u64 stall;
+        u64 set_watchdog_timer;
+        u64 connect_controller;
+        u64 disconnect_controller;
+        u64 open_protocol;
+        u64 close_protocol;
+        u64 open_protocol_information;
+        u64 protocols_per_handle;
+        u64 locate_handle_buffer;
+        u64 locate_protocol;
+        u64 install_multiple_protocol_interfaces;
+        u64 uninstall_multiple_protocol_interfaces;
+        u64 calculate_crc32;
+        u64 copy_mem;
+        u64 set_mem;
+        u64 create_event_ex;
+} __packed efi_boot_services_64_t;
+
 /*
  * EFI Boot Services table
  */
@@ -231,6 +327,15 @@ typedef enum {
     EfiPciIoAttributeOperationMaximum
 } EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION;
 
+typedef struct {
+        u32 read;
+        u32 write;
+} efi_pci_io_protocol_access_32_t;
+
+typedef struct {
+        u64 read;
+        u64 write;
+} efi_pci_io_protocol_access_64_t;
 
 typedef struct {
         void *read;
@@ -238,6 +343,46 @@ typedef struct {
 } efi_pci_io_protocol_access_t;
 
 typedef struct {
+        u32 poll_mem;
+        u32 poll_io;
+        efi_pci_io_protocol_access_32_t mem;
+        efi_pci_io_protocol_access_32_t io;
+        efi_pci_io_protocol_access_32_t pci;
+        u32 copy_mem;
+        u32 map;
+        u32 unmap;
+        u32 allocate_buffer;
+        u32 free_buffer;
+        u32 flush;
+        u32 get_location;
+        u32 attributes;
+        u32 get_bar_attributes;
+        u32 set_bar_attributes;
+        uint64_t romsize;
+        void *romimage;
+} efi_pci_io_protocol_32;
+
+typedef struct {
+        u64 poll_mem;
+        u64 poll_io;
+        efi_pci_io_protocol_access_64_t mem;
+        efi_pci_io_protocol_access_64_t io;
+        efi_pci_io_protocol_access_64_t pci;
+        u64 copy_mem;
+        u64 map;
+        u64 unmap;
+        u64 allocate_buffer;
+        u64 free_buffer;
+        u64 flush;
+        u64 get_location;
+        u64 attributes;
+        u64 get_bar_attributes;
+        u64 set_bar_attributes;
+        uint64_t romsize;
+        void *romimage;
+} efi_pci_io_protocol_64;
+
+typedef struct {
         void *poll_mem;
         void *poll_io;
         efi_pci_io_protocol_access_t mem;
@@ -292,6 +437,42 @@ typedef struct {
 
 typedef struct {
         efi_table_hdr_t hdr;
+        u32 get_time;
+        u32 set_time;
+        u32 get_wakeup_time;
+        u32 set_wakeup_time;
+        u32 set_virtual_address_map;
+        u32 convert_pointer;
+        u32 get_variable;
+        u32 get_next_variable;
+        u32 set_variable;
+        u32 get_next_high_mono_count;
+        u32 reset_system;
+        u32 update_capsule;
+        u32 query_capsule_caps;
+        u32 query_variable_info;
+} efi_runtime_services_32_t;
+
+typedef struct {
+        efi_table_hdr_t hdr;
+        u64 get_time;
+        u64 set_time;
+        u64 get_wakeup_time;
+        u64 set_wakeup_time;
+        u64 set_virtual_address_map;
+        u64 convert_pointer;
+        u64 get_variable;
+        u64 get_next_variable;
+        u64 set_variable;
+        u64 get_next_high_mono_count;
+        u64 reset_system;
+        u64 update_capsule;
+        u64 query_capsule_caps;
+        u64 query_variable_info;
+} efi_runtime_services_64_t;
+
+typedef struct {
+        efi_table_hdr_t hdr;
         void *get_time;
         void *set_time;
         void *get_wakeup_time;
@@ -485,6 +666,38 @@ struct efi_memory_map {
 
 typedef struct {
         u32 revision;
+        u32 parent_handle;
+        u32 system_table;
+        u32 device_handle;
+        u32 file_path;
+        u32 reserved;
+        u32 load_options_size;
+        u32 load_options;
+        u32 image_base;
+        __aligned_u64 image_size;
+        unsigned int image_code_type;
+        unsigned int image_data_type;
+        unsigned long unload;
+} efi_loaded_image_32_t;
+
+typedef struct {
+        u32 revision;
+        u64 parent_handle;
+        u64 system_table;
+        u64 device_handle;
+        u64 file_path;
+        u64 reserved;
+        u32 load_options_size;
+        u64 load_options;
+        u64 image_base;
+        __aligned_u64 image_size;
+        unsigned int image_code_type;
+        unsigned int image_data_type;
+        unsigned long unload;
+} efi_loaded_image_64_t;
+
+typedef struct {
+        u32 revision;
         void *parent_handle;
         efi_system_table_t *system_table;
         void *device_handle;
@@ -511,6 +724,34 @@ typedef struct {
         efi_char16_t filename[1];
 } efi_file_info_t;
 
+typedef struct {
+        u64 revision;
+        u32 open;
+        u32 close;
+        u32 delete;
+        u32 read;
+        u32 write;
+        u32 get_position;
+        u32 set_position;
+        u32 get_info;
+        u32 set_info;
+        u32 flush;
+} efi_file_handle_32_t;
+
+typedef struct {
+        u64 revision;
+        u64 open;
+        u64 close;
+        u64 delete;
+        u64 read;
+        u64 write;
+        u64 get_position;
+        u64 set_position;
+        u64 get_info;
+        u64 set_info;
+        u64 flush;
+} efi_file_handle_64_t;
+
 typedef struct _efi_file_handle {
         u64 revision;
         efi_status_t (*open)(struct _efi_file_handle *,
@@ -573,6 +814,7 @@ extern struct efi {
         efi_reset_system_t *reset_system;
         efi_set_virtual_address_map_t *set_virtual_address_map;
         struct efi_memory_map *memmap;
+        unsigned long flags;
 } efi;
 
 static inline int
@@ -659,18 +901,17 @@ extern int __init efi_setup_pcdp_console(char *);
 #define EFI_ARCH_1              6       /* First arch-specific bit */
 
 #ifdef CONFIG_EFI
-# ifdef CONFIG_X86
-extern int efi_enabled(int facility);
-# else
-static inline int efi_enabled(int facility)
+/*
+ * Test whether the above EFI_* bits are enabled.
+ */
+static inline bool efi_enabled(int feature)
 {
-        return 1;
+        return test_bit(feature, &efi.flags) != 0;
 }
-# endif
 #else
-static inline int efi_enabled(int facility)
+static inline bool efi_enabled(int feature)
 {
-        return 0;
+        return false;
 }
 #endif
 
@@ -809,6 +1050,17 @@ struct efivar_entry {
         bool deleting;
 };
 
+struct efi_simple_text_output_protocol_32 {
+        u32 reset;
+        u32 output_string;
+        u32 test_string;
+};
+
+struct efi_simple_text_output_protocol_64 {
+        u64 reset;
+        u64 output_string;
+        u64 test_string;
+};
 
 struct efi_simple_text_output_protocol {
         void *reset;
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 306dd8cd0b6f..df63bd3a8cf1 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -202,17 +202,8 @@ enum {
 #define rq_end_sector(rq)       (blk_rq_pos(rq) + blk_rq_sectors(rq))
 #define rb_entry_rq(node)       rb_entry((node), struct request, rb_node)
 
-/*
- * Hack to reuse the csd.list list_head as the fifo time holder while
- * the request is in the io scheduler. Saves an unsigned long in rq.
- */
-#define rq_fifo_time(rq)        ((unsigned long) (rq)->csd.list.next)
-#define rq_set_fifo_time(rq,exp)        ((rq)->csd.list.next = (void *) (exp))
 #define rq_entry_fifo(ptr)      list_entry((ptr), struct request, queuelist)
-#define rq_fifo_clear(rq)       do {            \
-        list_del_init(&(rq)->queuelist);        \
-        INIT_LIST_HEAD(&(rq)->csd.list);        \
-        } while (0)
+#define rq_fifo_clear(rq)       list_del_init(&(rq)->queuelist)
 
 #else /* CONFIG_BLOCK */
 
diff --git a/include/linux/extcon.h b/include/linux/extcon.h
index 21c59af1150b..f488145bb2d4 100644
--- a/include/linux/extcon.h
+++ b/include/linux/extcon.h
@@ -240,6 +240,12 @@ extern int extcon_register_notifier(struct extcon_dev *edev,
                                     struct notifier_block *nb);
 extern int extcon_unregister_notifier(struct extcon_dev *edev,
                                       struct notifier_block *nb);
+
+/*
+ * Following API get the extcon device from devicetree.
+ * This function use phandle of devicetree to get extcon device directly.
+ */
+extern struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev, int index);
 #else /* CONFIG_EXTCON */
 static inline int extcon_dev_register(struct extcon_dev *edev)
 {
@@ -324,5 +330,11 @@ static inline int extcon_unregister_interest(struct extcon_specific_cable_nb
 {
         return 0;
 }
+
+static inline struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev,
+                                                            int index)
+{
+        return ERR_PTR(-ENODEV);
+}
 #endif /* CONFIG_EXTCON */
 #endif /* __LINUX_EXTCON_H__ */
diff --git a/include/linux/extcon/of_extcon.h b/include/linux/extcon/of_extcon.h
deleted file mode 100644
index 0ebfeff1b55d..000000000000
--- a/include/linux/extcon/of_extcon.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * OF helpers for External connector (extcon) framework
- *
- * Copyright (C) 2013 Texas Instruments, Inc.
- * Kishon Vijay Abraham I <kishon@ti.com>
- *
- * Copyright (C) 2013 Samsung Electronics
- * Chanwoo Choi <cw00.choi@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-
-#ifndef __LINUX_OF_EXTCON_H
-#define __LINUX_OF_EXTCON_H
-
-#include <linux/err.h>
-
-#if IS_ENABLED(CONFIG_OF_EXTCON)
-extern struct extcon_dev
-        *of_extcon_get_extcon_dev(struct device *dev, int index);
-#else
-static inline struct extcon_dev
-        *of_extcon_get_extcon_dev(struct device *dev, int index)
-{
-        return ERR_PTR(-ENOSYS);
-}
-#endif /* CONFIG_OF_EXTCON */
-#endif /* __LINUX_OF_EXTCON_H */
diff --git a/include/linux/file.h b/include/linux/file.h
index cbacf4faf447..4d69123377a2 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -28,33 +28,36 @@ static inline void fput_light(struct file *file, int fput_needed)
 
 struct fd {
         struct file *file;
-        int need_put;
+        unsigned int flags;
 };
+#define FDPUT_FPUT       1
+#define FDPUT_POS_UNLOCK 2
 
 static inline void fdput(struct fd fd)
 {
-        if (fd.need_put)
+        if (fd.flags & FDPUT_FPUT)
                 fput(fd.file);
 }
 
 extern struct file *fget(unsigned int fd);
-extern struct file *fget_light(unsigned int fd, int *fput_needed);
+extern struct file *fget_raw(unsigned int fd);
+extern unsigned long __fdget(unsigned int fd);
+extern unsigned long __fdget_raw(unsigned int fd);
+extern unsigned long __fdget_pos(unsigned int fd);
 
-static inline struct fd fdget(unsigned int fd)
+static inline struct fd __to_fd(unsigned long v)
 {
-        int b;
-        struct file *f = fget_light(fd, &b);
-        return (struct fd){f,b};
+        return (struct fd){(struct file *)(v & ~3),v & 3};
 }
 
-extern struct file *fget_raw(unsigned int fd);
-extern struct file *fget_raw_light(unsigned int fd, int *fput_needed);
+static inline struct fd fdget(unsigned int fd)
+{
+        return __to_fd(__fdget(fd));
+}
 
 static inline struct fd fdget_raw(unsigned int fd)
 {
-        int b;
-        struct file *f = fget_raw_light(fd, &b);
-        return (struct fd){f,b};
+        return __to_fd(__fdget_raw(fd));
 }
 
 extern int f_dupfd(unsigned int from, struct file *file, unsigned flags);
diff --git a/include/linux/firewire.h b/include/linux/firewire.h
index 5d7782e42b8f..c3683bdf28fe 100644
--- a/include/linux/firewire.h
+++ b/include/linux/firewire.h
@@ -200,6 +200,7 @@ struct fw_device {
         unsigned irmc:1;
         unsigned bc_implemented:2;
 
+        work_func_t workfn;
         struct delayed_work work;
         struct fw_attribute_group attribute_group;
 };
diff --git a/include/linux/fmc-sdb.h b/include/linux/fmc-sdb.h
index 1974317a9b3d..599bd6bab56d 100644
--- a/include/linux/fmc-sdb.h
+++ b/include/linux/fmc-sdb.h
@@ -14,6 +14,8 @@ union sdb_record {
         struct sdb_bridge bridge;
         struct sdb_integration integr;
         struct sdb_empty empty;
+        struct sdb_synthesis synthesis;
+        struct sdb_repo_url repo_url;
 };
 
 struct fmc_device;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 60829565e552..23b2a35d712e 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -123,6 +123,9 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 /* File is opened with O_PATH; almost nothing can be done with it */
 #define FMODE_PATH              ((__force fmode_t)0x4000)
 
+/* File needs atomic accesses to f_pos */
+#define FMODE_ATOMIC_POS        ((__force fmode_t)0x8000)
+
 /* File was opened by fanotify and shouldn't generate fanotify events */
 #define FMODE_NONOTIFY          ((__force fmode_t)0x1000000)
 
@@ -780,13 +783,14 @@ struct file {
         const struct file_operations    *f_op;
 
         /*
-         * Protects f_ep_links, f_flags, f_pos vs i_size in lseek SEEK_CUR.
+         * Protects f_ep_links, f_flags.
          * Must not be taken from IRQ context.
          */
         spinlock_t              f_lock;
         atomic_long_t           f_count;
         unsigned int            f_flags;
         fmode_t                 f_mode;
+        struct mutex            f_pos_lock;
         loff_t                  f_pos;
         struct fown_struct      f_owner;
         const struct cred       *f_cred;
@@ -808,7 +812,7 @@ struct file {
 #ifdef CONFIG_DEBUG_WRITECOUNT
         unsigned long f_mnt_write_state;
 #endif
-};
+} __attribute__((aligned(4)));  /* lest something weird decides that 2 is OK */
 
 struct file_handle {
         __u32 handle_bytes;
diff --git a/include/linux/fsl_ifc.h b/include/linux/fsl_ifc.h
new file mode 100644
index 000000000000..f49ddb1b2273
--- /dev/null
+++ b/include/linux/fsl_ifc.h
@@ -0,0 +1,838 @@
+/* Freescale Integrated Flash Controller
+ *
+ * Copyright 2011 Freescale Semiconductor, Inc
+ *
+ * Author: Dipen Dudhat <dipen.dudhat@freescale.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __ASM_FSL_IFC_H
+#define __ASM_FSL_IFC_H
+
+#include <linux/compiler.h>
+#include <linux/types.h>
+#include <linux/io.h>
+
+#include <linux/of_platform.h>
+#include <linux/interrupt.h>
+
+#define FSL_IFC_BANK_COUNT 4
+
+/*
+ * CSPR - Chip Select Property Register
+ */
+#define CSPR_BA                         0xFFFF0000
+#define CSPR_BA_SHIFT                   16
+#define CSPR_PORT_SIZE                  0x00000180
+#define CSPR_PORT_SIZE_SHIFT            7
+/* Port Size 8 bit */
+#define CSPR_PORT_SIZE_8                0x00000080
+/* Port Size 16 bit */
+#define CSPR_PORT_SIZE_16               0x00000100
+/* Port Size 32 bit */
+#define CSPR_PORT_SIZE_32               0x00000180
+/* Write Protect */
+#define CSPR_WP                         0x00000040
+#define CSPR_WP_SHIFT                   6
+/* Machine Select */
+#define CSPR_MSEL                       0x00000006
+#define CSPR_MSEL_SHIFT                 1
+/* NOR */
+#define CSPR_MSEL_NOR                   0x00000000
+/* NAND */
+#define CSPR_MSEL_NAND                  0x00000002
+/* GPCM */
+#define CSPR_MSEL_GPCM                  0x00000004
+/* Bank Valid */
+#define CSPR_V                          0x00000001
+#define CSPR_V_SHIFT                    0
+
+/*
+ * Address Mask Register
+ */
+#define IFC_AMASK_MASK                  0xFFFF0000
+#define IFC_AMASK_SHIFT                 16
+#define IFC_AMASK(n)                    (IFC_AMASK_MASK << \
+                                        (__ilog2(n) - IFC_AMASK_SHIFT))
+
+/*
+ * Chip Select Option Register IFC_NAND Machine
+ */
+/* Enable ECC Encoder */
+#define CSOR_NAND_ECC_ENC_EN            0x80000000
+#define CSOR_NAND_ECC_MODE_MASK         0x30000000
+/* 4 bit correction per 520 Byte sector */
+#define CSOR_NAND_ECC_MODE_4            0x00000000
+/* 8 bit correction per 528 Byte sector */
+#define CSOR_NAND_ECC_MODE_8            0x10000000
+/* Enable ECC Decoder */
+#define CSOR_NAND_ECC_DEC_EN            0x04000000
+/* Row Address Length */
+#define CSOR_NAND_RAL_MASK              0x01800000
+#define CSOR_NAND_RAL_SHIFT             20
+#define CSOR_NAND_RAL_1                 0x00000000
+#define CSOR_NAND_RAL_2                 0x00800000
+#define CSOR_NAND_RAL_3                 0x01000000
+#define CSOR_NAND_RAL_4                 0x01800000
+/* Page Size 512b, 2k, 4k */
+#define CSOR_NAND_PGS_MASK              0x00180000
+#define CSOR_NAND_PGS_SHIFT             16
+#define CSOR_NAND_PGS_512               0x00000000
+#define CSOR_NAND_PGS_2K                0x00080000
+#define CSOR_NAND_PGS_4K                0x00100000
+#define CSOR_NAND_PGS_8K                0x00180000
+/* Spare region Size */
+#define CSOR_NAND_SPRZ_MASK             0x0000E000
+#define CSOR_NAND_SPRZ_SHIFT            13
+#define CSOR_NAND_SPRZ_16               0x00000000
+#define CSOR_NAND_SPRZ_64               0x00002000
+#define CSOR_NAND_SPRZ_128              0x00004000
+#define CSOR_NAND_SPRZ_210              0x00006000
+#define CSOR_NAND_SPRZ_218              0x00008000
+#define CSOR_NAND_SPRZ_224              0x0000A000
+#define CSOR_NAND_SPRZ_CSOR_EXT         0x0000C000
+/* Pages Per Block */
+#define CSOR_NAND_PB_MASK               0x00000700
+#define CSOR_NAND_PB_SHIFT              8
+#define CSOR_NAND_PB(n)         ((__ilog2(n) - 5) << CSOR_NAND_PB_SHIFT)
+/* Time for Read Enable High to Output High Impedance */
+#define CSOR_NAND_TRHZ_MASK             0x0000001C
+#define CSOR_NAND_TRHZ_SHIFT            2
+#define CSOR_NAND_TRHZ_20               0x00000000
+#define CSOR_NAND_TRHZ_40               0x00000004
+#define CSOR_NAND_TRHZ_60               0x00000008
+#define CSOR_NAND_TRHZ_80               0x0000000C
+#define CSOR_NAND_TRHZ_100              0x00000010
+/* Buffer control disable */
+#define CSOR_NAND_BCTLD                 0x00000001
+
+/*
+ * Chip Select Option Register - NOR Flash Mode
+ */
+/* Enable Address shift Mode */
+#define CSOR_NOR_ADM_SHFT_MODE_EN       0x80000000
+/* Page Read Enable from NOR device */
+#define CSOR_NOR_PGRD_EN                0x10000000
+/* AVD Toggle Enable during Burst Program */
+#define CSOR_NOR_AVD_TGL_PGM_EN         0x01000000
+/* Address Data Multiplexing Shift */
+#define CSOR_NOR_ADM_MASK               0x0003E000
+#define CSOR_NOR_ADM_SHIFT_SHIFT        13
+#define CSOR_NOR_ADM_SHIFT(n)   ((n) << CSOR_NOR_ADM_SHIFT_SHIFT)
+/* Type of the NOR device hooked */
+#define CSOR_NOR_NOR_MODE_AYSNC_NOR     0x00000000
+#define CSOR_NOR_NOR_MODE_AVD_NOR       0x00000020
+/* Time for Read Enable High to Output High Impedance */
+#define CSOR_NOR_TRHZ_MASK              0x0000001C
+#define CSOR_NOR_TRHZ_SHIFT             2
+#define CSOR_NOR_TRHZ_20                0x00000000
+#define CSOR_NOR_TRHZ_40                0x00000004
+#define CSOR_NOR_TRHZ_60                0x00000008
+#define CSOR_NOR_TRHZ_80                0x0000000C
+#define CSOR_NOR_TRHZ_100               0x00000010
+/* Buffer control disable */
+#define CSOR_NOR_BCTLD                  0x00000001
+
+/*
+ * Chip Select Option Register - GPCM Mode
+ */
+/* GPCM Mode - Normal */
+#define CSOR_GPCM_GPMODE_NORMAL         0x00000000
+/* GPCM Mode - GenericASIC */
+#define CSOR_GPCM_GPMODE_ASIC           0x80000000
+/* Parity Mode odd/even */
+#define CSOR_GPCM_PARITY_EVEN           0x40000000
+/* Parity Checking enable/disable */
+#define CSOR_GPCM_PAR_EN                0x20000000
+/* GPCM Timeout Count */
+#define CSOR_GPCM_GPTO_MASK             0x0F000000
+#define CSOR_GPCM_GPTO_SHIFT            24
+#define CSOR_GPCM_GPTO(n)       ((__ilog2(n) - 8) << CSOR_GPCM_GPTO_SHIFT)
+/* GPCM External Access Termination mode for read access */
+#define CSOR_GPCM_RGETA_EXT             0x00080000
+/* GPCM External Access Termination mode for write access */
+#define CSOR_GPCM_WGETA_EXT             0x00040000
+/* Address Data Multiplexing Shift */
+#define CSOR_GPCM_ADM_MASK              0x0003E000
+#define CSOR_GPCM_ADM_SHIFT_SHIFT       13
+#define CSOR_GPCM_ADM_SHIFT(n)  ((n) << CSOR_GPCM_ADM_SHIFT_SHIFT)
+/* Generic ASIC Parity error indication delay */
+#define CSOR_GPCM_GAPERRD_MASK          0x00000180
+#define CSOR_GPCM_GAPERRD_SHIFT         7
+#define CSOR_GPCM_GAPERRD(n)    (((n) - 1) << CSOR_GPCM_GAPERRD_SHIFT)
+/* Time for Read Enable High to Output High Impedance */
+#define CSOR_GPCM_TRHZ_MASK             0x0000001C
+#define CSOR_GPCM_TRHZ_20               0x00000000
+#define CSOR_GPCM_TRHZ_40               0x00000004
+#define CSOR_GPCM_TRHZ_60               0x00000008
+#define CSOR_GPCM_TRHZ_80               0x0000000C
+#define CSOR_GPCM_TRHZ_100              0x00000010
+/* Buffer control disable */
+#define CSOR_GPCM_BCTLD                 0x00000001
+
+/*
+ * Ready Busy Status Register (RB_STAT)
+ */
+/* CSn is READY */
+#define IFC_RB_STAT_READY_CS0           0x80000000
+#define IFC_RB_STAT_READY_CS1           0x40000000
+#define IFC_RB_STAT_READY_CS2           0x20000000
+#define IFC_RB_STAT_READY_CS3           0x10000000
+
+/*
+ * General Control Register (GCR)
+ */
+#define IFC_GCR_MASK                    0x8000F800
+/* reset all IFC hardware */
+#define IFC_GCR_SOFT_RST_ALL            0x80000000
+/* Turnaroud Time of external buffer */
+#define IFC_GCR_TBCTL_TRN_TIME          0x0000F800
+#define IFC_GCR_TBCTL_TRN_TIME_SHIFT    11
+
+/*
+ * Common Event and Error Status Register (CM_EVTER_STAT)
+ */
+/* Chip select error */
+#define IFC_CM_EVTER_STAT_CSER          0x80000000
+
+/*
+ * Common Event and Error Enable Register (CM_EVTER_EN)
+ */
+/* Chip select error checking enable */
+#define IFC_CM_EVTER_EN_CSEREN          0x80000000
+
+/*
+ * Common Event and Error Interrupt Enable Register (CM_EVTER_INTR_EN)
+ */
+/* Chip select error interrupt enable */
+#define IFC_CM_EVTER_INTR_EN_CSERIREN   0x80000000
+
+/*
+ * Common Transfer Error Attribute Register-0 (CM_ERATTR0)
+ */
+/* transaction type of error Read/Write */
+#define IFC_CM_ERATTR0_ERTYP_READ       0x80000000
+#define IFC_CM_ERATTR0_ERAID            0x0FF00000
+#define IFC_CM_ERATTR0_ERAID_SHIFT      20
+#define IFC_CM_ERATTR0_ESRCID           0x0000FF00
+#define IFC_CM_ERATTR0_ESRCID_SHIFT     8
+
+/*
+ * Clock Control Register (CCR)
+ */
+#define IFC_CCR_MASK                    0x0F0F8800
+/* Clock division ratio */
+#define IFC_CCR_CLK_DIV_MASK            0x0F000000
+#define IFC_CCR_CLK_DIV_SHIFT           24
+#define IFC_CCR_CLK_DIV(n)              ((n-1) << IFC_CCR_CLK_DIV_SHIFT)
+/* IFC Clock Delay */
+#define IFC_CCR_CLK_DLY_MASK            0x000F0000
+#define IFC_CCR_CLK_DLY_SHIFT           16
+#define IFC_CCR_CLK_DLY(n)              ((n) << IFC_CCR_CLK_DLY_SHIFT)
+/* Invert IFC clock before sending out */
+#define IFC_CCR_INV_CLK_EN              0x00008000
+/* Fedback IFC Clock */
+#define IFC_CCR_FB_IFC_CLK_SEL          0x00000800
+
+/*
+ * Clock Status Register (CSR)
+ */
+/* Clk is stable */
+#define IFC_CSR_CLK_STAT_STABLE         0x80000000
+
+/*
+ * IFC_NAND Machine Specific Registers
+ */
+/*
+ * NAND Configuration Register (NCFGR)
+ */
+/* Auto Boot Mode */
+#define IFC_NAND_NCFGR_BOOT             0x80000000
+/* Addressing Mode-ROW0+n/COL0 */
+#define IFC_NAND_NCFGR_ADDR_MODE_RC0    0x00000000
+/* Addressing Mode-ROW0+n/COL0+n */
+#define IFC_NAND_NCFGR_ADDR_MODE_RC1    0x00400000
+/* Number of loop iterations of FIR sequences for multi page operations */
+#define IFC_NAND_NCFGR_NUM_LOOP_MASK    0x0000F000
+#define IFC_NAND_NCFGR_NUM_LOOP_SHIFT   12
+#define IFC_NAND_NCFGR_NUM_LOOP(n)      ((n) << IFC_NAND_NCFGR_NUM_LOOP_SHIFT)
+/* Number of wait cycles */
+#define IFC_NAND_NCFGR_NUM_WAIT_MASK    0x000000FF
+#define IFC_NAND_NCFGR_NUM_WAIT_SHIFT   0
+
+/*
+ * NAND Flash Command Registers (NAND_FCR0/NAND_FCR1)
+ */
+/* General purpose FCM flash command bytes CMD0-CMD7 */
+#define IFC_NAND_FCR0_CMD0              0xFF000000
+#define IFC_NAND_FCR0_CMD0_SHIFT        24
+#define IFC_NAND_FCR0_CMD1              0x00FF0000
+#define IFC_NAND_FCR0_CMD1_SHIFT        16
+#define IFC_NAND_FCR0_CMD2              0x0000FF00
+#define IFC_NAND_FCR0_CMD2_SHIFT        8
+#define IFC_NAND_FCR0_CMD3              0x000000FF
+#define IFC_NAND_FCR0_CMD3_SHIFT        0
+#define IFC_NAND_FCR1_CMD4              0xFF000000
+#define IFC_NAND_FCR1_CMD4_SHIFT        24
+#define IFC_NAND_FCR1_CMD5              0x00FF0000
+#define IFC_NAND_FCR1_CMD5_SHIFT        16
+#define IFC_NAND_FCR1_CMD6              0x0000FF00
+#define IFC_NAND_FCR1_CMD6_SHIFT        8
+#define IFC_NAND_FCR1_CMD7              0x000000FF
+#define IFC_NAND_FCR1_CMD7_SHIFT        0
+
+/*
+ * Flash ROW and COL Address Register (ROWn, COLn)
+ */
+/* Main/spare region locator */
+#define IFC_NAND_COL_MS                 0x80000000
+/* Column Address */
+#define IFC_NAND_COL_CA_MASK            0x00000FFF
+
+/*
+ * NAND Flash Byte Count Register (NAND_BC)
+ */
+/* Byte Count for read/Write */
+#define IFC_NAND_BC                     0x000001FF
+
+/*
+ * NAND Flash Instruction Registers (NAND_FIR0/NAND_FIR1/NAND_FIR2)
+ */
+/* NAND Machine specific opcodes OP0-OP14*/
+#define IFC_NAND_FIR0_OP0               0xFC000000
+#define IFC_NAND_FIR0_OP0_SHIFT         26
+#define IFC_NAND_FIR0_OP1               0x03F00000
+#define IFC_NAND_FIR0_OP1_SHIFT         20
+#define IFC_NAND_FIR0_OP2               0x000FC000
+#define IFC_NAND_FIR0_OP2_SHIFT         14
+#define IFC_NAND_FIR0_OP3               0x00003F00
+#define IFC_NAND_FIR0_OP3_SHIFT         8
+#define IFC_NAND_FIR0_OP4               0x000000FC
+#define IFC_NAND_FIR0_OP4_SHIFT         2
+#define IFC_NAND_FIR1_OP5               0xFC000000
+#define IFC_NAND_FIR1_OP5_SHIFT         26
+#define IFC_NAND_FIR1_OP6               0x03F00000
+#define IFC_NAND_FIR1_OP6_SHIFT         20
+#define IFC_NAND_FIR1_OP7               0x000FC000
+#define IFC_NAND_FIR1_OP7_SHIFT         14
+#define IFC_NAND_FIR1_OP8               0x00003F00
+#define IFC_NAND_FIR1_OP8_SHIFT         8
+#define IFC_NAND_FIR1_OP9               0x000000FC
+#define IFC_NAND_FIR1_OP9_SHIFT         2
+#define IFC_NAND_FIR2_OP10              0xFC000000
+#define IFC_NAND_FIR2_OP10_SHIFT        26
+#define IFC_NAND_FIR2_OP11              0x03F00000
+#define IFC_NAND_FIR2_OP11_SHIFT        20
+#define IFC_NAND_FIR2_OP12              0x000FC000
+#define IFC_NAND_FIR2_OP12_SHIFT        14
+#define IFC_NAND_FIR2_OP13              0x00003F00
+#define IFC_NAND_FIR2_OP13_SHIFT        8
+#define IFC_NAND_FIR2_OP14              0x000000FC
+#define IFC_NAND_FIR2_OP14_SHIFT        2
+
+/*
+ * Instruction opcodes to be programmed
+ * in FIR registers- 6bits
+ */
+enum ifc_nand_fir_opcodes {
+        IFC_FIR_OP_NOP,
+        IFC_FIR_OP_CA0,
+        IFC_FIR_OP_CA1,
+        IFC_FIR_OP_CA2,
+        IFC_FIR_OP_CA3,
+        IFC_FIR_OP_RA0,
+        IFC_FIR_OP_RA1,
+        IFC_FIR_OP_RA2,
+        IFC_FIR_OP_RA3,
+        IFC_FIR_OP_CMD0,
+        IFC_FIR_OP_CMD1,
+        IFC_FIR_OP_CMD2,
+        IFC_FIR_OP_CMD3,
+        IFC_FIR_OP_CMD4,
+        IFC_FIR_OP_CMD5,
+        IFC_FIR_OP_CMD6,
+        IFC_FIR_OP_CMD7,
+        IFC_FIR_OP_CW0,
+        IFC_FIR_OP_CW1,
+        IFC_FIR_OP_CW2,
+        IFC_FIR_OP_CW3,
+        IFC_FIR_OP_CW4,
+        IFC_FIR_OP_CW5,
+        IFC_FIR_OP_CW6,
+        IFC_FIR_OP_CW7,
+        IFC_FIR_OP_WBCD,
+        IFC_FIR_OP_RBCD,
+        IFC_FIR_OP_BTRD,
+        IFC_FIR_OP_RDSTAT,
+        IFC_FIR_OP_NWAIT,
+        IFC_FIR_OP_WFR,
+        IFC_FIR_OP_SBRD,
+        IFC_FIR_OP_UA,
+        IFC_FIR_OP_RB,
+};
+
+/*
+ * NAND Chip Select Register (NAND_CSEL)
+ */
+#define IFC_NAND_CSEL                   0x0C000000
+#define IFC_NAND_CSEL_SHIFT             26
+#define IFC_NAND_CSEL_CS0               0x00000000
+#define IFC_NAND_CSEL_CS1               0x04000000
+#define IFC_NAND_CSEL_CS2               0x08000000
+#define IFC_NAND_CSEL_CS3               0x0C000000
+
+/*
+ * NAND Operation Sequence Start (NANDSEQ_STRT)
+ */
+/* NAND Flash Operation Start */
+#define IFC_NAND_SEQ_STRT_FIR_STRT      0x80000000
+/* Automatic Erase */
+#define IFC_NAND_SEQ_STRT_AUTO_ERS      0x00800000
+/* Automatic Program */
+#define IFC_NAND_SEQ_STRT_AUTO_PGM      0x00100000
+/* Automatic Copyback */
+#define IFC_NAND_SEQ_STRT_AUTO_CPB      0x00020000
+/* Automatic Read Operation */
+#define IFC_NAND_SEQ_STRT_AUTO_RD       0x00004000
+/* Automatic Status Read */
+#define IFC_NAND_SEQ_STRT_AUTO_STAT_RD  0x00000800
+
+/*
+ * NAND Event and Error Status Register (NAND_EVTER_STAT)
+ */
+/* Operation Complete */
+#define IFC_NAND_EVTER_STAT_OPC         0x80000000
+/* Flash Timeout Error */
+#define IFC_NAND_EVTER_STAT_FTOER       0x08000000
+/* Write Protect Error */
+#define IFC_NAND_EVTER_STAT_WPER        0x04000000
+/* ECC Error */
+#define IFC_NAND_EVTER_STAT_ECCER       0x02000000
+/* RCW Load Done */
+#define IFC_NAND_EVTER_STAT_RCW_DN      0x00008000
+/* Boot Loadr Done */
+#define IFC_NAND_EVTER_STAT_BOOT_DN     0x00004000
+/* Bad Block Indicator search select */
+#define IFC_NAND_EVTER_STAT_BBI_SRCH_SE 0x00000800
+
+/*
+ * NAND Flash Page Read Completion Event Status Register
+ * (PGRDCMPL_EVT_STAT)
+ */
+#define PGRDCMPL_EVT_STAT_MASK          0xFFFF0000
+/* Small Page 0-15 Done */
+#define PGRDCMPL_EVT_STAT_SECTION_SP(n) (1 << (31 - (n)))
+/* Large Page(2K) 0-3 Done */
+#define PGRDCMPL_EVT_STAT_LP_2K(n)      (0xF << (28 - (n)*4))
+/* Large Page(4K) 0-1 Done */
+#define PGRDCMPL_EVT_STAT_LP_4K(n)      (0xFF << (24 - (n)*8))
+
+/*
+ * NAND Event and Error Enable Register (NAND_EVTER_EN)
+ */
+/* Operation complete event enable */
+#define IFC_NAND_EVTER_EN_OPC_EN        0x80000000
+/* Page read complete event enable */
+#define IFC_NAND_EVTER_EN_PGRDCMPL_EN   0x20000000
+/* Flash Timeout error enable */
+#define IFC_NAND_EVTER_EN_FTOER_EN      0x08000000
+/* Write Protect error enable */
+#define IFC_NAND_EVTER_EN_WPER_EN       0x04000000
+/* ECC error logging enable */
+#define IFC_NAND_EVTER_EN_ECCER_EN      0x02000000
+
+/*
+ * NAND Event and Error Interrupt Enable Register (NAND_EVTER_INTR_EN)
+ */
+/* Enable interrupt for operation complete */
+#define IFC_NAND_EVTER_INTR_OPCIR_EN            0x80000000
+/* Enable interrupt for Page read complete */
+#define IFC_NAND_EVTER_INTR_PGRDCMPLIR_EN       0x20000000
+/* Enable interrupt for Flash timeout error */
+#define IFC_NAND_EVTER_INTR_FTOERIR_EN          0x08000000
+/* Enable interrupt for Write protect error */
+#define IFC_NAND_EVTER_INTR_WPERIR_EN           0x04000000
+/* Enable interrupt for ECC error*/
+#define IFC_NAND_EVTER_INTR_ECCERIR_EN          0x02000000
+
+/*
+ * NAND Transfer Error Attribute Register-0 (NAND_ERATTR0)
+ */
+#define IFC_NAND_ERATTR0_MASK           0x0C080000
+/* Error on CS0-3 for NAND */
+#define IFC_NAND_ERATTR0_ERCS_CS0       0x00000000
+#define IFC_NAND_ERATTR0_ERCS_CS1       0x04000000
+#define IFC_NAND_ERATTR0_ERCS_CS2       0x08000000
+#define IFC_NAND_ERATTR0_ERCS_CS3       0x0C000000
+/* Transaction type of error Read/Write */
+#define IFC_NAND_ERATTR0_ERTTYPE_READ   0x00080000
+
+/*
+ * NAND Flash Status Register (NAND_FSR)
+ */
+/* First byte of data read from read status op */
+#define IFC_NAND_NFSR_RS0               0xFF000000
+/* Second byte of data read from read status op */
+#define IFC_NAND_NFSR_RS1               0x00FF0000
+
+/*
+ * ECC Error Status Registers (ECCSTAT0-ECCSTAT3)
+ */
+/* Number of ECC errors on sector n (n = 0-15) */
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR0_MASK   0x0F000000
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR0_SHIFT  24
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR1_MASK   0x000F0000
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR1_SHIFT  16
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR2_MASK   0x00000F00
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR2_SHIFT  8
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR3_MASK   0x0000000F
+#define IFC_NAND_ECCSTAT0_ERRCNT_SECTOR3_SHIFT  0
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR4_MASK   0x0F000000
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR4_SHIFT  24
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR5_MASK   0x000F0000
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR5_SHIFT  16
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR6_MASK   0x00000F00
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR6_SHIFT  8
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR7_MASK   0x0000000F
+#define IFC_NAND_ECCSTAT1_ERRCNT_SECTOR7_SHIFT  0
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR8_MASK   0x0F000000
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR8_SHIFT  24
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR9_MASK   0x000F0000
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR9_SHIFT  16
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR10_MASK  0x00000F00
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR10_SHIFT 8
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR11_MASK  0x0000000F
+#define IFC_NAND_ECCSTAT2_ERRCNT_SECTOR11_SHIFT 0
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR12_MASK  0x0F000000
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR12_SHIFT 24
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR13_MASK  0x000F0000
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR13_SHIFT 16
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR14_MASK  0x00000F00
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR14_SHIFT 8
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR15_MASK  0x0000000F
+#define IFC_NAND_ECCSTAT3_ERRCNT_SECTOR15_SHIFT 0
+
+/*
+ * NAND Control Register (NANDCR)
+ */
+#define IFC_NAND_NCR_FTOCNT_MASK        0x1E000000
+#define IFC_NAND_NCR_FTOCNT_SHIFT       25
+#define IFC_NAND_NCR_FTOCNT(n)  ((_ilog2(n) - 8)  << IFC_NAND_NCR_FTOCNT_SHIFT)
+
+/*
+ * NAND_AUTOBOOT_TRGR
+ */
+/* Trigger RCW load */
+#define IFC_NAND_AUTOBOOT_TRGR_RCW_LD   0x80000000
+/* Trigget Auto Boot */
+#define IFC_NAND_AUTOBOOT_TRGR_BOOT_LD  0x20000000
+
+/*
+ * NAND_MDR
+ */
+/* 1st read data byte when opcode SBRD */
+#define IFC_NAND_MDR_RDATA0             0xFF000000
+/* 2nd read data byte when opcode SBRD */
+#define IFC_NAND_MDR_RDATA1             0x00FF0000
+
+/*
+ * NOR Machine Specific Registers
+ */
+/*
+ * NOR Event and Error Status Register (NOR_EVTER_STAT)
+ */
+/* NOR Command Sequence Operation Complete */
+#define IFC_NOR_EVTER_STAT_OPC_NOR      0x80000000
+/* Write Protect Error */
+#define IFC_NOR_EVTER_STAT_WPER         0x04000000
+/* Command Sequence Timeout Error */
+#define IFC_NOR_EVTER_STAT_STOER        0x01000000
+
+/*
+ * NOR Event and Error Enable Register (NOR_EVTER_EN)
+ */
+/* NOR Command Seq complete event enable */
+#define IFC_NOR_EVTER_EN_OPCEN_NOR      0x80000000
+/* Write Protect Error Checking Enable */
+#define IFC_NOR_EVTER_EN_WPEREN         0x04000000
+/* Timeout Error Enable */
+#define IFC_NOR_EVTER_EN_STOEREN        0x01000000
+
+/*
+ * NOR Event and Error Interrupt Enable Register (NOR_EVTER_INTR_EN)
+ */
+/* Enable interrupt for OPC complete */
+#define IFC_NOR_EVTER_INTR_OPCEN_NOR    0x80000000
+/* Enable interrupt for write protect error */
+#define IFC_NOR_EVTER_INTR_WPEREN       0x04000000
+/* Enable interrupt for timeout error */
+#define IFC_NOR_EVTER_INTR_STOEREN      0x01000000
+
+/*
+ * NOR Transfer Error Attribute Register-0 (NOR_ERATTR0)
+ */
+/* Source ID for error transaction */
+#define IFC_NOR_ERATTR0_ERSRCID         0xFF000000
+/* AXI ID for error transation */
+#define IFC_NOR_ERATTR0_ERAID           0x000FF000
+/* Chip select corresponds to NOR error */
+#define IFC_NOR_ERATTR0_ERCS_CS0        0x00000000
+#define IFC_NOR_ERATTR0_ERCS_CS1        0x00000010
+#define IFC_NOR_ERATTR0_ERCS_CS2        0x00000020
+#define IFC_NOR_ERATTR0_ERCS_CS3        0x00000030
+/* Type of transaction read/write */
+#define IFC_NOR_ERATTR0_ERTYPE_READ     0x00000001
+
+/*
+ * NOR Transfer Error Attribute Register-2 (NOR_ERATTR2)
+ */
+#define IFC_NOR_ERATTR2_ER_NUM_PHASE_EXP        0x000F0000
+#define IFC_NOR_ERATTR2_ER_NUM_PHASE_PER        0x00000F00
+
+/*
+ * NOR Control Register (NORCR)
+ */
+#define IFC_NORCR_MASK                  0x0F0F0000
+/* No. of Address/Data Phase */
+#define IFC_NORCR_NUM_PHASE_MASK        0x0F000000
+#define IFC_NORCR_NUM_PHASE_SHIFT       24
+#define IFC_NORCR_NUM_PHASE(n)  ((n-1) << IFC_NORCR_NUM_PHASE_SHIFT)
+/* Sequence Timeout Count */
+#define IFC_NORCR_STOCNT_MASK           0x000F0000
+#define IFC_NORCR_STOCNT_SHIFT          16
+#define IFC_NORCR_STOCNT(n)     ((__ilog2(n) - 8) << IFC_NORCR_STOCNT_SHIFT)
+
+/*
+ * GPCM Machine specific registers
+ */
+/*
+ * GPCM Event and Error Status Register (GPCM_EVTER_STAT)
+ */
+/* Timeout error */
+#define IFC_GPCM_EVTER_STAT_TOER        0x04000000
+/* Parity error */
+#define IFC_GPCM_EVTER_STAT_PER         0x01000000
+
+/*
+ * GPCM Event and Error Enable Register (GPCM_EVTER_EN)
+ */
+/* Timeout error enable */
+#define IFC_GPCM_EVTER_EN_TOER_EN       0x04000000
+/* Parity error enable */
+#define IFC_GPCM_EVTER_EN_PER_EN        0x01000000
+
+/*
+ * GPCM Event and Error Interrupt Enable Register (GPCM_EVTER_INTR_EN)
+ */
+/* Enable Interrupt for timeout error */
+#define IFC_GPCM_EEIER_TOERIR_EN        0x04000000
+/* Enable Interrupt for Parity error */
+#define IFC_GPCM_EEIER_PERIR_EN         0x01000000
+
+/*
+ * GPCM Transfer Error Attribute Register-0 (GPCM_ERATTR0)
+ */
+/* Source ID for error transaction */
+#define IFC_GPCM_ERATTR0_ERSRCID        0xFF000000
+/* AXI ID for error transaction */
+#define IFC_GPCM_ERATTR0_ERAID          0x000FF000
+/* Chip select corresponds to GPCM error */
+#define IFC_GPCM_ERATTR0_ERCS_CS0       0x00000000
+#define IFC_GPCM_ERATTR0_ERCS_CS1       0x00000040
+#define IFC_GPCM_ERATTR0_ERCS_CS2       0x00000080
+#define IFC_GPCM_ERATTR0_ERCS_CS3       0x000000C0
+/* Type of transaction read/Write */
+#define IFC_GPCM_ERATTR0_ERTYPE_READ    0x00000001
+
+/*
+ * GPCM Transfer Error Attribute Register-2 (GPCM_ERATTR2)
+ */
+/* On which beat of address/data parity error is observed */
+#define IFC_GPCM_ERATTR2_PERR_BEAT              0x00000C00
+/* Parity Error on byte */
+#define IFC_GPCM_ERATTR2_PERR_BYTE              0x000000F0
+/* Parity Error reported in addr or data phase */
+#define IFC_GPCM_ERATTR2_PERR_DATA_PHASE        0x00000001
+
+/*
+ * GPCM Status Register (GPCM_STAT)
+ */
+#define IFC_GPCM_STAT_BSY               0x80000000  /* GPCM is busy */
+
+/*
+ * IFC Controller NAND Machine registers
+ */
+struct fsl_ifc_nand {
+        __be32 ncfgr;
+        u32 res1[0x4];
+        __be32 nand_fcr0;
+        __be32 nand_fcr1;
+        u32 res2[0x8];
+        __be32 row0;
+        u32 res3;
+        __be32 col0;
+        u32 res4;
+        __be32 row1;
+        u32 res5;
+        __be32 col1;
+        u32 res6;
+        __be32 row2;
+        u32 res7;
+        __be32 col2;
+        u32 res8;
+        __be32 row3;
+        u32 res9;
+        __be32 col3;
+        u32 res10[0x24];
+        __be32 nand_fbcr;
+        u32 res11;
+        __be32 nand_fir0;
+        __be32 nand_fir1;
+        __be32 nand_fir2;
+        u32 res12[0x10];
+        __be32 nand_csel;
+        u32 res13;
+        __be32 nandseq_strt;
+        u32 res14;
+        __be32 nand_evter_stat;
+        u32 res15;
+        __be32 pgrdcmpl_evt_stat;
+        u32 res16[0x2];
+        __be32 nand_evter_en;
+        u32 res17[0x2];
+        __be32 nand_evter_intr_en;
+        u32 res18[0x2];
+        __be32 nand_erattr0;
+        __be32 nand_erattr1;
+        u32 res19[0x10];
+        __be32 nand_fsr;
+        u32 res20;
+        __be32 nand_eccstat[4];
+        u32 res21[0x20];
+        __be32 nanndcr;
+        u32 res22[0x2];
+        __be32 nand_autoboot_trgr;
+        u32 res23;
+        __be32 nand_mdr;
+        u32 res24[0x5C];
+};
+
+/*
+ * IFC controller NOR Machine registers
+ */
+struct fsl_ifc_nor {
+        __be32 nor_evter_stat;
+        u32 res1[0x2];
+        __be32 nor_evter_en;
+        u32 res2[0x2];
+        __be32 nor_evter_intr_en;
+        u32 res3[0x2];
+        __be32 nor_erattr0;
+        __be32 nor_erattr1;
+        __be32 nor_erattr2;
+        u32 res4[0x4];
+        __be32 norcr;
+        u32 res5[0xEF];
+};
+
+/*
+ * IFC controller GPCM Machine registers
+ */
+struct fsl_ifc_gpcm {
+        __be32 gpcm_evter_stat;
+        u32 res1[0x2];
+        __be32 gpcm_evter_en;
+        u32 res2[0x2];
+        __be32 gpcm_evter_intr_en;
+        u32 res3[0x2];
+        __be32 gpcm_erattr0;
+        __be32 gpcm_erattr1;
+        __be32 gpcm_erattr2;
+        __be32 gpcm_stat;
+        u32 res4[0x1F3];
+};
+
+/*
+ * IFC Controller Registers
+ */
+struct fsl_ifc_regs {
+        __be32 ifc_rev;
+        u32 res1[0x2];
+        struct {
+                __be32 cspr_ext;
+                __be32 cspr;
+                u32 res2;
+        } cspr_cs[FSL_IFC_BANK_COUNT];
+        u32 res3[0x19];
+        struct {
+                __be32 amask;
+                u32 res4[0x2];
+        } amask_cs[FSL_IFC_BANK_COUNT];
+        u32 res5[0x17];
+        struct {
+                __be32 csor_ext;
+                __be32 csor;
+                u32 res6;
+        } csor_cs[FSL_IFC_BANK_COUNT];
+        u32 res7[0x19];
+        struct {
+                __be32 ftim[4];
+                u32 res8[0x8];
+        } ftim_cs[FSL_IFC_BANK_COUNT];
+        u32 res9[0x60];
+        __be32 rb_stat;
+        u32 res10[0x2];
+        __be32 ifc_gcr;
+        u32 res11[0x2];
+        __be32 cm_evter_stat;
+        u32 res12[0x2];
+        __be32 cm_evter_en;
+        u32 res13[0x2];
+        __be32 cm_evter_intr_en;
+        u32 res14[0x2];
+        __be32 cm_erattr0;
+        __be32 cm_erattr1;
+        u32 res15[0x2];
+        __be32 ifc_ccr;
+        __be32 ifc_csr;
+        u32 res16[0x2EB];
+        struct fsl_ifc_nand ifc_nand;
+        struct fsl_ifc_nor ifc_nor;
+        struct fsl_ifc_gpcm ifc_gpcm;
+};
+
+extern unsigned int convert_ifc_address(phys_addr_t addr_base);
+extern int fsl_ifc_find(phys_addr_t addr_base);
+
+/* overview of the fsl ifc controller */
+
+struct fsl_ifc_ctrl {
+        /* device info */
+        struct device                   *dev;
+        struct fsl_ifc_regs __iomem     *regs;
+        int                             irq;
+        int                             nand_irq;
+        spinlock_t                      lock;
+        void                            *nand;
+
+        u32 nand_stat;
+        wait_queue_head_t nand_wait;
+};
+
+extern struct fsl_ifc_ctrl *fsl_ifc_ctrl_dev;
+
+
+#endif /* __ASM_FSL_IFC_H */
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 3d286ff49ab0..64cf3ef50696 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -99,7 +99,7 @@ struct fsnotify_ops {
                             struct fsnotify_mark *inode_mark,
                             struct fsnotify_mark *vfsmount_mark,
                             u32 mask, void *data, int data_type,
-                            const unsigned char *file_name);
+                            const unsigned char *file_name, u32 cookie);
         void (*free_group_priv)(struct fsnotify_group *group);
         void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group);
         void (*free_event)(struct fsnotify_event *event);
@@ -160,7 +160,7 @@ struct fsnotify_group {
 
         struct fasync_struct *fsn_fa;    /* async notification */
 
-        struct fsnotify_event overflow_event;   /* Event we queue when the
+        struct fsnotify_event *overflow_event;  /* Event we queue when the
                                                  * notification list is too
                                                  * full */
 
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 4e4cc28623ad..4cdb3a17bcb5 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -495,10 +495,6 @@ enum {
         FILTER_TRACE_FN,
 };
 
-#define EVENT_STORAGE_SIZE 128
-extern struct mutex event_storage_mutex;
-extern char event_storage[EVENT_STORAGE_SIZE];
-
 extern int trace_event_raw_init(struct ftrace_event_call *call);
 extern int trace_define_field(struct ftrace_event_call *call, const char *type,
                               const char *name, int offset, int size,
diff --git a/include/linux/futex.h b/include/linux/futex.h
index b0d95cac826e..6435f46d6e13 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -55,7 +55,11 @@ union futex_key {
 #ifdef CONFIG_FUTEX
 extern void exit_robust_list(struct task_struct *curr);
 extern void exit_pi_state_list(struct task_struct *curr);
+#ifdef CONFIG_HAVE_FUTEX_CMPXCHG
+#define futex_cmpxchg_enabled 1
+#else
 extern int futex_cmpxchg_enabled;
+#endif
 #else
 static inline void exit_robust_list(struct task_struct *curr)
 {
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 0437439bc047..39b81dc7d01a 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -123,6 +123,10 @@ struct vm_area_struct;
                          __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN | \
                          __GFP_NO_KSWAPD)
 
+/*
+ * GFP_THISNODE does not perform any reclaim, you most likely want to
+ * use __GFP_THISNODE to allocate from a given node without fallback!
+ */
 #ifdef CONFIG_NUMA
 #define GFP_THISNODE    (__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY)
 #else
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 12d5f972f23f..cba442ec3c66 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -9,6 +9,7 @@
 
 
 extern void synchronize_irq(unsigned int irq);
+extern void synchronize_hardirq(unsigned int irq);
 
 #if defined(CONFIG_TINY_RCU)
 
diff --git a/include/linux/hid-sensor-ids.h b/include/linux/hid-sensor-ids.h
index beaf965621c1..537161a997ab 100644
--- a/include/linux/hid-sensor-ids.h
+++ b/include/linux/hid-sensor-ids.h
@@ -33,6 +33,16 @@
 #define HID_USAGE_SENSOR_DATA_LIGHT                             0x2004d0
 #define HID_USAGE_SENSOR_LIGHT_ILLUM                            0x2004d1
 
+/* PROX (200011) */
+#define HID_USAGE_SENSOR_PROX                                   0x200011
+#define HID_USAGE_SENSOR_DATA_PRESENCE                          0x2004b0
+#define HID_USAGE_SENSOR_HUMAN_PRESENCE                         0x2004b1
+
+/* Pressure (200031) */
+#define HID_USAGE_SENSOR_PRESSURE                               0x200031
+#define HID_USAGE_SENSOR_DATA_ATMOSPHERIC_PRESSURE              0x200430
+#define HID_USAGE_SENSOR_ATMOSPHERIC_PRESSURE                   0x200431
+
 /* Gyro 3D: (200076) */
 #define HID_USAGE_SENSOR_GYRO_3D                                0x200076
 #define HID_USAGE_SENSOR_DATA_ANGL_VELOCITY                     0x200456
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index d19a5c2d2270..e7a8d3fa91d5 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -96,12 +96,12 @@ enum hrtimer_restart {
  * @function:   timer expiry callback function
  * @base:       pointer to the timer base (per cpu and per clock)
  * @state:      state information (See bit values above)
+ * @start_pid: timer statistics field to store the pid of the task which
+ *              started the timer
  * @start_site: timer statistics field to store the site where the timer
  *              was started
  * @start_comm: timer statistics field to store the name of the process which
  *              started the timer
- * @start_pid: timer statistics field to store the pid of the task which
- *              started the timer
  *
  * The hrtimer structure must be initialized by hrtimer_init()
  */
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index db512014e061..b826239bdce0 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -157,46 +157,6 @@ static inline int hpage_nr_pages(struct page *page)
                 return HPAGE_PMD_NR;
         return 1;
 }
-/*
- * compound_trans_head() should be used instead of compound_head(),
- * whenever the "page" passed as parameter could be the tail of a
- * transparent hugepage that could be undergoing a
- * __split_huge_page_refcount(). The page structure layout often
- * changes across releases and it makes extensive use of unions. So if
- * the page structure layout will change in a way that
- * page->first_page gets clobbered by __split_huge_page_refcount, the
- * implementation making use of smp_rmb() will be required.
- *
- * Currently we define compound_trans_head as compound_head, because
- * page->private is in the same union with page->first_page, and
- * page->private isn't clobbered. However this also means we're
- * currently leaving dirt into the page->private field of anonymous
- * pages resulting from a THP split, instead of setting page->private
- * to zero like for every other page that has PG_private not set. But
- * anonymous pages don't use page->private so this is not a problem.
- */
-#if 0
-/* This will be needed if page->private will be clobbered in split_huge_page */
-static inline struct page *compound_trans_head(struct page *page)
-{
-        if (PageTail(page)) {
-                struct page *head;
-                head = page->first_page;
-                smp_rmb();
-                /*
-                 * head may be a dangling pointer.
-                 * __split_huge_page_refcount clears PageTail before
-                 * overwriting first_page, so if PageTail is still
-                 * there it means the head pointer isn't dangling.
-                 */
-                if (PageTail(page))
-                        return head;
-        }
-        return page;
-}
-#else
-#define compound_trans_head(page) compound_head(page)
-#endif
 
 extern int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
                                 unsigned long addr, pmd_t pmd, pmd_t *pmdp);
@@ -226,7 +186,6 @@ static inline int split_huge_page(struct page *page)
         do { } while (0)
 #define split_huge_page_pmd_mm(__mm, __address, __pmd)  \
         do { } while (0)
-#define compound_trans_head(page) compound_head(page)
 static inline int hugepage_madvise(struct vm_area_struct *vma,
                                    unsigned long *vm_flags, int advice)
 {
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 344883dce584..ab7359fde987 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -25,328 +25,11 @@
 #ifndef _HYPERV_H
 #define _HYPERV_H
 
-#include <linux/types.h>
-
-/*
- * Framework version for util services.
- */
-#define UTIL_FW_MINOR  0
-
-#define UTIL_WS2K8_FW_MAJOR  1
-#define UTIL_WS2K8_FW_VERSION     (UTIL_WS2K8_FW_MAJOR << 16 | UTIL_FW_MINOR)
-
-#define UTIL_FW_MAJOR  3
-#define UTIL_FW_VERSION     (UTIL_FW_MAJOR << 16 | UTIL_FW_MINOR)
-
-
-/*
- * Implementation of host controlled snapshot of the guest.
- */
-
-#define VSS_OP_REGISTER 128
-
-enum hv_vss_op {
-        VSS_OP_CREATE = 0,
-        VSS_OP_DELETE,
-        VSS_OP_HOT_BACKUP,
-        VSS_OP_GET_DM_INFO,
-        VSS_OP_BU_COMPLETE,
-        /*
-         * Following operations are only supported with IC version >= 5.0
-         */
-        VSS_OP_FREEZE, /* Freeze the file systems in the VM */
-        VSS_OP_THAW, /* Unfreeze the file systems */
-        VSS_OP_AUTO_RECOVER,
-        VSS_OP_COUNT /* Number of operations, must be last */
-};
-
-
-/*
- * Header for all VSS messages.
- */
-struct hv_vss_hdr {
-        __u8 operation;
-        __u8 reserved[7];
-} __attribute__((packed));
-
-
-/*
- * Flag values for the hv_vss_check_feature. Linux supports only
- * one value.
- */
-#define VSS_HBU_NO_AUTO_RECOVERY        0x00000005
-
-struct hv_vss_check_feature {
-        __u32 flags;
-} __attribute__((packed));
-
-struct hv_vss_check_dm_info {
-        __u32 flags;
-} __attribute__((packed));
-
-struct hv_vss_msg {
-        union {
-                struct hv_vss_hdr vss_hdr;
-                int error;
-        };
-        union {
-                struct hv_vss_check_feature vss_cf;
-                struct hv_vss_check_dm_info dm_info;
-        };
-} __attribute__((packed));
-
-/*
- * An implementation of HyperV key value pair (KVP) functionality for Linux.
- *
- *
- * Copyright (C) 2010, Novell, Inc.
- * Author : K. Y. Srinivasan <ksrinivasan@novell.com>
- *
- */
-
-/*
- * Maximum value size - used for both key names and value data, and includes
- * any applicable NULL terminators.
- *
- * Note:  This limit is somewhat arbitrary, but falls easily within what is
- * supported for all native guests (back to Win 2000) and what is reasonable
- * for the IC KVP exchange functionality.  Note that Windows Me/98/95 are
- * limited to 255 character key names.
- *
- * MSDN recommends not storing data values larger than 2048 bytes in the
- * registry.
- *
- * Note:  This value is used in defining the KVP exchange message - this value
- * cannot be modified without affecting the message size and compatibility.
- */
-
-/*
- * bytes, including any null terminators
- */
-#define HV_KVP_EXCHANGE_MAX_VALUE_SIZE          (2048)
-
-
-/*
- * Maximum key size - the registry limit for the length of an entry name
- * is 256 characters, including the null terminator
- */
-
-#define HV_KVP_EXCHANGE_MAX_KEY_SIZE            (512)
-
-/*
- * In Linux, we implement the KVP functionality in two components:
- * 1) The kernel component which is packaged as part of the hv_utils driver
- * is responsible for communicating with the host and responsible for
- * implementing the host/guest protocol. 2) A user level daemon that is
- * responsible for data gathering.
- *
- * Host/Guest Protocol: The host iterates over an index and expects the guest
- * to assign a key name to the index and also return the value corresponding to
- * the key. The host will have atmost one KVP transaction outstanding at any
- * given point in time. The host side iteration stops when the guest returns
- * an error. Microsoft has specified the following mapping of key names to
- * host specified index:
- *
- *      Index           Key Name
- *      0               FullyQualifiedDomainName
- *      1               IntegrationServicesVersion
- *      2               NetworkAddressIPv4
- *      3               NetworkAddressIPv6
- *      4               OSBuildNumber
- *      5               OSName
- *      6               OSMajorVersion
- *      7               OSMinorVersion
- *      8               OSVersion
- *      9               ProcessorArchitecture
- *
- * The Windows host expects the Key Name and Key Value to be encoded in utf16.
- *
- * Guest Kernel/KVP Daemon Protocol: As noted earlier, we implement all of the
- * data gathering functionality in a user mode daemon. The user level daemon
- * is also responsible for binding the key name to the index as well. The
- * kernel and user-level daemon communicate using a connector channel.
- *
- * The user mode component first registers with the
- * the kernel component. Subsequently, the kernel component requests, data
- * for the specified keys. In response to this message the user mode component
- * fills in the value corresponding to the specified key. We overload the
- * sequence field in the cn_msg header to define our KVP message types.
- *
- *
- * The kernel component simply acts as a conduit for communication between the
- * Windows host and the user-level daemon. The kernel component passes up the
- * index received from the Host to the user-level daemon. If the index is
- * valid (supported), the corresponding key as well as its
- * value (both are strings) is returned. If the index is invalid
- * (not supported), a NULL key string is returned.
- */
-
-
-/*
- * Registry value types.
- */
-
-#define REG_SZ 1
-#define REG_U32 4
-#define REG_U64 8
-
-/*
- * As we look at expanding the KVP functionality to include
- * IP injection functionality, we need to maintain binary
- * compatibility with older daemons.
- *
- * The KVP opcodes are defined by the host and it was unfortunate
- * that I chose to treat the registration operation as part of the
- * KVP operations defined by the host.
- * Here is the level of compatibility
- * (between the user level daemon and the kernel KVP driver) that we
- * will implement:
- *
- * An older daemon will always be supported on a newer driver.
- * A given user level daemon will require a minimal version of the
- * kernel driver.
- * If we cannot handle the version differences, we will fail gracefully
- * (this can happen when we have a user level daemon that is more
- * advanced than the KVP driver.
- *
- * We will use values used in this handshake for determining if we have
- * workable user level daemon and the kernel driver. We begin by taking the
- * registration opcode out of the KVP opcode namespace. We will however,
- * maintain compatibility with the existing user-level daemon code.
- */
-
-/*
- * Daemon code not supporting IP injection (legacy daemon).
- */
-
-#define KVP_OP_REGISTER 4
-
-/*
- * Daemon code supporting IP injection.
- * The KVP opcode field is used to communicate the
- * registration information; so define a namespace that
- * will be distinct from the host defined KVP opcode.
- */
-
-#define KVP_OP_REGISTER1 100
-
-enum hv_kvp_exchg_op {
-        KVP_OP_GET = 0,
-        KVP_OP_SET,
-        KVP_OP_DELETE,
-        KVP_OP_ENUMERATE,
-        KVP_OP_GET_IP_INFO,
-        KVP_OP_SET_IP_INFO,
-        KVP_OP_COUNT /* Number of operations, must be last. */
-};
-
-enum hv_kvp_exchg_pool {
-        KVP_POOL_EXTERNAL = 0,
-        KVP_POOL_GUEST,
-        KVP_POOL_AUTO,
-        KVP_POOL_AUTO_EXTERNAL,
-        KVP_POOL_AUTO_INTERNAL,
-        KVP_POOL_COUNT /* Number of pools, must be last. */
-};
-
-/*
- * Some Hyper-V status codes.
- */
+#include <uapi/linux/hyperv.h>
 
-#define HV_S_OK                         0x00000000
-#define HV_E_FAIL                       0x80004005
-#define HV_S_CONT                       0x80070103
-#define HV_ERROR_NOT_SUPPORTED          0x80070032
-#define HV_ERROR_MACHINE_LOCKED         0x800704F7
-#define HV_ERROR_DEVICE_NOT_CONNECTED   0x8007048F
-#define HV_INVALIDARG                   0x80070057
-#define HV_GUID_NOTFOUND                0x80041002
-
-#define ADDR_FAMILY_NONE        0x00
-#define ADDR_FAMILY_IPV4        0x01
-#define ADDR_FAMILY_IPV6        0x02
-
-#define MAX_ADAPTER_ID_SIZE     128
-#define MAX_IP_ADDR_SIZE        1024
-#define MAX_GATEWAY_SIZE        512
-
-
-struct hv_kvp_ipaddr_value {
-        __u16   adapter_id[MAX_ADAPTER_ID_SIZE];
-        __u8    addr_family;
-        __u8    dhcp_enabled;
-        __u16   ip_addr[MAX_IP_ADDR_SIZE];
-        __u16   sub_net[MAX_IP_ADDR_SIZE];
-        __u16   gate_way[MAX_GATEWAY_SIZE];
-        __u16   dns_addr[MAX_IP_ADDR_SIZE];
-} __attribute__((packed));
-
-
-struct hv_kvp_hdr {
-        __u8 operation;
-        __u8 pool;
-        __u16 pad;
-} __attribute__((packed));
-
-struct hv_kvp_exchg_msg_value {
-        __u32 value_type;
-        __u32 key_size;
-        __u32 value_size;
-        __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
-        union {
-                __u8 value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE];
-                __u32 value_u32;
-                __u64 value_u64;
-        };
-} __attribute__((packed));
-
-struct hv_kvp_msg_enumerate {
-        __u32 index;
-        struct hv_kvp_exchg_msg_value data;
-} __attribute__((packed));
-
-struct hv_kvp_msg_get {
-        struct hv_kvp_exchg_msg_value data;
-};
-
-struct hv_kvp_msg_set {
-        struct hv_kvp_exchg_msg_value data;
-};
-
-struct hv_kvp_msg_delete {
-        __u32 key_size;
-        __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
-};
-
-struct hv_kvp_register {
-        __u8 version[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
-};
-
-struct hv_kvp_msg {
-        union {
-                struct hv_kvp_hdr       kvp_hdr;
-                int error;
-        };
-        union {
-                struct hv_kvp_msg_get           kvp_get;
-                struct hv_kvp_msg_set           kvp_set;
-                struct hv_kvp_msg_delete        kvp_delete;
-                struct hv_kvp_msg_enumerate     kvp_enum_data;
-                struct hv_kvp_ipaddr_value      kvp_ip_val;
-                struct hv_kvp_register          kvp_register;
-        } body;
-} __attribute__((packed));
-
-struct hv_kvp_ip_msg {
-        __u8 operation;
-        __u8 pool;
-        struct hv_kvp_ipaddr_value      kvp_ip_val;
-} __attribute__((packed));
-
-#ifdef __KERNEL__
+#include <linux/types.h>
 #include <linux/scatterlist.h>
 #include <linux/list.h>
-#include <linux/uuid.h>
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/completion.h>
@@ -354,7 +37,7 @@ struct hv_kvp_ip_msg {
 #include <linux/mod_devicetable.h>
 
 
-#define MAX_PAGE_BUFFER_COUNT                           19
+#define MAX_PAGE_BUFFER_COUNT                           32
 #define MAX_MULTIPAGE_BUFFER_COUNT                      32 /* 128K */
 
 #pragma pack(push, 1)
@@ -1043,6 +726,10 @@ struct vmbus_channel {
          * This will be NULL for the primary channel.
          */
         struct vmbus_channel *primary_channel;
+        /*
+         * Support per-channel state for use by vmbus drivers.
+         */
+        void *per_channel_state;
 };
 
 static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
@@ -1050,6 +737,16 @@ static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
         c->batched_reading = state;
 }
 
+static inline void set_per_channel_state(struct vmbus_channel *c, void *s)
+{
+        c->per_channel_state = s;
+}
+
+static inline void *get_per_channel_state(struct vmbus_channel *c)
+{
+        return c->per_channel_state;
+}
+
 void vmbus_onmessage(void *context);
 
 int vmbus_request_offers(void);
@@ -1118,7 +815,7 @@ extern int vmbus_open(struct vmbus_channel *channel,
 extern void vmbus_close(struct vmbus_channel *channel);
 
 extern int vmbus_sendpacket(struct vmbus_channel *channel,
-                                  const void *buffer,
+                                  void *buffer,
                                   u32 bufferLen,
                                   u64 requestid,
                                   enum vmbus_packet_type type,
@@ -1352,6 +1049,17 @@ void vmbus_driver_unregister(struct hv_driver *hv_driver);
                 }
 
 /*
+ * Guest File Copy Service
+ * {34D14BE3-DEE4-41c8-9AE7-6B174977C192}
+ */
+
+#define HV_FCOPY_GUID \
+        .guid = { \
+                        0xE3, 0x4B, 0xD1, 0x34, 0xE4, 0xDE, 0xC8, 0x41, \
+                        0x9A, 0xE7, 0x6B, 0x17, 0x49, 0x77, 0xC1, 0x92 \
+                }
+
+/*
  * Common header for Hyper-V ICs
  */
 
@@ -1459,11 +1167,12 @@ int hv_vss_init(struct hv_util_service *);
 void hv_vss_deinit(void);
 void hv_vss_onchannelcallback(void *);
 
+extern struct resource hyperv_mmio;
+
 /*
  * Negotiated version with the Host.
  */
 
 extern __u32 vmbus_proto_version;
 
-#endif /* __KERNEL__ */
 #endif /* _HYPERV_H */
diff --git a/include/linux/idr.h b/include/linux/idr.h
index 871a213a8477..9c95d210458b 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -85,6 +85,7 @@ void idr_remove(struct idr *idp, int id);
 void idr_free(struct idr *idp, int id);
 void idr_destroy(struct idr *idp);
 void idr_init(struct idr *idp);
+bool idr_is_empty(struct idr *idp);
 
 /**
  * idr_preload_end - end preload section started with idr_preload()
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index 75a8a20c8179..5f2d00e7e488 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -254,12 +254,16 @@ static inline bool iio_channel_has_info(const struct iio_chan_spec *chan,
                 (chan->info_mask_shared_by_all & BIT(type));
 }
 
-#define IIO_ST(si, rb, sb, sh)                                          \
-        { .sign = si, .realbits = rb, .storagebits = sb, .shift = sh }
-
-#define IIO_CHAN_SOFT_TIMESTAMP(_si)                                    \
-        { .type = IIO_TIMESTAMP, .channel = -1,                         \
-                        .scan_index = _si, .scan_type = IIO_ST('s', 64, 64, 0) }
+#define IIO_CHAN_SOFT_TIMESTAMP(_si) {                                  \
+        .type = IIO_TIMESTAMP,                                          \
+        .channel = -1,                                                  \
+        .scan_index = _si,                                              \
+        .scan_type = {                                                  \
+                .sign = 's',                                            \
+                .realbits = 64,                                 \
+                .storagebits = 64,                                      \
+                },                                                      \
+}
 
 /**
  * iio_get_time_ns() - utility function to get a time stamp for events etc
diff --git a/include/linux/init.h b/include/linux/init.h
index e1688802964f..a3ba27076342 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -163,6 +163,23 @@ extern bool initcall_debug;
 
 #ifndef __ASSEMBLY__
 
+#ifdef CONFIG_LTO
+/* Work around a LTO gcc problem: when there is no reference to a variable
+ * in a module it will be moved to the end of the program. This causes
+ * reordering of initcalls which the kernel does not like.
+ * Add a dummy reference function to avoid this. The function is
+ * deleted by the linker.
+ */
+#define LTO_REFERENCE_INITCALL(x) \
+        ; /* yes this is needed */                      \
+        static __used __exit void *reference_##x(void)  \
+        {                                               \
+                return &x;                              \
+        }
+#else
+#define LTO_REFERENCE_INITCALL(x)
+#endif
+
 /* initcalls are now grouped by functionality into separate 
  * subsections. Ordering inside the subsections is determined
  * by link order. 
@@ -175,7 +192,8 @@ extern bool initcall_debug;
 
 #define __define_initcall(fn, id) \
         static initcall_t __initcall_##fn##id __used \
-        __attribute__((__section__(".initcall" #id ".init"))) = fn
+        __attribute__((__section__(".initcall" #id ".init"))) = fn; \
+        LTO_REFERENCE_INITCALL(__initcall_##fn##id)
 
 /*
  * Early initcalls run before initializing SMP.
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index a2678d35b5a2..c7bfac1c4a7b 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -188,6 +188,7 @@ extern void disable_irq(unsigned int irq);
 extern void disable_percpu_irq(unsigned int irq);
 extern void enable_irq(unsigned int irq);
 extern void enable_percpu_irq(unsigned int irq, unsigned int type);
+extern void irq_wake_thread(unsigned int irq, void *dev_id);
 
 /* The following three functions are for the core kernel use only. */
 extern void suspend_device_irqs(void);
diff --git a/include/linux/io.h b/include/linux/io.h
index f4f42faec686..8a18e75600cc 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -24,7 +24,7 @@
 
 struct device;
 
-void __iowrite32_copy(void __iomem *to, const void *from, size_t count);
+__visible void __iowrite32_copy(void __iomem *to, const void *from, size_t count);
 void __iowrite64_copy(void __iomem *to, const void *from, size_t count);
 
 #ifdef CONFIG_MMU
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 89b7c24a36e9..5e3a906cc089 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -51,7 +51,7 @@ struct resource {
 
 #define IORESOURCE_EXCLUSIVE    0x08000000      /* Userland may not map this resource */
 #define IORESOURCE_DISABLED     0x10000000
-#define IORESOURCE_UNSET        0x20000000
+#define IORESOURCE_UNSET        0x20000000      /* No address assigned yet */
 #define IORESOURCE_AUTO         0x40000000
 #define IORESOURCE_BUSY         0x80000000      /* Driver has marked this resource busy */
 
@@ -169,6 +169,16 @@ static inline unsigned long resource_type(const struct resource *res)
 {
         return res->flags & IORESOURCE_TYPE_BITS;
 }
+/* True iff r1 completely contains r2 */
+static inline bool resource_contains(struct resource *r1, struct resource *r2)
+{
+        if (resource_type(r1) != resource_type(r2))
+                return false;
+        if (r1->flags & IORESOURCE_UNSET || r2->flags & IORESOURCE_UNSET)
+                return false;
+        return r1->start <= r2->start && r1->end >= r2->end;
+}
+
 
 /* Convenience shorthand with allocation */
 #define request_region(start,n,name)            __request_region(&ioport_resource, (start), (n), (name), 0)
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index e7831d203737..35e7eca4e33b 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -118,9 +118,7 @@ extern int mq_init_ns(struct ipc_namespace *ns);
  *     the new maximum will handle anyone else.  I may have to revisit this
  *     in the future.
  */
-#define MIN_QUEUESMAX                   1
 #define DFLT_QUEUESMAX                256
-#define HARD_QUEUESMAX               1024
 #define MIN_MSGMAX                      1
 #define DFLT_MSG                       10U
 #define DFLT_MSGMAX                    10
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 7dc10036eff5..d278838908cb 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -303,6 +303,10 @@ static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
  * @irq_pm_shutdown:    function called from core code on shutdown once per chip
  * @irq_calc_mask:      Optional function to set irq_data.mask for special cases
  * @irq_print_chip:     optional to print special chip info in show_interrupts
+ * @irq_request_resources:      optional to request resources before calling
+ *                              any other callback related to this irq
+ * @irq_release_resources:      optional to release resources acquired with
+ *                              irq_request_resources
  * @flags:              chip specific flags
  */
 struct irq_chip {
@@ -336,6 +340,8 @@ struct irq_chip {
         void            (*irq_calc_mask)(struct irq_data *data);
 
         void            (*irq_print_chip)(struct irq_data *data, struct seq_file *p);
+        int             (*irq_request_resources)(struct irq_data *data);
+        void            (*irq_release_resources)(struct irq_data *data);
 
         unsigned long   flags;
 };
@@ -349,6 +355,8 @@ struct irq_chip {
  * IRQCHIP_ONOFFLINE_ENABLED:   Only call irq_on/off_line callbacks
  *                              when irq enabled
  * IRQCHIP_SKIP_SET_WAKE:       Skip chip.irq_set_wake(), for this irq chip
+ * IRQCHIP_ONESHOT_SAFE:        One shot does not require mask/unmask
+ * IRQCHIP_EOI_THREADED:        Chip requires eoi() on unmask in threaded mode
  */
 enum {
         IRQCHIP_SET_TYPE_MASKED         = (1 <<  0),
@@ -357,6 +365,7 @@ enum {
         IRQCHIP_ONOFFLINE_ENABLED       = (1 <<  3),
         IRQCHIP_SKIP_SET_WAKE           = (1 <<  4),
         IRQCHIP_ONESHOT_SAFE            = (1 <<  5),
+        IRQCHIP_EOI_THREADED            = (1 <<  6),
 };
 
 /* This include will go away once we isolated irq_desc usage to core code */
diff --git a/include/linux/irq_work.h b/include/linux/irq_work.h
index 66017028dcb3..19ae05d4b8ec 100644
--- a/include/linux/irq_work.h
+++ b/include/linux/irq_work.h
@@ -30,7 +30,9 @@ void init_irq_work(struct irq_work *work, void (*func)(struct irq_work *))
         work->func = func;
 }
 
-void irq_work_queue(struct irq_work *work);
+#define DEFINE_IRQ_WORK(name, _f) struct irq_work name = { .func = (_f), }
+
+bool irq_work_queue(struct irq_work *work);
 void irq_work_run(void);
 void irq_work_sync(struct irq_work *work);
 
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 196d1ea86df0..08fb02477641 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -458,7 +458,7 @@ extern enum system_states {
 
 #define TAINT_PROPRIETARY_MODULE        0
 #define TAINT_FORCED_MODULE             1
-#define TAINT_UNSAFE_SMP                2
+#define TAINT_CPU_OUT_OF_SPEC           2
 #define TAINT_FORCED_RMMOD              3
 #define TAINT_MACHINE_CHECK             4
 #define TAINT_BAD_PAGE                  5
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index 51c72be4a7c3..ecbc52f9ff77 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -9,7 +9,7 @@
 #include <linux/sched.h>
 #include <linux/vtime.h>
 #include <asm/irq.h>
-#include <asm/cputime.h>
+#include <linux/cputime.h>
 
 /*
  * 'kernel_stat.h' contains the definitions needed for doing
@@ -51,14 +51,8 @@ DECLARE_PER_CPU(struct kernel_cpustat, kernel_cpustat);
 
 extern unsigned long long nr_context_switches(void);
 
-#include <linux/irq.h>
 extern unsigned int kstat_irqs_cpu(unsigned int irq, int cpu);
-
-#define kstat_incr_irqs_this_cpu(irqno, DESC)           \
-do {                                                    \
-        __this_cpu_inc(*(DESC)->kstat_irqs);            \
-        __this_cpu_inc(kstat.irqs_sum);                 \
-} while (0)
+extern void kstat_incr_irq_this_cpu(unsigned int irq);
 
 static inline void kstat_incr_softirqs_this_cpu(unsigned int irq)
 {
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index 5be9f0228a3b..b0122dc6f96a 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -15,7 +15,7 @@
 #include <linux/lockdep.h>
 #include <linux/rbtree.h>
 #include <linux/atomic.h>
-#include <linux/completion.h>
+#include <linux/wait.h>
 
 struct file;
 struct dentry;
@@ -35,16 +35,22 @@ enum kernfs_node_type {
 };
 
 #define KERNFS_TYPE_MASK        0x000f
-#define KERNFS_ACTIVE_REF       KERNFS_FILE
 #define KERNFS_FLAG_MASK        ~KERNFS_TYPE_MASK
 
 enum kernfs_node_flag {
-        KERNFS_REMOVED          = 0x0010,
+        KERNFS_ACTIVATED        = 0x0010,
         KERNFS_NS               = 0x0020,
         KERNFS_HAS_SEQ_SHOW     = 0x0040,
         KERNFS_HAS_MMAP         = 0x0080,
         KERNFS_LOCKDEP          = 0x0100,
         KERNFS_STATIC_NAME      = 0x0200,
+        KERNFS_SUICIDAL         = 0x0400,
+        KERNFS_SUICIDED         = 0x0800,
+};
+
+/* @flags for kernfs_create_root() */
+enum kernfs_root_flag {
+        KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
 };
 
 /* type-specific structures for kernfs_node union members */
@@ -85,17 +91,17 @@ struct kernfs_node {
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
         struct lockdep_map      dep_map;
 #endif
-        /* the following two fields are published */
+        /*
+         * Use kernfs_get_parent() and kernfs_name/path() instead of
+         * accessing the following two fields directly.  If the node is
+         * never moved to a different parent, it is safe to access the
+         * parent directly.
+         */
         struct kernfs_node      *parent;
         const char              *name;
 
         struct rb_node          rb;
 
-        union {
-                struct completion       *completion;
-                struct kernfs_node      *removed_list;
-        } u;
-
         const void              *ns;    /* namespace tag */
         unsigned int            hash;   /* ns + name hash */
         union {
@@ -113,12 +119,16 @@ struct kernfs_node {
 };
 
 /*
- * kernfs_dir_ops may be specified on kernfs_create_root() to support
- * directory manipulation syscalls.  These optional callbacks are invoked
- * on the matching syscalls and can perform any kernfs operations which
- * don't necessarily have to be the exact operation requested.
+ * kernfs_syscall_ops may be specified on kernfs_create_root() to support
+ * syscalls.  These optional callbacks are invoked on the matching syscalls
+ * and can perform any kernfs operations which don't necessarily have to be
+ * the exact operation requested.  An active reference is held for each
+ * kernfs_node parameter.
  */
-struct kernfs_dir_ops {
+struct kernfs_syscall_ops {
+        int (*remount_fs)(struct kernfs_root *root, int *flags, char *data);
+        int (*show_options)(struct seq_file *sf, struct kernfs_root *root);
+
         int (*mkdir)(struct kernfs_node *parent, const char *name,
                      umode_t mode);
         int (*rmdir)(struct kernfs_node *kn);
@@ -129,22 +139,26 @@ struct kernfs_dir_ops {
 struct kernfs_root {
         /* published fields */
         struct kernfs_node      *kn;
+        unsigned int            flags;  /* KERNFS_ROOT_* flags */
 
         /* private fields, do not use outside kernfs proper */
         struct ida              ino_ida;
-        struct kernfs_dir_ops   *dir_ops;
+        struct kernfs_syscall_ops *syscall_ops;
+        wait_queue_head_t       deactivate_waitq;
 };
 
 struct kernfs_open_file {
         /* published fields */
         struct kernfs_node      *kn;
         struct file             *file;
+        void                    *priv;
 
         /* private fields, do not use outside kernfs proper */
         struct mutex            mutex;
         int                     event;
         struct list_head        list;
 
+        size_t                  atomic_write_len;
         bool                    mmapped;
         const struct vm_operations_struct *vm_ops;
 };
@@ -171,9 +185,13 @@ struct kernfs_ops {
                         loff_t off);
 
         /*
-         * write() is bounced through kernel buffer and a write larger than
-         * PAGE_SIZE results in partial operation of PAGE_SIZE.
+         * write() is bounced through kernel buffer.  If atomic_write_len
+         * is not set, a write larger than PAGE_SIZE results in partial
+         * operations of PAGE_SIZE chunks.  If atomic_write_len is set,
+         * writes upto the specified size are executed atomically but
+         * larger ones are rejected with -E2BIG.
          */
+        size_t atomic_write_len;
         ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
                          loff_t off);
 
@@ -184,7 +202,7 @@ struct kernfs_ops {
 #endif
 };
 
-#ifdef CONFIG_SYSFS
+#ifdef CONFIG_KERNFS
 
 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
 {
@@ -217,13 +235,22 @@ static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
         return kn->flags & KERNFS_NS;
 }
 
+int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
+char * __must_check kernfs_path(struct kernfs_node *kn, char *buf,
+                                size_t buflen);
+void pr_cont_kernfs_name(struct kernfs_node *kn);
+void pr_cont_kernfs_path(struct kernfs_node *kn);
+struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
 struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
                                            const char *name, const void *ns);
 void kernfs_get(struct kernfs_node *kn);
 void kernfs_put(struct kernfs_node *kn);
 
-struct kernfs_root *kernfs_create_root(struct kernfs_dir_ops *kdops,
-                                       void *priv);
+struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
+struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
+
+struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
+                                       unsigned int flags, void *priv);
 void kernfs_destroy_root(struct kernfs_root *root);
 
 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
@@ -239,7 +266,11 @@ struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
 struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
                                        const char *name,
                                        struct kernfs_node *target);
+void kernfs_activate(struct kernfs_node *kn);
 void kernfs_remove(struct kernfs_node *kn);
+void kernfs_break_active_protection(struct kernfs_node *kn);
+void kernfs_unbreak_active_protection(struct kernfs_node *kn);
+bool kernfs_remove_self(struct kernfs_node *kn);
 int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
                              const void *ns);
 int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
@@ -249,12 +280,13 @@ void kernfs_notify(struct kernfs_node *kn);
 
 const void *kernfs_super_ns(struct super_block *sb);
 struct dentry *kernfs_mount_ns(struct file_system_type *fs_type, int flags,
-                               struct kernfs_root *root, const void *ns);
+                               struct kernfs_root *root, bool *new_sb_created,
+                               const void *ns);
 void kernfs_kill_sb(struct super_block *sb);
 
 void kernfs_init(void);
 
-#else   /* CONFIG_SYSFS */
+#else   /* CONFIG_KERNFS */
 
 static inline enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
 { return 0; }   /* whatever */
@@ -264,6 +296,19 @@ static inline void kernfs_enable_ns(struct kernfs_node *kn) { }
 static inline bool kernfs_ns_enabled(struct kernfs_node *kn)
 { return false; }
 
+static inline int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen)
+{ return -ENOSYS; }
+
+static inline char * __must_check kernfs_path(struct kernfs_node *kn, char *buf,
+                                              size_t buflen)
+{ return NULL; }
+
+static inline void pr_cont_kernfs_name(struct kernfs_node *kn) { }
+static inline void pr_cont_kernfs_path(struct kernfs_node *kn) { }
+
+static inline struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn)
+{ return NULL; }
+
 static inline struct kernfs_node *
 kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
                        const void *ns)
@@ -272,8 +317,15 @@ kernfs_find_and_get_ns(struct kernfs_node *parent, const char *name,
 static inline void kernfs_get(struct kernfs_node *kn) { }
 static inline void kernfs_put(struct kernfs_node *kn) { }
 
+static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
+{ return NULL; }
+
+static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
+{ return NULL; }
+
 static inline struct kernfs_root *
-kernfs_create_root(struct kernfs_dir_ops *kdops, void *priv)
+kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
+                   void *priv)
 { return ERR_PTR(-ENOSYS); }
 
 static inline void kernfs_destroy_root(struct kernfs_root *root) { }
@@ -295,8 +347,13 @@ kernfs_create_link(struct kernfs_node *parent, const char *name,
                    struct kernfs_node *target)
 { return ERR_PTR(-ENOSYS); }
 
+static inline void kernfs_activate(struct kernfs_node *kn) { }
+
 static inline void kernfs_remove(struct kernfs_node *kn) { }
 
+static inline bool kernfs_remove_self(struct kernfs_node *kn)
+{ return false; }
+
 static inline int kernfs_remove_by_name_ns(struct kernfs_node *kn,
                                            const char *name, const void *ns)
 { return -ENOSYS; }
@@ -317,14 +374,14 @@ static inline const void *kernfs_super_ns(struct super_block *sb)
 
 static inline struct dentry *
 kernfs_mount_ns(struct file_system_type *fs_type, int flags,
-                struct kernfs_root *root, const void *ns)
+                struct kernfs_root *root, bool *new_sb_created, const void *ns)
 { return ERR_PTR(-ENOSYS); }
 
 static inline void kernfs_kill_sb(struct super_block *sb) { }
 
 static inline void kernfs_init(void) { }
 
-#endif  /* CONFIG_SYSFS */
+#endif  /* CONFIG_KERNFS */
 
 static inline struct kernfs_node *
 kernfs_find_and_get(struct kernfs_node *kn, const char *name)
@@ -366,11 +423,18 @@ static inline int kernfs_remove_by_name(struct kernfs_node *parent,
         return kernfs_remove_by_name_ns(parent, name, NULL);
 }
 
+static inline int kernfs_rename(struct kernfs_node *kn,
+                                struct kernfs_node *new_parent,
+                                const char *new_name)
+{
+        return kernfs_rename_ns(kn, new_parent, new_name, NULL);
+}
+
 static inline struct dentry *
 kernfs_mount(struct file_system_type *fs_type, int flags,
-             struct kernfs_root *root)
+             struct kernfs_root *root, bool *new_sb_created)
 {
-        return kernfs_mount_ns(fs_type, flags, root, NULL);
+        return kernfs_mount_ns(fs_type, flags, root, new_sb_created, NULL);
 }
 
 #endif  /* __LINUX_KERNFS_H */
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index 6d4066cdb5b5..a75641930049 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -127,12 +127,6 @@ extern asmlinkage long sys_kexec_load(unsigned long entry,
                                         struct kexec_segment __user *segments,
                                         unsigned long flags);
 extern int kernel_kexec(void);
-#ifdef CONFIG_COMPAT
-extern asmlinkage long compat_sys_kexec_load(unsigned long entry,
-                                unsigned long nr_segments,
-                                struct compat_kexec_segment __user *segments,
-                                unsigned long flags);
-#endif
 extern struct page *kimage_alloc_control_pages(struct kimage *image,
                                                 unsigned int order);
 extern void crash_kexec(struct pt_regs *);
diff --git a/include/linux/libata.h b/include/linux/libata.h
index bec6dbe939a0..1de36be64df4 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -848,7 +848,6 @@ struct ata_port {
         struct completion       park_req_pending;
 
         pm_message_t            pm_mesg;
-        int                     *pm_result;
         enum ata_lpm_policy     target_lpm_policy;
 
         struct timer_list       fastdrain_timer;
@@ -1140,16 +1139,14 @@ extern bool ata_link_offline(struct ata_link *link);
 #ifdef CONFIG_PM
 extern int ata_host_suspend(struct ata_host *host, pm_message_t mesg);
 extern void ata_host_resume(struct ata_host *host);
-extern int ata_sas_port_async_suspend(struct ata_port *ap, int *async);
-extern int ata_sas_port_async_resume(struct ata_port *ap, int *async);
+extern void ata_sas_port_suspend(struct ata_port *ap);
+extern void ata_sas_port_resume(struct ata_port *ap);
 #else
-static inline int ata_sas_port_async_suspend(struct ata_port *ap, int *async)
+static inline void ata_sas_port_suspend(struct ata_port *ap)
 {
-        return 0;
 }
-static inline int ata_sas_port_async_resume(struct ata_port *ap, int *async)
+static inline void ata_sas_port_resume(struct ata_port *ap)
 {
-        return 0;
 }
 #endif
 extern int ata_ratelimit(void);
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
index a6a42dd02466..34a513a2727b 100644
--- a/include/linux/linkage.h
+++ b/include/linux/linkage.h
@@ -12,9 +12,9 @@
 #endif
 
 #ifdef __cplusplus
-#define CPP_ASMLINKAGE extern "C"
+#define CPP_ASMLINKAGE extern "C" __visible
 #else
-#define CPP_ASMLINKAGE
+#define CPP_ASMLINKAGE __visible
 #endif
 
 #ifndef asmlinkage
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 92b1bfc5da60..008388f920d7 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -252,9 +252,9 @@ struct held_lock {
         unsigned int trylock:1;                                         /* 16 bits */
 
         unsigned int read:2;        /* see lock_acquire() comment */
-        unsigned int check:2;       /* see lock_acquire() comment */
+        unsigned int check:1;       /* see lock_acquire() comment */
         unsigned int hardirqs_off:1;
-        unsigned int references:11;                                     /* 32 bits */
+        unsigned int references:12;                                     /* 32 bits */
 };
 
 /*
@@ -265,7 +265,7 @@ extern void lockdep_info(void);
 extern void lockdep_reset(void);
 extern void lockdep_reset_lock(struct lockdep_map *lock);
 extern void lockdep_free_key_range(void *start, unsigned long size);
-extern void lockdep_sys_exit(void);
+extern asmlinkage void lockdep_sys_exit(void);
 
 extern void lockdep_off(void);
 extern void lockdep_on(void);
@@ -303,7 +303,7 @@ extern void lockdep_init_map(struct lockdep_map *lock, const char *name,
                                  (lock)->dep_map.key, sub)
 
 #define lockdep_set_novalidate_class(lock) \
-        lockdep_set_class(lock, &__lockdep_no_validate__)
+        lockdep_set_class_and_name(lock, &__lockdep_no_validate__, #lock)
 /*
  * Compare locking classes
  */
@@ -326,9 +326,8 @@ static inline int lockdep_match_key(struct lockdep_map *lock,
  *
  * Values for check:
  *
- *   0: disabled
- *   1: simple checks (freeing, held-at-exit-time, etc.)
- *   2: full validation
+ *   0: simple checks (freeing, held-at-exit-time, etc.)
+ *   1: full validation
  */
 extern void lock_acquire(struct lockdep_map *lock, unsigned int subclass,
                          int trylock, int read, int check,
@@ -479,15 +478,9 @@ static inline void print_irqtrace_events(struct task_struct *curr)
  * on the per lock-class debug mode:
  */
 
-#ifdef CONFIG_PROVE_LOCKING
- #define lock_acquire_exclusive(l, s, t, n, i)          lock_acquire(l, s, t, 0, 2, n, i)
- #define lock_acquire_shared(l, s, t, n, i)             lock_acquire(l, s, t, 1, 2, n, i)
- #define lock_acquire_shared_recursive(l, s, t, n, i)   lock_acquire(l, s, t, 2, 2, n, i)
-#else
- #define lock_acquire_exclusive(l, s, t, n, i)          lock_acquire(l, s, t, 0, 1, n, i)
- #define lock_acquire_shared(l, s, t, n, i)             lock_acquire(l, s, t, 1, 1, n, i)
- #define lock_acquire_shared_recursive(l, s, t, n, i)   lock_acquire(l, s, t, 2, 1, n, i)
-#endif
+#define lock_acquire_exclusive(l, s, t, n, i)           lock_acquire(l, s, t, 0, 1, n, i)
+#define lock_acquire_shared(l, s, t, n, i)              lock_acquire(l, s, t, 1, 1, n, i)
+#define lock_acquire_shared_recursive(l, s, t, n, i)    lock_acquire(l, s, t, 2, 1, n, i)
 
 #define spin_acquire(l, s, t, i)                lock_acquire_exclusive(l, s, t, NULL, i)
 #define spin_acquire_nest(l, s, t, n, i)        lock_acquire_exclusive(l, s, t, n, i)
@@ -518,13 +511,13 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 # define might_lock(lock)                                               \
 do {                                                                    \
         typecheck(struct lockdep_map *, &(lock)->dep_map);              \
-        lock_acquire(&(lock)->dep_map, 0, 0, 0, 2, NULL, _THIS_IP_);    \
+        lock_acquire(&(lock)->dep_map, 0, 0, 0, 1, NULL, _THIS_IP_);    \
         lock_release(&(lock)->dep_map, 0, _THIS_IP_);                   \
 } while (0)
 # define might_lock_read(lock)                                          \
 do {                                                                    \
         typecheck(struct lockdep_map *, &(lock)->dep_map);              \
-        lock_acquire(&(lock)->dep_map, 0, 0, 1, 2, NULL, _THIS_IP_);    \
+        lock_acquire(&(lock)->dep_map, 0, 0, 1, 1, NULL, _THIS_IP_);    \
         lock_release(&(lock)->dep_map, 0, _THIS_IP_);                   \
 } while (0)
 #else
diff --git a/include/linux/mcb.h b/include/linux/mcb.h
new file mode 100644
index 000000000000..2db284d14064
--- /dev/null
+++ b/include/linux/mcb.h
@@ -0,0 +1,119 @@
+/*
+ * MEN Chameleon Bus.
+ *
+ * Copyright (C) 2014 MEN Mikroelektronik GmbH (www.men.de)
+ * Author: Johannes Thumshirn <johannes.thumshirn@men.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2 of the License.
+ */
+#ifndef _LINUX_MCB_H
+#define _LINUX_MCB_H
+
+#include <linux/mod_devicetable.h>
+#include <linux/device.h>
+#include <linux/irqreturn.h>
+
+struct mcb_driver;
+
+/**
+ * struct mcb_bus - MEN Chameleon Bus
+ *
+ * @dev: pointer to carrier device
+ * @children: the child busses
+ * @bus_nr: mcb bus number
+ */
+struct mcb_bus {
+        struct list_head children;
+        struct device dev;
+        int bus_nr;
+};
+#define to_mcb_bus(b) container_of((b), struct mcb_bus, dev)
+
+/**
+ * struct mcb_device - MEN Chameleon Bus device
+ *
+ * @bus_list: internal list handling for bus code
+ * @dev: device in kernel representation
+ * @bus: mcb bus the device is plugged to
+ * @subordinate: subordinate MCBus in case of bridge
+ * @is_added: flag to check if device is added to bus
+ * @driver: associated mcb_driver
+ * @id: mcb device id
+ * @inst: instance in Chameleon table
+ * @group: group in Chameleon table
+ * @var: variant in Chameleon table
+ * @bar: BAR in Chameleon table
+ * @rev: revision in Chameleon table
+ * @irq: IRQ resource
+ * @memory: memory resource
+ */
+struct mcb_device {
+        struct list_head bus_list;
+        struct device dev;
+        struct mcb_bus *bus;
+        struct mcb_bus *subordinate;
+        bool is_added;
+        struct mcb_driver *driver;
+        u16 id;
+        int inst;
+        int group;
+        int var;
+        int bar;
+        int rev;
+        struct resource irq;
+        struct resource mem;
+};
+#define to_mcb_device(x) container_of((x), struct mcb_device, dev)
+
+/**
+ * struct mcb_driver - MEN Chameleon Bus device driver
+ *
+ * @driver: device_driver
+ * @id_table: mcb id table
+ * @probe: probe callback
+ * @remove: remove callback
+ * @shutdown: shutdown callback
+ */
+struct mcb_driver {
+        struct device_driver driver;
+        const struct mcb_device_id *id_table;
+        int (*probe)(struct mcb_device *mdev, const struct mcb_device_id *id);
+        void (*remove)(struct mcb_device *mdev);
+        void (*shutdown)(struct mcb_device *mdev);
+};
+#define to_mcb_driver(x) container_of((x), struct mcb_driver, driver)
+
+static inline void *mcb_get_drvdata(struct mcb_device *dev)
+{
+        return dev_get_drvdata(&dev->dev);
+}
+
+static inline void mcb_set_drvdata(struct mcb_device *dev, void *data)
+{
+        dev_set_drvdata(&dev->dev, data);
+}
+
+extern int __must_check __mcb_register_driver(struct mcb_driver *drv,
+                                        struct module *owner,
+                                        const char *mod_name);
+#define mcb_register_driver(driver)             \
+        __mcb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
+extern void mcb_unregister_driver(struct mcb_driver *driver);
+#define module_mcb_driver(__mcb_driver)         \
+        module_driver(__mcb_driver, mcb_register_driver, mcb_unregister_driver);
+extern void mcb_bus_add_devices(const struct mcb_bus *bus);
+extern int mcb_device_register(struct mcb_bus *bus, struct mcb_device *dev);
+extern struct mcb_bus *mcb_alloc_bus(void);
+extern struct mcb_bus *mcb_bus_get(struct mcb_bus *bus);
+extern void mcb_bus_put(struct mcb_bus *bus);
+extern struct mcb_device *mcb_alloc_dev(struct mcb_bus *bus);
+extern void mcb_free_dev(struct mcb_device *dev);
+extern void mcb_release_bus(struct mcb_bus *bus);
+extern struct resource *mcb_request_mem(struct mcb_device *dev,
+                                        const char *name);
+extern void mcb_release_mem(struct resource *mem);
+extern int mcb_get_irq(struct mcb_device *dev);
+
+#endif /* _LINUX_MCB_H */
diff --git a/include/linux/mfd/arizona/registers.h b/include/linux/mfd/arizona/registers.h
index fdf3aa376eb2..3ddaa634b19d 100644
--- a/include/linux/mfd/arizona/registers.h
+++ b/include/linux/mfd/arizona/registers.h
@@ -1702,9 +1702,9 @@
 /*
  * R373 (0x175) - FLL1 Control 5
  */
-#define ARIZONA_FLL1_FRATIO_MASK                 0x0700  /* FLL1_FRATIO - [10:8] */
-#define ARIZONA_FLL1_FRATIO_SHIFT                     8  /* FLL1_FRATIO - [10:8] */
-#define ARIZONA_FLL1_FRATIO_WIDTH                     3  /* FLL1_FRATIO - [10:8] */
+#define ARIZONA_FLL1_FRATIO_MASK                 0x0F00  /* FLL1_FRATIO - [11:8] */
+#define ARIZONA_FLL1_FRATIO_SHIFT                     8  /* FLL1_FRATIO - [11:8] */
+#define ARIZONA_FLL1_FRATIO_WIDTH                     4  /* FLL1_FRATIO - [11:8] */
 #define ARIZONA_FLL1_OUTDIV_MASK                 0x000E  /* FLL1_OUTDIV - [3:1] */
 #define ARIZONA_FLL1_OUTDIV_SHIFT                     1  /* FLL1_OUTDIV - [3:1] */
 #define ARIZONA_FLL1_OUTDIV_WIDTH                     3  /* FLL1_OUTDIV - [3:1] */
diff --git a/include/linux/mfd/max8997-private.h b/include/linux/mfd/max8997-private.h
index ad1ae7f345ad..78c76cd4d37b 100644
--- a/include/linux/mfd/max8997-private.h
+++ b/include/linux/mfd/max8997-private.h
@@ -387,7 +387,7 @@ struct max8997_dev {
         struct i2c_client *muic; /* slave addr 0x4a */
         struct mutex iolock;
 
-        int type;
+        unsigned long type;
         struct platform_device *battery; /* battery control (not fuel gauge) */
 
         int irq;
diff --git a/include/linux/mfd/max8998-private.h b/include/linux/mfd/max8998-private.h
index 4ecb24b4b863..d68ada502ff3 100644
--- a/include/linux/mfd/max8998-private.h
+++ b/include/linux/mfd/max8998-private.h
@@ -163,7 +163,7 @@ struct max8998_dev {
         int ono;
         u8 irq_masks_cur[MAX8998_NUM_IRQ_REGS];
         u8 irq_masks_cache[MAX8998_NUM_IRQ_REGS];
-        int type;
+        unsigned long type;
         bool wakeup;
 };
 
diff --git a/include/linux/mfd/samsung/core.h b/include/linux/mfd/samsung/core.h
index 41c9bde410c5..157e32b6ca28 100644
--- a/include/linux/mfd/samsung/core.h
+++ b/include/linux/mfd/samsung/core.h
@@ -18,7 +18,9 @@ enum sec_device_type {
         S5M8751X,
         S5M8763X,
         S5M8767X,
+        S2MPA01,
         S2MPS11X,
+        S2MPS14X,
 };
 
 /**
@@ -50,7 +52,7 @@ struct sec_pmic_dev {
         struct regmap_irq_chip_data *irq_data;
 
         int ono;
-        int type;
+        unsigned long type;
         bool wakeup;
         bool wtsr_smpl;
 };
@@ -92,7 +94,7 @@ struct sec_platform_data {
         int                             buck3_default_idx;
         int                             buck4_default_idx;
 
-        int                             buck_ramp_delay;
+        int                             buck_ramp_delay;
 
         int                             buck2_ramp_delay;
         int                             buck34_ramp_delay;
@@ -100,10 +102,15 @@ struct sec_platform_data {
         int                             buck16_ramp_delay;
         int                             buck7810_ramp_delay;
         int                             buck9_ramp_delay;
-
-        bool                            buck2_ramp_enable;
-        bool                            buck3_ramp_enable;
-        bool                            buck4_ramp_enable;
+        int                             buck24_ramp_delay;
+        int                             buck3_ramp_delay;
+        int                             buck7_ramp_delay;
+        int                             buck8910_ramp_delay;
+
+        bool                            buck1_ramp_enable;
+        bool                            buck2_ramp_enable;
+        bool                            buck3_ramp_enable;
+        bool                            buck4_ramp_enable;
         bool                            buck6_ramp_enable;
 
         int                             buck2_init;
@@ -119,7 +126,8 @@ struct sec_platform_data {
 struct sec_regulator_data {
         int                             id;
         struct regulator_init_data      *initdata;
-        struct device_node *reg_node;
+        struct device_node              *reg_node;
+        int                             ext_control_gpio;
 };
 
 /*
diff --git a/include/linux/mfd/samsung/irq.h b/include/linux/mfd/samsung/irq.h
index d43b4f9e7fb2..1224f447356b 100644
--- a/include/linux/mfd/samsung/irq.h
+++ b/include/linux/mfd/samsung/irq.h
@@ -13,6 +13,56 @@
 #ifndef __LINUX_MFD_SEC_IRQ_H
 #define __LINUX_MFD_SEC_IRQ_H
 
+enum s2mpa01_irq {
+        S2MPA01_IRQ_PWRONF,
+        S2MPA01_IRQ_PWRONR,
+        S2MPA01_IRQ_JIGONBF,
+        S2MPA01_IRQ_JIGONBR,
+        S2MPA01_IRQ_ACOKBF,
+        S2MPA01_IRQ_ACOKBR,
+        S2MPA01_IRQ_PWRON1S,
+        S2MPA01_IRQ_MRB,
+
+        S2MPA01_IRQ_RTC60S,
+        S2MPA01_IRQ_RTCA1,
+        S2MPA01_IRQ_RTCA0,
+        S2MPA01_IRQ_SMPL,
+        S2MPA01_IRQ_RTC1S,
+        S2MPA01_IRQ_WTSR,
+
+        S2MPA01_IRQ_INT120C,
+        S2MPA01_IRQ_INT140C,
+        S2MPA01_IRQ_LDO3_TSD,
+        S2MPA01_IRQ_B16_TSD,
+        S2MPA01_IRQ_B24_TSD,
+        S2MPA01_IRQ_B35_TSD,
+
+        S2MPA01_IRQ_NR,
+};
+
+#define S2MPA01_IRQ_PWRONF_MASK         (1 << 0)
+#define S2MPA01_IRQ_PWRONR_MASK         (1 << 1)
+#define S2MPA01_IRQ_JIGONBF_MASK        (1 << 2)
+#define S2MPA01_IRQ_JIGONBR_MASK        (1 << 3)
+#define S2MPA01_IRQ_ACOKBF_MASK         (1 << 4)
+#define S2MPA01_IRQ_ACOKBR_MASK         (1 << 5)
+#define S2MPA01_IRQ_PWRON1S_MASK        (1 << 6)
+#define S2MPA01_IRQ_MRB_MASK            (1 << 7)
+
+#define S2MPA01_IRQ_RTC60S_MASK         (1 << 0)
+#define S2MPA01_IRQ_RTCA1_MASK          (1 << 1)
+#define S2MPA01_IRQ_RTCA0_MASK          (1 << 2)
+#define S2MPA01_IRQ_SMPL_MASK           (1 << 3)
+#define S2MPA01_IRQ_RTC1S_MASK          (1 << 4)
+#define S2MPA01_IRQ_WTSR_MASK           (1 << 5)
+
+#define S2MPA01_IRQ_INT120C_MASK        (1 << 0)
+#define S2MPA01_IRQ_INT140C_MASK        (1 << 1)
+#define S2MPA01_IRQ_LDO3_TSD_MASK       (1 << 2)
+#define S2MPA01_IRQ_B16_TSD_MASK        (1 << 3)
+#define S2MPA01_IRQ_B24_TSD_MASK        (1 << 4)
+#define S2MPA01_IRQ_B35_TSD_MASK        (1 << 5)
+
 enum s2mps11_irq {
         S2MPS11_IRQ_PWRONF,
         S2MPS11_IRQ_PWRONR,
@@ -24,8 +74,8 @@ enum s2mps11_irq {
         S2MPS11_IRQ_MRB,
 
         S2MPS11_IRQ_RTC60S,
+        S2MPS11_IRQ_RTCA0,
         S2MPS11_IRQ_RTCA1,
-        S2MPS11_IRQ_RTCA2,
         S2MPS11_IRQ_SMPL,
         S2MPS11_IRQ_RTC1S,
         S2MPS11_IRQ_WTSR,
@@ -47,7 +97,7 @@ enum s2mps11_irq {
 
 #define S2MPS11_IRQ_RTC60S_MASK         (1 << 0)
 #define S2MPS11_IRQ_RTCA1_MASK          (1 << 1)
-#define S2MPS11_IRQ_RTCA2_MASK          (1 << 2)
+#define S2MPS11_IRQ_RTCA0_MASK          (1 << 2)
 #define S2MPS11_IRQ_SMPL_MASK           (1 << 3)
 #define S2MPS11_IRQ_RTC1S_MASK          (1 << 4)
 #define S2MPS11_IRQ_WTSR_MASK           (1 << 5)
@@ -55,6 +105,33 @@ enum s2mps11_irq {
 #define S2MPS11_IRQ_INT120C_MASK        (1 << 0)
 #define S2MPS11_IRQ_INT140C_MASK        (1 << 1)
 
+enum s2mps14_irq {
+        S2MPS14_IRQ_PWRONF,
+        S2MPS14_IRQ_PWRONR,
+        S2MPS14_IRQ_JIGONBF,
+        S2MPS14_IRQ_JIGONBR,
+        S2MPS14_IRQ_ACOKBF,
+        S2MPS14_IRQ_ACOKBR,
+        S2MPS14_IRQ_PWRON1S,
+        S2MPS14_IRQ_MRB,
+
+        S2MPS14_IRQ_RTC60S,
+        S2MPS14_IRQ_RTCA1,
+        S2MPS14_IRQ_RTCA0,
+        S2MPS14_IRQ_SMPL,
+        S2MPS14_IRQ_RTC1S,
+        S2MPS14_IRQ_WTSR,
+
+        S2MPS14_IRQ_INT120C,
+        S2MPS14_IRQ_INT140C,
+        S2MPS14_IRQ_TSD,
+
+        S2MPS14_IRQ_NR,
+};
+
+/* Masks for interrupts are the same as in s2mps11 */
+#define S2MPS14_IRQ_TSD_MASK            (1 << 2)
+
 enum s5m8767_irq {
         S5M8767_IRQ_PWRR,
         S5M8767_IRQ_PWRF,
diff --git a/include/linux/mfd/samsung/rtc.h b/include/linux/mfd/samsung/rtc.h
index 94b7cd6d8891..3e02b768d537 100644
--- a/include/linux/mfd/samsung/rtc.h
+++ b/include/linux/mfd/samsung/rtc.h
@@ -1,12 +1,17 @@
-/*  rtc.h
+/* rtc.h
  *
- * Copyright (c) 2011 Samsung Electronics Co., Ltd
+ * Copyright (c) 2011-2014 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
  *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
  */
 
@@ -43,6 +48,39 @@ enum sec_rtc_reg {
         SEC_RTC_STATUS,
         SEC_WTSR_SMPL_CNTL,
         SEC_RTC_UDR_CON,
+
+        SEC_RTC_REG_MAX,
+};
+
+enum s2mps_rtc_reg {
+        S2MPS_RTC_CTRL,
+        S2MPS_WTSR_SMPL_CNTL,
+        S2MPS_RTC_UDR_CON,
+        S2MPS_RSVD,
+        S2MPS_RTC_SEC,
+        S2MPS_RTC_MIN,
+        S2MPS_RTC_HOUR,
+        S2MPS_RTC_WEEKDAY,
+        S2MPS_RTC_DATE,
+        S2MPS_RTC_MONTH,
+        S2MPS_RTC_YEAR,
+        S2MPS_ALARM0_SEC,
+        S2MPS_ALARM0_MIN,
+        S2MPS_ALARM0_HOUR,
+        S2MPS_ALARM0_WEEKDAY,
+        S2MPS_ALARM0_DATE,
+        S2MPS_ALARM0_MONTH,
+        S2MPS_ALARM0_YEAR,
+        S2MPS_ALARM1_SEC,
+        S2MPS_ALARM1_MIN,
+        S2MPS_ALARM1_HOUR,
+        S2MPS_ALARM1_WEEKDAY,
+        S2MPS_ALARM1_DATE,
+        S2MPS_ALARM1_MONTH,
+        S2MPS_ALARM1_YEAR,
+        S2MPS_OFFSRC,
+
+        S2MPS_RTC_REG_MAX,
 };
 
 #define RTC_I2C_ADDR            (0x0C >> 1)
@@ -54,6 +92,9 @@ enum sec_rtc_reg {
 #define ALARM1_STATUS           (1 << 2)
 #define UPDATE_AD               (1 << 0)
 
+#define S2MPS_ALARM0_STATUS     (1 << 2)
+#define S2MPS_ALARM1_STATUS     (1 << 1)
+
 /* RTC Control Register */
 #define BCD_EN_SHIFT            0
 #define BCD_EN_MASK             (1 << BCD_EN_SHIFT)
@@ -62,6 +103,10 @@ enum sec_rtc_reg {
 /* RTC Update Register1 */
 #define RTC_UDR_SHIFT           0
 #define RTC_UDR_MASK            (1 << RTC_UDR_SHIFT)
+#define S2MPS_RTC_WUDR_SHIFT    4
+#define S2MPS_RTC_WUDR_MASK     (1 << S2MPS_RTC_WUDR_SHIFT)
+#define S2MPS_RTC_RUDR_SHIFT    0
+#define S2MPS_RTC_RUDR_MASK     (1 << S2MPS_RTC_RUDR_SHIFT)
 #define RTC_TCON_SHIFT          1
 #define RTC_TCON_MASK           (1 << RTC_TCON_SHIFT)
 #define RTC_TIME_EN_SHIFT       3
diff --git a/include/linux/mfd/samsung/s2mpa01.h b/include/linux/mfd/samsung/s2mpa01.h
new file mode 100644
index 000000000000..fbc63bc0d6a2
--- /dev/null
+++ b/include/linux/mfd/samsung/s2mpa01.h
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd
+ *              http://www.samsung.com
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#ifndef __LINUX_MFD_S2MPA01_H
+#define __LINUX_MFD_S2MPA01_H
+
+/* S2MPA01 registers */
+enum s2mpa01_reg {
+        S2MPA01_REG_ID,
+        S2MPA01_REG_INT1,
+        S2MPA01_REG_INT2,
+        S2MPA01_REG_INT3,
+        S2MPA01_REG_INT1M,
+        S2MPA01_REG_INT2M,
+        S2MPA01_REG_INT3M,
+        S2MPA01_REG_ST1,
+        S2MPA01_REG_ST2,
+        S2MPA01_REG_PWRONSRC,
+        S2MPA01_REG_OFFSRC,
+        S2MPA01_REG_RTC_BUF,
+        S2MPA01_REG_CTRL1,
+        S2MPA01_REG_ETC_TEST,
+        S2MPA01_REG_RSVD1,
+        S2MPA01_REG_BU_CHG,
+        S2MPA01_REG_RAMP1,
+        S2MPA01_REG_RAMP2,
+        S2MPA01_REG_LDO_DSCH1,
+        S2MPA01_REG_LDO_DSCH2,
+        S2MPA01_REG_LDO_DSCH3,
+        S2MPA01_REG_LDO_DSCH4,
+        S2MPA01_REG_OTP_ADRL,
+        S2MPA01_REG_OTP_ADRH,
+        S2MPA01_REG_OTP_DATA,
+        S2MPA01_REG_MON1SEL,
+        S2MPA01_REG_MON2SEL,
+        S2MPA01_REG_LEE,
+        S2MPA01_REG_RSVD2,
+        S2MPA01_REG_RSVD3,
+        S2MPA01_REG_RSVD4,
+        S2MPA01_REG_RSVD5,
+        S2MPA01_REG_RSVD6,
+        S2MPA01_REG_TOP_RSVD,
+        S2MPA01_REG_DVS_SEL,
+        S2MPA01_REG_DVS_PTR,
+        S2MPA01_REG_DVS_DATA,
+        S2MPA01_REG_RSVD_NO,
+        S2MPA01_REG_UVLO,
+        S2MPA01_REG_LEE_NO,
+        S2MPA01_REG_B1CTRL1,
+        S2MPA01_REG_B1CTRL2,
+        S2MPA01_REG_B2CTRL1,
+        S2MPA01_REG_B2CTRL2,
+        S2MPA01_REG_B3CTRL1,
+        S2MPA01_REG_B3CTRL2,
+        S2MPA01_REG_B4CTRL1,
+        S2MPA01_REG_B4CTRL2,
+        S2MPA01_REG_B5CTRL1,
+        S2MPA01_REG_B5CTRL2,
+        S2MPA01_REG_B5CTRL3,
+        S2MPA01_REG_B5CTRL4,
+        S2MPA01_REG_B5CTRL5,
+        S2MPA01_REG_B5CTRL6,
+        S2MPA01_REG_B6CTRL1,
+        S2MPA01_REG_B6CTRL2,
+        S2MPA01_REG_B7CTRL1,
+        S2MPA01_REG_B7CTRL2,
+        S2MPA01_REG_B8CTRL1,
+        S2MPA01_REG_B8CTRL2,
+        S2MPA01_REG_B9CTRL1,
+        S2MPA01_REG_B9CTRL2,
+        S2MPA01_REG_B10CTRL1,
+        S2MPA01_REG_B10CTRL2,
+        S2MPA01_REG_L1CTRL,
+        S2MPA01_REG_L2CTRL,
+        S2MPA01_REG_L3CTRL,
+        S2MPA01_REG_L4CTRL,
+        S2MPA01_REG_L5CTRL,
+        S2MPA01_REG_L6CTRL,
+        S2MPA01_REG_L7CTRL,
+        S2MPA01_REG_L8CTRL,
+        S2MPA01_REG_L9CTRL,
+        S2MPA01_REG_L10CTRL,
+        S2MPA01_REG_L11CTRL,
+        S2MPA01_REG_L12CTRL,
+        S2MPA01_REG_L13CTRL,
+        S2MPA01_REG_L14CTRL,
+        S2MPA01_REG_L15CTRL,
+        S2MPA01_REG_L16CTRL,
+        S2MPA01_REG_L17CTRL,
+        S2MPA01_REG_L18CTRL,
+        S2MPA01_REG_L19CTRL,
+        S2MPA01_REG_L20CTRL,
+        S2MPA01_REG_L21CTRL,
+        S2MPA01_REG_L22CTRL,
+        S2MPA01_REG_L23CTRL,
+        S2MPA01_REG_L24CTRL,
+        S2MPA01_REG_L25CTRL,
+        S2MPA01_REG_L26CTRL,
+
+        S2MPA01_REG_LDO_OVCB1,
+        S2MPA01_REG_LDO_OVCB2,
+        S2MPA01_REG_LDO_OVCB3,
+        S2MPA01_REG_LDO_OVCB4,
+
+};
+
+/* S2MPA01 regulator ids */
+enum s2mpa01_regulators {
+        S2MPA01_LDO1,
+        S2MPA01_LDO2,
+        S2MPA01_LDO3,
+        S2MPA01_LDO4,
+        S2MPA01_LDO5,
+        S2MPA01_LDO6,
+        S2MPA01_LDO7,
+        S2MPA01_LDO8,
+        S2MPA01_LDO9,
+        S2MPA01_LDO10,
+        S2MPA01_LDO11,
+        S2MPA01_LDO12,
+        S2MPA01_LDO13,
+        S2MPA01_LDO14,
+        S2MPA01_LDO15,
+        S2MPA01_LDO16,
+        S2MPA01_LDO17,
+        S2MPA01_LDO18,
+        S2MPA01_LDO19,
+        S2MPA01_LDO20,
+        S2MPA01_LDO21,
+        S2MPA01_LDO22,
+        S2MPA01_LDO23,
+        S2MPA01_LDO24,
+        S2MPA01_LDO25,
+        S2MPA01_LDO26,
+
+        S2MPA01_BUCK1,
+        S2MPA01_BUCK2,
+        S2MPA01_BUCK3,
+        S2MPA01_BUCK4,
+        S2MPA01_BUCK5,
+        S2MPA01_BUCK6,
+        S2MPA01_BUCK7,
+        S2MPA01_BUCK8,
+        S2MPA01_BUCK9,
+        S2MPA01_BUCK10,
+
+        S2MPA01_REGULATOR_MAX,
+};
+
+#define S2MPA01_BUCK_MIN1       600000
+#define S2MPA01_BUCK_MIN2       800000
+#define S2MPA01_BUCK_MIN3       1000000
+#define S2MPA01_BUCK_MIN4       1500000
+#define S2MPA01_LDO_MIN         800000
+
+#define S2MPA01_BUCK_STEP1      6250
+#define S2MPA01_BUCK_STEP2      12500
+
+#define S2MPA01_LDO_STEP1       50000
+#define S2MPA01_LDO_STEP2       25000
+
+#define S2MPA01_LDO_VSEL_MASK   0x3F
+#define S2MPA01_BUCK_VSEL_MASK  0xFF
+#define S2MPA01_ENABLE_MASK     (0x03 << S2MPA01_ENABLE_SHIFT)
+#define S2MPA01_ENABLE_SHIFT    0x06
+#define S2MPA01_LDO_N_VOLTAGES  (S2MPA01_LDO_VSEL_MASK + 1)
+#define S2MPA01_BUCK_N_VOLTAGES (S2MPA01_BUCK_VSEL_MASK + 1)
+
+#define S2MPA01_RAMP_DELAY      12500   /* uV/us */
+
+#define S2MPA01_BUCK16_RAMP_SHIFT       4
+#define S2MPA01_BUCK24_RAMP_SHIFT       6
+#define S2MPA01_BUCK3_RAMP_SHIFT        4
+#define S2MPA01_BUCK5_RAMP_SHIFT        6
+#define S2MPA01_BUCK7_RAMP_SHIFT        2
+#define S2MPA01_BUCK8910_RAMP_SHIFT     0
+
+#define S2MPA01_BUCK1_RAMP_EN_SHIFT     3
+#define S2MPA01_BUCK2_RAMP_EN_SHIFT     2
+#define S2MPA01_BUCK3_RAMP_EN_SHIFT     1
+#define S2MPA01_BUCK4_RAMP_EN_SHIFT     0
+#define S2MPA01_PMIC_EN_SHIFT   6
+
+#endif /*__LINUX_MFD_S2MPA01_H */
diff --git a/include/linux/mfd/samsung/s2mps14.h b/include/linux/mfd/samsung/s2mps14.h
new file mode 100644
index 000000000000..4b449b8ac548
--- /dev/null
+++ b/include/linux/mfd/samsung/s2mps14.h
@@ -0,0 +1,154 @@
+/*
+ * s2mps14.h
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd
+ *              http://www.samsung.com
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef __LINUX_MFD_S2MPS14_H
+#define __LINUX_MFD_S2MPS14_H
+
+/* S2MPS14 registers */
+enum s2mps14_reg {
+        S2MPS14_REG_ID,
+        S2MPS14_REG_INT1,
+        S2MPS14_REG_INT2,
+        S2MPS14_REG_INT3,
+        S2MPS14_REG_INT1M,
+        S2MPS14_REG_INT2M,
+        S2MPS14_REG_INT3M,
+        S2MPS14_REG_ST1,
+        S2MPS14_REG_ST2,
+        S2MPS14_REG_PWRONSRC,
+        S2MPS14_REG_OFFSRC,
+        S2MPS14_REG_BU_CHG,
+        S2MPS14_REG_RTCCTRL,
+        S2MPS14_REG_CTRL1,
+        S2MPS14_REG_CTRL2,
+        S2MPS14_REG_RSVD1,
+        S2MPS14_REG_RSVD2,
+        S2MPS14_REG_RSVD3,
+        S2MPS14_REG_RSVD4,
+        S2MPS14_REG_RSVD5,
+        S2MPS14_REG_RSVD6,
+        S2MPS14_REG_CTRL3,
+        S2MPS14_REG_RSVD7,
+        S2MPS14_REG_RSVD8,
+        S2MPS14_REG_WRSTBI,
+        S2MPS14_REG_B1CTRL1,
+        S2MPS14_REG_B1CTRL2,
+        S2MPS14_REG_B2CTRL1,
+        S2MPS14_REG_B2CTRL2,
+        S2MPS14_REG_B3CTRL1,
+        S2MPS14_REG_B3CTRL2,
+        S2MPS14_REG_B4CTRL1,
+        S2MPS14_REG_B4CTRL2,
+        S2MPS14_REG_B5CTRL1,
+        S2MPS14_REG_B5CTRL2,
+        S2MPS14_REG_L1CTRL,
+        S2MPS14_REG_L2CTRL,
+        S2MPS14_REG_L3CTRL,
+        S2MPS14_REG_L4CTRL,
+        S2MPS14_REG_L5CTRL,
+        S2MPS14_REG_L6CTRL,
+        S2MPS14_REG_L7CTRL,
+        S2MPS14_REG_L8CTRL,
+        S2MPS14_REG_L9CTRL,
+        S2MPS14_REG_L10CTRL,
+        S2MPS14_REG_L11CTRL,
+        S2MPS14_REG_L12CTRL,
+        S2MPS14_REG_L13CTRL,
+        S2MPS14_REG_L14CTRL,
+        S2MPS14_REG_L15CTRL,
+        S2MPS14_REG_L16CTRL,
+        S2MPS14_REG_L17CTRL,
+        S2MPS14_REG_L18CTRL,
+        S2MPS14_REG_L19CTRL,
+        S2MPS14_REG_L20CTRL,
+        S2MPS14_REG_L21CTRL,
+        S2MPS14_REG_L22CTRL,
+        S2MPS14_REG_L23CTRL,
+        S2MPS14_REG_L24CTRL,
+        S2MPS14_REG_L25CTRL,
+        S2MPS14_REG_LDODSCH1,
+        S2MPS14_REG_LDODSCH2,
+        S2MPS14_REG_LDODSCH3,
+};
+
+/* S2MPS14 regulator ids */
+enum s2mps14_regulators {
+        S2MPS14_LDO1,
+        S2MPS14_LDO2,
+        S2MPS14_LDO3,
+        S2MPS14_LDO4,
+        S2MPS14_LDO5,
+        S2MPS14_LDO6,
+        S2MPS14_LDO7,
+        S2MPS14_LDO8,
+        S2MPS14_LDO9,
+        S2MPS14_LDO10,
+        S2MPS14_LDO11,
+        S2MPS14_LDO12,
+        S2MPS14_LDO13,
+        S2MPS14_LDO14,
+        S2MPS14_LDO15,
+        S2MPS14_LDO16,
+        S2MPS14_LDO17,
+        S2MPS14_LDO18,
+        S2MPS14_LDO19,
+        S2MPS14_LDO20,
+        S2MPS14_LDO21,
+        S2MPS14_LDO22,
+        S2MPS14_LDO23,
+        S2MPS14_LDO24,
+        S2MPS14_LDO25,
+        S2MPS14_BUCK1,
+        S2MPS14_BUCK2,
+        S2MPS14_BUCK3,
+        S2MPS14_BUCK4,
+        S2MPS14_BUCK5,
+
+        S2MPS14_REGULATOR_MAX,
+};
+
+/* Regulator constraints for BUCKx */
+#define S2MPS14_BUCK1235_MIN_600MV      600000
+#define S2MPS14_BUCK4_MIN_1400MV        1400000
+#define S2MPS14_BUCK1235_STEP_6_25MV    6250
+#define S2MPS14_BUCK4_STEP_12_5MV       12500
+#define S2MPS14_BUCK1235_START_SEL      0x20
+#define S2MPS14_BUCK4_START_SEL         0x40
+/*
+ * Default ramp delay in uv/us. Datasheet says that ramp delay can be
+ * controlled however it does not specify which register is used for that.
+ * Let's assume that default value will be set.
+ */
+#define S2MPS14_BUCK_RAMP_DELAY         12500
+
+/* Regulator constraints for different types of LDOx */
+#define S2MPS14_LDO_MIN_800MV           800000
+#define S2MPS14_LDO_MIN_1800MV          1800000
+#define S2MPS14_LDO_STEP_12_5MV         12500
+#define S2MPS14_LDO_STEP_25MV           25000
+
+#define S2MPS14_LDO_VSEL_MASK           0x3F
+#define S2MPS14_BUCK_VSEL_MASK          0xFF
+#define S2MPS14_ENABLE_MASK             (0x03 << S2MPS14_ENABLE_SHIFT)
+#define S2MPS14_ENABLE_SHIFT            6
+/* On/Off controlled by PWREN */
+#define S2MPS14_ENABLE_SUSPEND          (0x01 << S2MPS14_ENABLE_SHIFT)
+#define S2MPS14_LDO_N_VOLTAGES          (S2MPS14_LDO_VSEL_MASK + 1)
+#define S2MPS14_BUCK_N_VOLTAGES         (S2MPS14_BUCK_VSEL_MASK + 1)
+
+#endif /*  __LINUX_MFD_S2MPS14_H */
diff --git a/include/linux/mfd/samsung/s5m8767.h b/include/linux/mfd/samsung/s5m8767.h
index 2ab0b0f03641..243b58fec33d 100644
--- a/include/linux/mfd/samsung/s5m8767.h
+++ b/include/linux/mfd/samsung/s5m8767.h
@@ -183,10 +183,17 @@ enum s5m8767_regulators {
         S5M8767_REG_MAX,
 };
 
+/* LDO_EN/BUCK_EN field in registers */
 #define S5M8767_ENCTRL_SHIFT            6
 #define S5M8767_ENCTRL_MASK             (0x3 << S5M8767_ENCTRL_SHIFT)
 
 /*
+ * LDO_EN/BUCK_EN register value for controlling this Buck or LDO
+ * by GPIO (PWREN, BUCKEN).
+ */
+#define S5M8767_ENCTRL_USE_GPIO         0x1
+
+/*
  * Values for BUCK_RAMP field in DVS_RAMP register, matching raw values
  * in mV/us.
  */
diff --git a/include/linux/mfd/tps65217.h b/include/linux/mfd/tps65217.h
index a5a7f0130e96..54b5458ec084 100644
--- a/include/linux/mfd/tps65217.h
+++ b/include/linux/mfd/tps65217.h
@@ -252,7 +252,7 @@ struct tps65217_board {
 struct tps65217 {
         struct device *dev;
         struct tps65217_board *pdata;
-        unsigned int id;
+        unsigned long id;
         struct regulator_desc desc[TPS65217_NUM_REGULATOR];
         struct regulator_dev *rdev[TPS65217_NUM_REGULATOR];
         struct regmap *regmap;
@@ -263,7 +263,7 @@ static inline struct tps65217 *dev_to_tps65217(struct device *dev)
         return dev_get_drvdata(dev);
 }
 
-static inline int tps65217_chip_id(struct tps65217 *tps65217)
+static inline unsigned long tps65217_chip_id(struct tps65217 *tps65217)
 {
         return tps65217->id;
 }
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index 3737f7218f51..2cf1547096d9 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -11,23 +11,23 @@
  */
 
 #define PSMOUSE_MINOR           1
-#define MS_BUSMOUSE_MINOR       2
-#define ATIXL_BUSMOUSE_MINOR    3
+#define MS_BUSMOUSE_MINOR       2       /* unused */
+#define ATIXL_BUSMOUSE_MINOR    3       /* unused */
 /*#define AMIGAMOUSE_MINOR      4       FIXME OBSOLETE */
-#define ATARIMOUSE_MINOR        5
-#define SUN_MOUSE_MINOR         6
-#define APOLLO_MOUSE_MINOR      7
-#define PC110PAD_MINOR          9
+#define ATARIMOUSE_MINOR        5       /* unused */
+#define SUN_MOUSE_MINOR         6       /* unused */
+#define APOLLO_MOUSE_MINOR      7       /* unused */
+#define PC110PAD_MINOR          9       /* unused */
 /*#define ADB_MOUSE_MINOR       10      FIXME OBSOLETE */
 #define WATCHDOG_MINOR          130     /* Watchdog timer     */
 #define TEMP_MINOR              131     /* Temperature Sensor */
 #define RTC_MINOR               135
 #define EFI_RTC_MINOR           136     /* EFI Time services */
 #define SUN_OPENPROM_MINOR      139
-#define DMAPI_MINOR             140     /* DMAPI */
+#define DMAPI_MINOR             140     /* unused */
 #define NVRAM_MINOR             144
 #define SGI_MMTIMER             153
-#define STORE_QUEUE_MINOR       155
+#define STORE_QUEUE_MINOR       155     /* unused */
 #define I2O_MINOR               166
 #define MICROCODE_MINOR         184
 #define VFIO_MINOR              196
diff --git a/include/linux/mm.h b/include/linux/mm.h
index f28f46eade6a..2eec61fe75c9 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -175,7 +175,7 @@ extern unsigned int kobjsize(const void *objp);
  * Special vmas that are non-mergable, non-mlock()able.
  * Note: mm/huge_memory.c VM_NO_THP depends on this definition.
  */
-#define VM_SPECIAL (VM_IO | VM_DONTEXPAND | VM_PFNMAP)
+#define VM_SPECIAL (VM_IO | VM_DONTEXPAND | VM_PFNMAP | VM_MIXEDMAP)
 
 /*
  * mapping from the currently active vm_flags protection bits (the
@@ -399,8 +399,18 @@ static inline void compound_unlock_irqrestore(struct page *page,
 
 static inline struct page *compound_head(struct page *page)
 {
-        if (unlikely(PageTail(page)))
-                return page->first_page;
+        if (unlikely(PageTail(page))) {
+                struct page *head = page->first_page;
+
+                /*
+                 * page->first_page may be a dangling pointer to an old
+                 * compound page, so recheck that it is still a tail
+                 * page before returning.
+                 */
+                smp_rmb();
+                if (likely(PageTail(page)))
+                        return head;
+        }
         return page;
 }
 
@@ -757,7 +767,7 @@ static inline bool __cpupid_match_pid(pid_t task_pid, int cpupid)
 #ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
 static inline int page_cpupid_xchg_last(struct page *page, int cpupid)
 {
-        return xchg(&page->_last_cpupid, cpupid);
+        return xchg(&page->_last_cpupid, cpupid & LAST_CPUPID_MASK);
 }
 
 static inline int page_cpupid_last(struct page *page)
@@ -766,7 +776,7 @@ static inline int page_cpupid_last(struct page *page)
 }
 static inline void page_cpupid_reset_last(struct page *page)
 {
-        page->_last_cpupid = -1;
+        page->_last_cpupid = -1 & LAST_CPUPID_MASK;
 }
 #else
 static inline int page_cpupid_last(struct page *page)
@@ -1477,9 +1487,15 @@ static inline void pgtable_page_dtor(struct page *page)
 
 #if USE_SPLIT_PMD_PTLOCKS
 
+static struct page *pmd_to_page(pmd_t *pmd)
+{
+        unsigned long mask = ~(PTRS_PER_PMD * sizeof(pmd_t) - 1);
+        return virt_to_page((void *)((unsigned long) pmd & mask));
+}
+
 static inline spinlock_t *pmd_lockptr(struct mm_struct *mm, pmd_t *pmd)
 {
-        return ptlock_ptr(virt_to_page(pmd));
+        return ptlock_ptr(pmd_to_page(pmd));
 }
 
 static inline bool pgtable_pmd_page_ctor(struct page *page)
@@ -1498,7 +1514,7 @@ static inline void pgtable_pmd_page_dtor(struct page *page)
         ptlock_free(page);
 }
 
-#define pmd_huge_pte(mm, pmd) (virt_to_page(pmd)->pmd_huge_pte)
+#define pmd_huge_pte(mm, pmd) (pmd_to_page(pmd)->pmd_huge_pte)
 
 #else
 
@@ -1740,6 +1756,9 @@ extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file);
 extern struct file *get_mm_exe_file(struct mm_struct *mm);
 
 extern int may_expand_vm(struct mm_struct *mm, unsigned long npages);
+extern struct vm_area_struct *_install_special_mapping(struct mm_struct *mm,
+                                   unsigned long addr, unsigned long len,
+                                   unsigned long flags, struct page **pages);
 extern int install_special_mapping(struct mm_struct *mm,
                                    unsigned long addr, unsigned long len,
                                    unsigned long flags, struct page **pages);
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 5f2052c83154..9b61b9bf81ac 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -590,10 +590,10 @@ static inline bool zone_is_empty(struct zone *zone)
 
 /*
  * The NUMA zonelists are doubled because we need zonelists that restrict the
- * allocations to a single node for GFP_THISNODE.
+ * allocations to a single node for __GFP_THISNODE.
  *
  * [0]  : Zonelist with fallback
- * [1]  : No fallback (GFP_THISNODE)
+ * [1]  : No fallback (__GFP_THISNODE)
  */
 #define MAX_ZONELISTS 2
 
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 45e921401b06..9a165a213d93 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -432,6 +432,14 @@ struct spi_device_id {
         kernel_ulong_t driver_data;     /* Data private to the driver */
 };
 
+#define SPMI_NAME_SIZE  32
+#define SPMI_MODULE_PREFIX "spmi:"
+
+struct spmi_device_id {
+        char name[SPMI_NAME_SIZE];
+        kernel_ulong_t driver_data;     /* Data private to the driver */
+};
+
 /* dmi */
 enum dmi_field {
         DMI_NONE,
@@ -564,6 +572,15 @@ struct x86_cpu_id {
 #define X86_MODEL_ANY  0
 #define X86_FEATURE_ANY 0       /* Same as FPU, you can't test for that */
 
+/*
+ * Generic table type for matching CPU features.
+ * @feature:    the bit number of the feature (0 - 65535)
+ */
+
+struct cpu_feature {
+        __u16   feature;
+};
+
 #define IPACK_ANY_FORMAT 0xff
 #define IPACK_ANY_ID (~0)
 struct ipack_device_id {
@@ -599,4 +616,9 @@ struct rio_device_id {
         __u16 asm_did, asm_vid;
 };
 
+struct mcb_device_id {
+        __u16 device;
+        kernel_ulong_t driver_data;
+};
+
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index d3181936c138..11692dea18aa 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -46,6 +46,7 @@
  * - detects multi-task circular deadlocks and prints out all affected
  *   locks and tasks (and only those tasks)
  */
+struct optimistic_spin_queue;
 struct mutex {
         /* 1: unlocked, 0: locked, negative: locked, possible waiters */
         atomic_t                count;
@@ -55,7 +56,7 @@ struct mutex {
         struct task_struct      *owner;
 #endif
 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
-        void                    *spin_mlock;    /* Spinner MCS lock */
+        struct optimistic_spin_queue    *osq;   /* Spinner MCS lock */
 #endif
 #ifdef CONFIG_DEBUG_MUTEXES
         const char              *name;
@@ -179,4 +180,4 @@ extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
 # define arch_mutex_cpu_relax() cpu_relax()
 #endif
 
-#endif
+#endif /* __LINUX_MUTEX_H */
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index 1005ebf17575..5a09a48f2658 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -163,4 +163,11 @@ enum {
 /* changeable features with no special hardware requirements */
 #define NETIF_F_SOFT_FEATURES   (NETIF_F_GSO | NETIF_F_GRO)
 
+#define NETIF_F_VLAN_FEATURES   (NETIF_F_HW_VLAN_CTAG_FILTER | \
+                                 NETIF_F_HW_VLAN_CTAG_RX | \
+                                 NETIF_F_HW_VLAN_CTAG_TX | \
+                                 NETIF_F_HW_VLAN_STAG_FILTER | \
+                                 NETIF_F_HW_VLAN_STAG_RX | \
+                                 NETIF_F_HW_VLAN_STAG_TX)
+
 #endif  /* _LINUX_NETDEV_FEATURES_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 440a02ee6f92..daafd9561cbc 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -752,6 +752,9 @@ struct netdev_phys_port_id {
         unsigned char id_len;
 };
 
+typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
+                                       struct sk_buff *skb);
+
 /*
  * This structure defines the management hooks for network devices.
  * The following hooks can be defined; unless noted otherwise, they are
@@ -783,7 +786,7 @@ struct netdev_phys_port_id {
  *      Required can not be NULL.
  *
  * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
- *                         void *accel_priv);
+ *                         void *accel_priv, select_queue_fallback_t fallback);
  *      Called to decide which queue to when device supports multiple
  *      transmit queues.
  *
@@ -1005,7 +1008,8 @@ struct net_device_ops {
                                                    struct net_device *dev);
         u16                     (*ndo_select_queue)(struct net_device *dev,
                                                     struct sk_buff *skb,
-                                                    void *accel_priv);
+                                                    void *accel_priv,
+                                                    select_queue_fallback_t fallback);
         void                    (*ndo_change_rx_flags)(struct net_device *dev,
                                                        int flags);
         void                    (*ndo_set_rx_mode)(struct net_device *dev);
@@ -1551,7 +1555,6 @@ static inline void netdev_for_each_tx_queue(struct net_device *dev,
 struct netdev_queue *netdev_pick_tx(struct net_device *dev,
                                     struct sk_buff *skb,
                                     void *accel_priv);
-u16 __netdev_pick_tx(struct net_device *dev, struct sk_buff *skb);
 
 /*
  * Net namespace inlines
@@ -2276,6 +2279,26 @@ static inline void netdev_reset_queue(struct net_device *dev_queue)
 }
 
 /**
+ *      netdev_cap_txqueue - check if selected tx queue exceeds device queues
+ *      @dev: network device
+ *      @queue_index: given tx queue index
+ *
+ *      Returns 0 if given tx queue index >= number of device tx queues,
+ *      otherwise returns the originally passed tx queue index.
+ */
+static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
+{
+        if (unlikely(queue_index >= dev->real_num_tx_queues)) {
+                net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
+                                     dev->name, queue_index,
+                                     dev->real_num_tx_queues);
+                return 0;
+        }
+
+        return queue_index;
+}
+
+/**
  *      netif_running - test if up
  *      @dev: network device
  *
@@ -2991,7 +3014,7 @@ struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
 {
         return __skb_gso_segment(skb, features, true);
 }
-__be16 skb_network_protocol(struct sk_buff *skb);
+__be16 skb_network_protocol(struct sk_buff *skb, int *depth);
 
 static inline bool can_checksum_protocol(netdev_features_t features,
                                          __be16 protocol)
@@ -3068,7 +3091,12 @@ void netdev_change_features(struct net_device *dev);
 void netif_stacked_transfer_operstate(const struct net_device *rootdev,
                                         struct net_device *dev);
 
-netdev_features_t netif_skb_features(struct sk_buff *skb);
+netdev_features_t netif_skb_dev_features(struct sk_buff *skb,
+                                         const struct net_device *dev);
+static inline netdev_features_t netif_skb_features(struct sk_buff *skb)
+{
+        return netif_skb_dev_features(skb, skb->dev);
+}
 
 static inline bool net_gso_ok(netdev_features_t features, int gso_type)
 {
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index b2fb167b2e6d..5624e4e2763c 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -467,9 +467,14 @@ struct nfs_lockt_res {
 };
 
 struct nfs_release_lockowner_args {
+        struct nfs4_sequence_args       seq_args;
         struct nfs_lowner       lock_owner;
 };
 
+struct nfs_release_lockowner_res {
+        struct nfs4_sequence_res        seq_res;
+};
+
 struct nfs4_delegreturnargs {
         struct nfs4_sequence_args       seq_args;
         const struct nfs_fh *fhandle;
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 69ae03f6eb15..6b9aafed225f 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -87,6 +87,7 @@ struct nvme_dev {
         struct list_head namespaces;
         struct kref kref;
         struct miscdevice miscdev;
+        work_func_t reset_workfn;
         struct work_struct reset_work;
         char name[12];
         char serial[20];
diff --git a/include/linux/of.h b/include/linux/of.h
index 435cb995904d..919bf211877d 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -18,7 +18,7 @@
 #include <linux/types.h>
 #include <linux/bitops.h>
 #include <linux/errno.h>
-#include <linux/kref.h>
+#include <linux/kobject.h>
 #include <linux/mod_devicetable.h>
 #include <linux/spinlock.h>
 #include <linux/topology.h>
@@ -37,6 +37,7 @@ struct property {
         struct property *next;
         unsigned long _flags;
         unsigned int unique_id;
+        struct bin_attribute attr;
 };
 
 #if defined(CONFIG_SPARC)
@@ -56,8 +57,7 @@ struct device_node {
         struct  device_node *sibling;
         struct  device_node *next;      /* next device of same type */
         struct  device_node *allnext;   /* next in list of all nodes */
-        struct  proc_dir_entry *pde;    /* this node's proc directory */
-        struct  kref kref;
+        struct  kobject kobj;
         unsigned long _flags;
         void    *data;
 #if defined(CONFIG_SPARC)
@@ -67,13 +67,34 @@ struct device_node {
 #endif
 };
 
-#define MAX_PHANDLE_ARGS 8
+#define MAX_PHANDLE_ARGS 16
 struct of_phandle_args {
         struct device_node *np;
         int args_count;
         uint32_t args[MAX_PHANDLE_ARGS];
 };
 
+extern int of_node_add(struct device_node *node);
+
+/* initialize a node */
+extern struct kobj_type of_node_ktype;
+static inline void of_node_init(struct device_node *node)
+{
+        kobject_init(&node->kobj, &of_node_ktype);
+}
+
+/* true when node is initialized */
+static inline int of_node_is_initialized(struct device_node *node)
+{
+        return node && node->kobj.state_initialized;
+}
+
+/* true when node is attached (i.e. present on sysfs) */
+static inline int of_node_is_attached(struct device_node *node)
+{
+        return node && node->kobj.state_in_sysfs;
+}
+
 #ifdef CONFIG_OF_DYNAMIC
 extern struct device_node *of_node_get(struct device_node *node);
 extern void of_node_put(struct device_node *node);
@@ -114,6 +135,26 @@ static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
         set_bit(flag, &n->_flags);
 }
 
+static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
+{
+        clear_bit(flag, &n->_flags);
+}
+
+static inline int of_property_check_flag(struct property *p, unsigned long flag)
+{
+        return test_bit(flag, &p->_flags);
+}
+
+static inline void of_property_set_flag(struct property *p, unsigned long flag)
+{
+        set_bit(flag, &p->_flags);
+}
+
+static inline void of_property_clear_flag(struct property *p, unsigned long flag)
+{
+        clear_bit(flag, &p->_flags);
+}
+
 extern struct device_node *of_find_all_nodes(struct device_node *prev);
 
 /*
@@ -167,6 +208,8 @@ static inline const char *of_node_full_name(const struct device_node *np)
         return np ? np->full_name : "<no-node>";
 }
 
+#define for_each_of_allnodes(dn) \
+        for (dn = of_allnodes; dn; dn = dn->allnext)
 extern struct device_node *of_find_node_by_name(struct device_node *from,
         const char *name);
 extern struct device_node *of_find_node_by_type(struct device_node *from,
@@ -198,6 +241,8 @@ extern struct device_node *of_find_node_with_property(
 extern struct property *of_find_property(const struct device_node *np,
                                          const char *name,
                                          int *lenp);
+extern int of_property_count_elems_of_size(const struct device_node *np,
+                                const char *propname, int elem_size);
 extern int of_property_read_u32_index(const struct device_node *np,
                                        const char *propname,
                                        u32 index, u32 *out_value);
@@ -390,6 +435,12 @@ static inline struct device_node *of_find_compatible_node(
         return NULL;
 }
 
+static inline int of_property_count_elems_of_size(const struct device_node *np,
+                        const char *propname, int elem_size)
+{
+        return -ENOSYS;
+}
+
 static inline int of_property_read_u32_index(const struct device_node *np,
                         const char *propname, u32 index, u32 *out_value)
 {
@@ -536,6 +587,74 @@ static inline struct device_node *of_find_matching_node(
 }
 
 /**
+ * of_property_count_u8_elems - Count the number of u8 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u8 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u8 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u8_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u8));
+}
+
+/**
+ * of_property_count_u16_elems - Count the number of u16 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u16 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u16 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u16_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u16));
+}
+
+/**
+ * of_property_count_u32_elems - Count the number of u32 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u32 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u32 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u32_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u32));
+}
+
+/**
+ * of_property_count_u64_elems - Count the number of u64 elements in a property
+ *
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ *
+ * Search for a property in a device node and count the number of u64 elements
+ * in it. Returns number of elements on sucess, -EINVAL if the property does
+ * not exist or its length does not match a multiple of u64 and -ENODATA if the
+ * property does not have a value.
+ */
+static inline int of_property_count_u64_elems(const struct device_node *np,
+                                const char *propname)
+{
+        return of_property_count_elems_of_size(np, propname, sizeof(u64));
+}
+
+/**
  * of_property_read_bool - Findfrom a property
  * @np:         device node from which the property value is to be read.
  * @propname:   name of the property to be searched.
@@ -633,14 +752,4 @@ static inline int of_get_available_child_count(const struct device_node *np)
         return num;
 }
 
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_PROC_DEVICETREE)
-extern void proc_device_tree_add_node(struct device_node *, struct proc_dir_entry *);
-extern void proc_device_tree_add_prop(struct proc_dir_entry *pde, struct property *prop);
-extern void proc_device_tree_remove_prop(struct proc_dir_entry *pde,
-                                         struct property *prop);
-extern void proc_device_tree_update_prop(struct proc_dir_entry *pde,
-                                         struct property *newprop,
-                                         struct property *oldprop);
-#endif
-
 #endif /* _LINUX_OF_H */
diff --git a/include/linux/of_fdt.h b/include/linux/of_fdt.h
index 2b77058a7335..ddd7219af8ac 100644
--- a/include/linux/of_fdt.h
+++ b/include/linux/of_fdt.h
@@ -98,7 +98,10 @@ extern int early_init_dt_scan_chosen(unsigned long node, const char *uname,
                                      int depth, void *data);
 extern int early_init_dt_scan_memory(unsigned long node, const char *uname,
                                      int depth, void *data);
+extern void early_init_fdt_scan_reserved_mem(void);
 extern void early_init_dt_add_memory_arch(u64 base, u64 size);
+extern int early_init_dt_reserve_memory_arch(phys_addr_t base, phys_addr_t size,
+                                             bool no_map);
 extern void * early_init_dt_alloc_memory_arch(u64 size, u64 align);
 extern u64 dt_mem_next_cell(int s, __be32 **cellp);
 
@@ -118,6 +121,7 @@ extern void unflatten_and_copy_device_tree(void);
 extern void early_init_devtree(void *);
 extern void early_get_first_memblock_info(void *, phys_addr_t *);
 #else /* CONFIG_OF_FLATTREE */
+static inline void early_init_fdt_scan_reserved_mem(void) {}
 static inline const char *of_flat_dt_get_machine_name(void) { return NULL; }
 static inline void unflatten_device_tree(void) {}
 static inline void unflatten_and_copy_device_tree(void) {}
diff --git a/include/linux/of_graph.h b/include/linux/of_graph.h
new file mode 100644
index 000000000000..befef42e015b
--- /dev/null
+++ b/include/linux/of_graph.h
@@ -0,0 +1,66 @@
+/*
+ * OF graph binding parsing helpers
+ *
+ * Copyright (C) 2012 - 2013 Samsung Electronics Co., Ltd.
+ * Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
+ *
+ * Copyright (C) 2012 Renesas Electronics Corp.
+ * Author: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ */
+#ifndef __LINUX_OF_GRAPH_H
+#define __LINUX_OF_GRAPH_H
+
+/**
+ * struct of_endpoint - the OF graph endpoint data structure
+ * @port: identifier (value of reg property) of a port this endpoint belongs to
+ * @id: identifier (value of reg property) of this endpoint
+ * @local_node: pointer to device_node of this endpoint
+ */
+struct of_endpoint {
+        unsigned int port;
+        unsigned int id;
+        const struct device_node *local_node;
+};
+
+#ifdef CONFIG_OF
+int of_graph_parse_endpoint(const struct device_node *node,
+                                struct of_endpoint *endpoint);
+struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
+                                        struct device_node *previous);
+struct device_node *of_graph_get_remote_port_parent(
+                                        const struct device_node *node);
+struct device_node *of_graph_get_remote_port(const struct device_node *node);
+#else
+
+static inline int of_graph_parse_endpoint(const struct device_node *node,
+                                        struct of_endpoint *endpoint)
+{
+        return -ENOSYS;
+}
+
+static inline struct device_node *of_graph_get_next_endpoint(
+                                        const struct device_node *parent,
+                                        struct device_node *previous)
+{
+        return NULL;
+}
+
+static inline struct device_node *of_graph_get_remote_port_parent(
+                                        const struct device_node *node)
+{
+        return NULL;
+}
+
+static inline struct device_node *of_graph_get_remote_port(
+                                        const struct device_node *node)
+{
+        return NULL;
+}
+
+#endif /* CONFIG_OF */
+
+#endif /* __LINUX_OF_GRAPH_H */
diff --git a/include/linux/of_reserved_mem.h b/include/linux/of_reserved_mem.h
new file mode 100644
index 000000000000..9b1fbb7f29fc
--- /dev/null
+++ b/include/linux/of_reserved_mem.h
@@ -0,0 +1,53 @@
+#ifndef __OF_RESERVED_MEM_H
+#define __OF_RESERVED_MEM_H
+
+struct device;
+struct of_phandle_args;
+struct reserved_mem_ops;
+
+struct reserved_mem {
+        const char                      *name;
+        unsigned long                   fdt_node;
+        const struct reserved_mem_ops   *ops;
+        phys_addr_t                     base;
+        phys_addr_t                     size;
+        void                            *priv;
+};
+
+struct reserved_mem_ops {
+        void    (*device_init)(struct reserved_mem *rmem,
+                               struct device *dev);
+        void    (*device_release)(struct reserved_mem *rmem,
+                                  struct device *dev);
+};
+
+typedef int (*reservedmem_of_init_fn)(struct reserved_mem *rmem,
+                                      unsigned long node, const char *uname);
+
+#ifdef CONFIG_OF_RESERVED_MEM
+void fdt_init_reserved_mem(void);
+void fdt_reserved_mem_save_node(unsigned long node, const char *uname,
+                               phys_addr_t base, phys_addr_t size);
+
+#define RESERVEDMEM_OF_DECLARE(name, compat, init)                      \
+        static const struct of_device_id __reservedmem_of_table_##name  \
+                __used __section(__reservedmem_of_table)                \
+                 = { .compatible = compat,                              \
+                     .data = (init == (reservedmem_of_init_fn)NULL) ?   \
+                                init : init }
+
+#else
+static inline void fdt_init_reserved_mem(void) { }
+static inline void fdt_reserved_mem_save_node(unsigned long node,
+                const char *uname, phys_addr_t base, phys_addr_t size) { }
+
+#define RESERVEDMEM_OF_DECLARE(name, compat, init)                      \
+        static const struct of_device_id __reservedmem_of_table_##name  \
+                __attribute__((unused))                                 \
+                 = { .compatible = compat,                              \
+                     .data = (init == (reservedmem_of_init_fn)NULL) ?   \
+                                init : init }
+
+#endif
+
+#endif /* __OF_RESERVED_MEM_H */
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h
index 5a462c4e5009..637a608ded0b 100644
--- a/include/linux/pci-acpi.h
+++ b/include/linux/pci-acpi.h
@@ -59,12 +59,12 @@ static inline void acpi_pci_slot_remove(struct pci_bus *bus) { }
 void acpiphp_init(void);
 void acpiphp_enumerate_slots(struct pci_bus *bus);
 void acpiphp_remove_slots(struct pci_bus *bus);
-void acpiphp_check_host_bridge(acpi_handle handle);
+void acpiphp_check_host_bridge(struct acpi_device *adev);
 #else
 static inline void acpiphp_init(void) { }
 static inline void acpiphp_enumerate_slots(struct pci_bus *bus) { }
 static inline void acpiphp_remove_slots(struct pci_bus *bus) { }
-static inline void acpiphp_check_host_bridge(acpi_handle handle) { }
+static inline void acpiphp_check_host_bridge(struct acpi_device *adev) { }
 #endif
 
 #else   /* CONFIG_ACPI */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index fb57c892b214..aab57b4abe7f 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -29,7 +29,6 @@
 #include <linux/atomic.h>
 #include <linux/device.h>
 #include <linux/io.h>
-#include <linux/irqreturn.h>
 #include <uapi/linux/pci.h>
 
 #include <linux/pci_ids.h>
@@ -170,6 +169,8 @@ enum pci_dev_flags {
         PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) 2,
         /* Provide indication device is assigned by a Virtual Machine Manager */
         PCI_DEV_FLAGS_ASSIGNED = (__force pci_dev_flags_t) 4,
+        /* Flag for quirk use to store if quirk-specific ACS is enabled */
+        PCI_DEV_FLAGS_ACS_ENABLED_QUIRK = (__force pci_dev_flags_t) 8,
 };
 
 enum pci_irq_reroute_variant {
@@ -461,7 +462,6 @@ struct pci_bus {
         unsigned int            is_added:1;
 };
 
-#define pci_bus_b(n)    list_entry(n, struct pci_bus, node)
 #define to_pci_bus(n)   container_of(n, struct pci_bus, dev)
 
 /*
@@ -1066,7 +1066,7 @@ void pci_bus_remove_resources(struct pci_bus *bus);
 int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
                         struct resource *res, resource_size_t size,
                         resource_size_t align, resource_size_t min,
-                        unsigned int type_mask,
+                        unsigned long type_mask,
                         resource_size_t (*alignf)(void *,
                                                   const struct resource *,
                                                   resource_size_t,
@@ -1169,8 +1169,23 @@ void msi_remove_pci_irq_vectors(struct pci_dev *dev);
 void pci_restore_msi_state(struct pci_dev *dev);
 int pci_msi_enabled(void);
 int pci_enable_msi_range(struct pci_dev *dev, int minvec, int maxvec);
+static inline int pci_enable_msi_exact(struct pci_dev *dev, int nvec)
+{
+        int rc = pci_enable_msi_range(dev, nvec, nvec);
+        if (rc < 0)
+                return rc;
+        return 0;
+}
 int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
                           int minvec, int maxvec);
+static inline int pci_enable_msix_exact(struct pci_dev *dev,
+                                        struct msix_entry *entries, int nvec)
+{
+        int rc = pci_enable_msix_range(dev, entries, nvec, nvec);
+        if (rc < 0)
+                return rc;
+        return 0;
+}
 #else
 static inline int pci_msi_vec_count(struct pci_dev *dev) { return -ENOSYS; }
 static inline int pci_enable_msi_block(struct pci_dev *dev, int nvec)
@@ -1189,9 +1204,14 @@ static inline int pci_msi_enabled(void) { return 0; }
 static inline int pci_enable_msi_range(struct pci_dev *dev, int minvec,
                                        int maxvec)
 { return -ENOSYS; }
+static inline int pci_enable_msi_exact(struct pci_dev *dev, int nvec)
+{ return -ENOSYS; }
 static inline int pci_enable_msix_range(struct pci_dev *dev,
                       struct msix_entry *entries, int minvec, int maxvec)
 { return -ENOSYS; }
+static inline int pci_enable_msix_exact(struct pci_dev *dev,
+                      struct msix_entry *entries, int nvec)
+{ return -ENOSYS; }
 #endif
 
 #ifdef CONFIG_PCIEPORTBUS
@@ -1510,6 +1530,7 @@ enum pci_fixup_pass {
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
 struct pci_dev *pci_get_dma_source(struct pci_dev *dev);
 int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
+void pci_dev_specific_enable_acs(struct pci_dev *dev);
 #else
 static inline void pci_fixup_device(enum pci_fixup_pass pass,
                                     struct pci_dev *dev) { }
@@ -1522,6 +1543,7 @@ static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
 {
         return -ENOTTY;
 }
+static inline void pci_dev_specific_enable_acs(struct pci_dev *dev) { }
 #endif
 
 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
@@ -1577,7 +1599,6 @@ void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
 #ifdef CONFIG_PCI_IOV
 int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn);
 void pci_disable_sriov(struct pci_dev *dev);
-irqreturn_t pci_sriov_migration(struct pci_dev *dev);
 int pci_num_vf(struct pci_dev *dev);
 int pci_vfs_assigned(struct pci_dev *dev);
 int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs);
@@ -1586,8 +1607,6 @@ int pci_sriov_get_totalvfs(struct pci_dev *dev);
 static inline int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn)
 { return -ENODEV; }
 static inline void pci_disable_sriov(struct pci_dev *dev) { }
-static inline irqreturn_t pci_sriov_migration(struct pci_dev *dev)
-{ return IRQ_NONE; }
 static inline int pci_num_vf(struct pci_dev *dev) { return 0; }
 static inline int pci_vfs_assigned(struct pci_dev *dev)
 { return 0; }
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 97fbecdd7a40..d4de24b4d4c6 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -528,6 +528,8 @@
 #define PCI_DEVICE_ID_AMD_15H_NB_F5     0x1605
 #define PCI_DEVICE_ID_AMD_16H_NB_F3     0x1533
 #define PCI_DEVICE_ID_AMD_16H_NB_F4     0x1534
+#define PCI_DEVICE_ID_AMD_16H_M30H_NB_F3 0x1583
+#define PCI_DEVICE_ID_AMD_16H_M30H_NB_F4 0x1584
 #define PCI_DEVICE_ID_AMD_CNB17H_F3     0x1703
 #define PCI_DEVICE_ID_AMD_LANCE         0x2000
 #define PCI_DEVICE_ID_AMD_LANCE_HOME    0x2001
@@ -726,6 +728,7 @@
 #define PCI_DEVICE_ID_SI_7018           0x7018
 
 #define PCI_VENDOR_ID_HP                0x103c
+#define PCI_VENDOR_ID_HP_3PAR           0x1590
 #define PCI_DEVICE_ID_HP_VISUALIZE_EG   0x1005
 #define PCI_DEVICE_ID_HP_VISUALIZE_FX6  0x1006
 #define PCI_DEVICE_ID_HP_VISUALIZE_FX4  0x1008
@@ -2531,6 +2534,9 @@
 
 #define PCI_VENDOR_ID_INTEL             0x8086
 #define PCI_DEVICE_ID_INTEL_EESSC       0x0008
+#define PCI_DEVICE_ID_INTEL_SNB_IMC     0x0100
+#define PCI_DEVICE_ID_INTEL_IVB_IMC     0x0154
+#define PCI_DEVICE_ID_INTEL_HSW_IMC     0x0c00
 #define PCI_DEVICE_ID_INTEL_PXHD_0      0x0320
 #define PCI_DEVICE_ID_INTEL_PXHD_1      0x0321
 #define PCI_DEVICE_ID_INTEL_PXH_0       0x0329
diff --git a/include/linux/usb/omap_control_usb.h b/include/linux/phy/omap_control_phy.h
index 69ae383ee3cc..5450403c7546 100644
--- a/include/linux/usb/omap_control_usb.h
+++ b/include/linux/phy/omap_control_phy.h
@@ -1,5 +1,5 @@
 /*
- * omap_control_usb.h - Header file for the USB part of control module.
+ * omap_control_phy.h - Header file for the PHY part of control module.
  *
  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com
  * This program is free software; you can redistribute it and/or modify
@@ -16,10 +16,10 @@
  *
  */
 
-#ifndef __OMAP_CONTROL_USB_H__
-#define __OMAP_CONTROL_USB_H__
+#ifndef __OMAP_CONTROL_PHY_H__
+#define __OMAP_CONTROL_PHY_H__
 
-enum omap_control_usb_type {
+enum omap_control_phy_type {
         OMAP_CTRL_TYPE_OTGHS = 1,       /* Mailbox OTGHS_CONTROL */
         OMAP_CTRL_TYPE_USB2,    /* USB2_PHY, power down in CONTROL_DEV_CONF */
         OMAP_CTRL_TYPE_PIPE3,   /* PIPE3 PHY, DPLL & seperate Rx/Tx power */
@@ -27,7 +27,7 @@ enum omap_control_usb_type {
         OMAP_CTRL_TYPE_AM437USB2, /* USB2 PHY, power e.g. AM437x */
 };
 
-struct omap_control_usb {
+struct omap_control_phy {
         struct device *dev;
 
         u32 __iomem *otghs_control;
@@ -36,7 +36,7 @@ struct omap_control_usb {
 
         struct clk *sys_clk;
 
-        enum omap_control_usb_type type;
+        enum omap_control_phy_type type;
 };
 
 enum omap_control_usb_mode {
@@ -54,14 +54,14 @@ enum omap_control_usb_mode {
 #define OMAP_CTRL_DEV_SESSEND           BIT(3)
 #define OMAP_CTRL_DEV_IDDIG             BIT(4)
 
-#define OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK       0x003FC000
-#define OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT      0xE
+#define OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_CMD_MASK         0x003FC000
+#define OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_CMD_SHIFT        0xE
 
-#define OMAP_CTRL_USB_PWRCTL_CLK_FREQ_MASK      0xFFC00000
-#define OMAP_CTRL_USB_PWRCTL_CLK_FREQ_SHIFT     0x16
+#define OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_FREQ_MASK        0xFFC00000
+#define OMAP_CTRL_PIPE3_PHY_PWRCTL_CLK_FREQ_SHIFT       0x16
 
-#define OMAP_CTRL_USB3_PHY_TX_RX_POWERON        0x3
-#define OMAP_CTRL_USB3_PHY_TX_RX_POWEROFF       0x0
+#define OMAP_CTRL_PIPE3_PHY_TX_RX_POWERON       0x3
+#define OMAP_CTRL_PIPE3_PHY_TX_RX_POWEROFF      0x0
 
 #define OMAP_CTRL_USB2_PHY_PD           BIT(28)
 
@@ -70,13 +70,13 @@ enum omap_control_usb_mode {
 #define AM437X_CTRL_USB2_OTGVDET_EN     BIT(19)
 #define AM437X_CTRL_USB2_OTGSESSEND_EN  BIT(20)
 
-#if IS_ENABLED(CONFIG_OMAP_CONTROL_USB)
-extern void omap_control_usb_phy_power(struct device *dev, int on);
-extern void omap_control_usb_set_mode(struct device *dev,
-        enum omap_control_usb_mode mode);
+#if IS_ENABLED(CONFIG_OMAP_CONTROL_PHY)
+void omap_control_phy_power(struct device *dev, int on);
+void omap_control_usb_set_mode(struct device *dev,
+                               enum omap_control_usb_mode mode);
 #else
 
-static inline void omap_control_usb_phy_power(struct device *dev, int on)
+static inline void omap_control_phy_power(struct device *dev, int on)
 {
 }
 
@@ -86,4 +86,4 @@ static inline void omap_control_usb_set_mode(struct device *dev,
 }
 #endif
 
-#endif  /* __OMAP_CONTROL_USB_H__ */
+#endif  /* __OMAP_CONTROL_PHY_H__ */
diff --git a/include/linux/usb/omap_usb.h b/include/linux/phy/omap_usb.h
index 6ae29360e1d2..dc2c541a619b 100644
--- a/include/linux/usb/omap_usb.h
+++ b/include/linux/phy/omap_usb.h
@@ -34,14 +34,24 @@ struct omap_usb {
         struct usb_phy          phy;
         struct phy_companion    *comparator;
         void __iomem            *pll_ctrl_base;
+        void __iomem            *phy_base;
         struct device           *dev;
         struct device           *control_dev;
         struct clk              *wkupclk;
-        struct clk              *sys_clk;
         struct clk              *optclk;
-        u8                      is_suspended:1;
+        u8                      flags;
 };
 
+struct usb_phy_data {
+        const char *label;
+        u8 flags;
+};
+
+/* Driver Flags */
+#define OMAP_USB2_HAS_START_SRP (1 << 0)
+#define OMAP_USB2_HAS_SET_VBUS (1 << 1)
+#define OMAP_USB2_CALIBRATE_FALSE_DISCONNECT (1 << 2)
+
 #define phy_to_omapusb(x)       container_of((x), struct omap_usb, phy)
 
 #if defined(CONFIG_OMAP_USB2) || defined(CONFIG_OMAP_USB2_MODULE)
diff --git a/include/linux/phy/phy.h b/include/linux/phy/phy.h
index 3f83459dbb20..e2f5ca96cddc 100644
--- a/include/linux/phy/phy.h
+++ b/include/linux/phy/phy.h
@@ -149,8 +149,11 @@ struct phy *phy_get(struct device *dev, const char *string);
 struct phy *phy_optional_get(struct device *dev, const char *string);
 struct phy *devm_phy_get(struct device *dev, const char *string);
 struct phy *devm_phy_optional_get(struct device *dev, const char *string);
+struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
+                            const char *con_id);
 void phy_put(struct phy *phy);
 void devm_phy_put(struct device *dev, struct phy *phy);
+struct phy *of_phy_get(struct device_node *np, const char *con_id);
 struct phy *of_phy_simple_xlate(struct device *dev,
         struct of_phandle_args *args);
 struct phy *phy_create(struct device *dev, const struct phy_ops *ops,
@@ -251,6 +254,13 @@ static inline struct phy *devm_phy_optional_get(struct device *dev,
         return ERR_PTR(-ENOSYS);
 }
 
+static inline struct phy *devm_of_phy_get(struct device *dev,
+                                          struct device_node *np,
+                                          const char *con_id)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
 static inline void phy_put(struct phy *phy)
 {
 }
@@ -259,6 +269,11 @@ static inline void devm_phy_put(struct device *dev, struct phy *phy)
 {
 }
 
+static inline struct phy *of_phy_get(struct device_node *np, const char *con_id)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
 static inline struct phy *of_phy_simple_xlate(struct device *dev,
         struct of_phandle_args *args)
 {
diff --git a/include/linux/platform_data/adau1977.h b/include/linux/platform_data/adau1977.h
new file mode 100644
index 000000000000..bed11d908f92
--- /dev/null
+++ b/include/linux/platform_data/adau1977.h
@@ -0,0 +1,45 @@
+/*
+ * ADAU1977/ADAU1978/ADAU1979 driver
+ *
+ * Copyright 2014 Analog Devices Inc.
+ *  Author: Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef __LINUX_PLATFORM_DATA_ADAU1977_H__
+#define __LINUX_PLATFORM_DATA_ADAU1977_H__
+
+/**
+ * enum adau1977_micbias - ADAU1977 MICBIAS pin voltage setting
+ * @ADAU1977_MICBIAS_5V0: MICBIAS is set to 5.0 V
+ * @ADAU1977_MICBIAS_5V5: MICBIAS is set to 5.5 V
+ * @ADAU1977_MICBIAS_6V0: MICBIAS is set to 6.0 V
+ * @ADAU1977_MICBIAS_6V5: MICBIAS is set to 6.5 V
+ * @ADAU1977_MICBIAS_7V0: MICBIAS is set to 7.0 V
+ * @ADAU1977_MICBIAS_7V5: MICBIAS is set to 7.5 V
+ * @ADAU1977_MICBIAS_8V0: MICBIAS is set to 8.0 V
+ * @ADAU1977_MICBIAS_8V5: MICBIAS is set to 8.5 V
+ * @ADAU1977_MICBIAS_9V0: MICBIAS is set to 9.0 V
+ */
+enum adau1977_micbias {
+        ADAU1977_MICBIAS_5V0 = 0x0,
+        ADAU1977_MICBIAS_5V5 = 0x1,
+        ADAU1977_MICBIAS_6V0 = 0x2,
+        ADAU1977_MICBIAS_6V5 = 0x3,
+        ADAU1977_MICBIAS_7V0 = 0x4,
+        ADAU1977_MICBIAS_7V5 = 0x5,
+        ADAU1977_MICBIAS_8V0 = 0x6,
+        ADAU1977_MICBIAS_8V5 = 0x7,
+        ADAU1977_MICBIAS_9V0 = 0x8,
+};
+
+/**
+ * struct adau1977_platform_data - Platform configuration data for the ADAU1977
+ * @micbias: Specifies the voltage for the MICBIAS pin
+ */
+struct adau1977_platform_data {
+        enum adau1977_micbias micbias;
+};
+
+#endif
diff --git a/include/linux/platform_data/asoc-s3c.h b/include/linux/platform_data/asoc-s3c.h
index 9efc04dd255a..709c6f7e2f8c 100644
--- a/include/linux/platform_data/asoc-s3c.h
+++ b/include/linux/platform_data/asoc-s3c.h
@@ -1,5 +1,4 @@
-/* arch/arm/plat-samsung/include/plat/audio.h
- *
+/*
  * Copyright (c) 2009 Samsung Electronics Co. Ltd
  * Author: Jaswinder Singh <jassi.brar@samsung.com>
  *
diff --git a/include/linux/platform_data/asoc-s3c24xx_simtec.h b/include/linux/platform_data/asoc-s3c24xx_simtec.h
index 376af5286a3e..d220e54123aa 100644
--- a/include/linux/platform_data/asoc-s3c24xx_simtec.h
+++ b/include/linux/platform_data/asoc-s3c24xx_simtec.h
@@ -1,5 +1,4 @@
-/* arch/arm/plat-samsung/include/plat/audio-simtec.h
- *
+/*
  * Copyright 2008 Simtec Electronics
  *      http://armlinux.simtec.co.uk/
  *      Ben Dooks <ben@simtec.co.uk>
diff --git a/include/linux/platform_data/bt-nokia-h4p.h b/include/linux/platform_data/bt-nokia-h4p.h
new file mode 100644
index 000000000000..30d169dfadf3
--- /dev/null
+++ b/include/linux/platform_data/bt-nokia-h4p.h
@@ -0,0 +1,38 @@
+/*
+ * This file is part of Nokia H4P bluetooth driver
+ *
+ * Copyright (C) 2010 Nokia Corporation.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+
+/**
+ * struct hci_h4p_platform data - hci_h4p Platform data structure
+ */
+struct hci_h4p_platform_data {
+        int chip_type;
+        int bt_sysclk;
+        unsigned int bt_wakeup_gpio;
+        unsigned int host_wakeup_gpio;
+        unsigned int reset_gpio;
+        int reset_gpio_shared;
+        unsigned int uart_irq;
+        phys_addr_t uart_base;
+        const char *uart_iclk;
+        const char *uart_fclk;
+        void (*set_pm_limits)(struct device *dev, bool set);
+};
diff --git a/include/linux/platform_data/davinci_asp.h b/include/linux/platform_data/davinci_asp.h
index 5245992b0367..85ad68f9206a 100644
--- a/include/linux/platform_data/davinci_asp.h
+++ b/include/linux/platform_data/davinci_asp.h
@@ -18,7 +18,7 @@
 
 #include <linux/genalloc.h>
 
-struct snd_platform_data {
+struct davinci_mcasp_pdata {
         u32 tx_dma_offset;
         u32 rx_dma_offset;
         int asp_chan_q; /* event queue number for ASP channel */
@@ -87,6 +87,8 @@ struct snd_platform_data {
         int tx_dma_channel;
         int rx_dma_channel;
 };
+/* TODO: Fix arch/arm/mach-davinci/ users and remove this define */
+#define snd_platform_data davinci_mcasp_pdata
 
 enum {
         MCASP_VERSION_1 = 0,    /* DM646x */
diff --git a/include/linux/platform_data/max310x.h b/include/linux/platform_data/max310x.h
deleted file mode 100644
index dd11dcd1a184..000000000000
--- a/include/linux/platform_data/max310x.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- *  Maxim (Dallas) MAX3107/8/9, MAX14830 serial driver
- *
- *  Copyright (C) 2012 Alexander Shiyan <shc_work@mail.ru>
- *
- *  Based on max3100.c, by Christian Pellegrin <chripell@evolware.org>
- *  Based on max3110.c, by Feng Tang <feng.tang@intel.com>
- *  Based on max3107.c, by Aavamobile
- *
- *  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 _MAX310X_H_
-#define _MAX310X_H_
-
-/*
- * Example board initialization data:
- *
- * static struct max310x_pdata max3107_pdata = {
- *      .driver_flags   = MAX310X_EXT_CLK,
- *      .uart_flags[0]  = MAX310X_ECHO_SUPRESS | MAX310X_AUTO_DIR_CTRL,
- *      .frequency      = 3686400,
- *      .gpio_base      = -1,
- * };
- *
- * static struct spi_board_info spi_device_max3107[] = {
- *      {
- *              .modalias       = "max3107",
- *              .irq            = IRQ_EINT3,
- *              .bus_num        = 1,
- *              .chip_select    = 1,
- *              .platform_data  = &max3107_pdata,
- *      },
- * };
- */
-
-#define MAX310X_MAX_UARTS       4
-
-/* MAX310X platform data structure */
-struct max310x_pdata {
-        /* Flags global to driver */
-        const u8                driver_flags;
-#define MAX310X_EXT_CLK         (0x00000001)    /* External clock enable */
-        /* Flags global to UART port */
-        const u8                uart_flags[MAX310X_MAX_UARTS];
-#define MAX310X_LOOPBACK        (0x00000001)    /* Loopback mode enable */
-#define MAX310X_ECHO_SUPRESS    (0x00000002)    /* Enable echo supress */
-#define MAX310X_AUTO_DIR_CTRL   (0x00000004)    /* Enable Auto direction
-                                                 * control (RS-485)
-                                                 */
-        /* Frequency (extrenal clock or crystal) */
-        const int               frequency;
-        /* GPIO base number (can be negative) */
-        const int               gpio_base;
-        /* Called during startup */
-        void (*init)(void);
-        /* Called before finish */
-        void (*exit)(void);
-};
-
-#endif
diff --git a/include/linux/platform_data/serial-imx.h b/include/linux/platform_data/serial-imx.h
index 4adec9b154dd..3cc2e3c40914 100644
--- a/include/linux/platform_data/serial-imx.h
+++ b/include/linux/platform_data/serial-imx.h
@@ -23,8 +23,6 @@
 #define IMXUART_IRDA        (1<<1)
 
 struct imxuart_platform_data {
-        int (*init)(struct platform_device *pdev);
-        void (*exit)(struct platform_device *pdev);
         unsigned int flags;
         void (*irda_enable)(int enable);
         unsigned int irda_inv_rx:1;
diff --git a/include/linux/platform_data/spi-s3c64xx.h b/include/linux/platform_data/spi-s3c64xx.h
index 8447f634c7f5..d3889b98a1a1 100644
--- a/include/linux/platform_data/spi-s3c64xx.h
+++ b/include/linux/platform_data/spi-s3c64xx.h
@@ -1,5 +1,4 @@
-/* linux/arch/arm/plat-samsung/include/plat/s3c64xx-spi.h
- *
+/*
  * Copyright (C) 2009 Samsung Electronics Ltd.
  *      Jaswinder Singh <jassi.brar@samsung.com>
  *
@@ -8,8 +7,8 @@
  * published by the Free Software Foundation.
  */
 
-#ifndef __S3C64XX_PLAT_SPI_H
-#define __S3C64XX_PLAT_SPI_H
+#ifndef __SPI_S3C64XX_H
+#define __SPI_S3C64XX_H
 
 #include <linux/dmaengine.h>
 
@@ -68,4 +67,4 @@ extern int s3c64xx_spi2_cfg_gpio(void);
 extern struct s3c64xx_spi_info s3c64xx_spi0_pdata;
 extern struct s3c64xx_spi_info s3c64xx_spi1_pdata;
 extern struct s3c64xx_spi_info s3c64xx_spi2_pdata;
-#endif /* __S3C64XX_PLAT_SPI_H */
+#endif /*__SPI_S3C64XX_H */
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 8c6583a53a06..d915d0345fa1 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -264,9 +264,9 @@ typedef struct pm_message {
  *      registers, so that it is fully operational.
  *
  * @runtime_idle: Device appears to be inactive and it might be put into a
- *      low-power state if all of the necessary conditions are satisfied.  Check
- *      these conditions and handle the device as appropriate, possibly queueing
- *      a suspend request for it.  The return value is ignored by the PM core.
+ *      low-power state if all of the necessary conditions are satisfied.
+ *      Check these conditions, and return 0 if it's appropriate to let the PM
+ *      core queue a suspend request for the device.
  *
  * Refer to Documentation/power/runtime_pm.txt for more information about the
  * role of the above callbacks in device runtime power management.
@@ -352,7 +352,7 @@ const struct dev_pm_ops name = { \
 
 /*
  * Use this for defining a set of PM operations to be used in all situations
- * (sustem suspend, hibernation or runtime PM).
+ * (system suspend, hibernation or runtime PM).
  * NOTE: In general, system suspend callbacks, .suspend() and .resume(), should
  * be different from the corresponding runtime PM callbacks, .runtime_suspend(),
  * and .runtime_resume(), because .runtime_suspend() always works on an already
@@ -379,7 +379,7 @@ const struct dev_pm_ops name = { \
  *
  * ON           No transition.
  *
- * FREEZE       System is going to hibernate, call ->prepare() and ->freeze()
+ * FREEZE       System is going to hibernate, call ->prepare() and ->freeze()
  *              for all devices.
  *
  * SUSPEND      System is going to suspend, call ->prepare() and ->suspend()
@@ -423,7 +423,7 @@ const struct dev_pm_ops name = { \
 
 #define PM_EVENT_INVALID        (-1)
 #define PM_EVENT_ON             0x0000
-#define PM_EVENT_FREEZE         0x0001
+#define PM_EVENT_FREEZE         0x0001
 #define PM_EVENT_SUSPEND        0x0002
 #define PM_EVENT_HIBERNATE      0x0004
 #define PM_EVENT_QUIESCE        0x0008
@@ -542,6 +542,8 @@ struct dev_pm_info {
         unsigned int            async_suspend:1;
         bool                    is_prepared:1;  /* Owned by the PM core */
         bool                    is_suspended:1; /* Ditto */
+        bool                    is_noirq_suspended:1;
+        bool                    is_late_suspended:1;
         bool                    ignore_children:1;
         bool                    early_init:1;   /* Owned by the PM core */
         spinlock_t              lock;
@@ -582,6 +584,7 @@ struct dev_pm_info {
         unsigned long           accounting_timestamp;
 #endif
         struct pm_subsys_data   *subsys_data;  /* Owned by the subsystem. */
+        void (*set_latency_tolerance)(struct device *, s32);
         struct dev_pm_qos       *qos;
 };
 
@@ -612,11 +615,11 @@ struct dev_pm_domain {
  * message is implicit:
  *
  * ON           Driver starts working again, responding to hardware events
- *              and software requests.  The hardware may have gone through
- *              a power-off reset, or it may have maintained state from the
- *              previous suspend() which the driver will rely on while
- *              resuming.  On most platforms, there are no restrictions on
- *              availability of resources like clocks during resume().
+ *              and software requests.  The hardware may have gone through
+ *              a power-off reset, or it may have maintained state from the
+ *              previous suspend() which the driver will rely on while
+ *              resuming.  On most platforms, there are no restrictions on
+ *              availability of resources like clocks during resume().
  *
  * Other transitions are triggered by messages sent using suspend().  All
  * these transitions quiesce the driver, so that I/O queues are inactive.
@@ -626,21 +629,21 @@ struct dev_pm_domain {
  * differ according to the message:
  *
  * SUSPEND      Quiesce, enter a low power device state appropriate for
- *              the upcoming system state (such as PCI_D3hot), and enable
- *              wakeup events as appropriate.
+ *              the upcoming system state (such as PCI_D3hot), and enable
+ *              wakeup events as appropriate.
  *
  * HIBERNATE    Enter a low power device state appropriate for the hibernation
- *              state (eg. ACPI S4) and enable wakeup events as appropriate.
+ *              state (eg. ACPI S4) and enable wakeup events as appropriate.
  *
  * FREEZE       Quiesce operations so that a consistent image can be saved;
- *              but do NOT otherwise enter a low power device state, and do
- *              NOT emit system wakeup events.
+ *              but do NOT otherwise enter a low power device state, and do
+ *              NOT emit system wakeup events.
  *
  * PRETHAW      Quiesce as if for FREEZE; additionally, prepare for restoring
- *              the system from a snapshot taken after an earlier FREEZE.
- *              Some drivers will need to reset their hardware state instead
- *              of preserving it, to ensure that it's never mistaken for the
- *              state which that earlier snapshot had set up.
+ *              the system from a snapshot taken after an earlier FREEZE.
+ *              Some drivers will need to reset their hardware state instead
+ *              of preserving it, to ensure that it's never mistaken for the
+ *              state which that earlier snapshot had set up.
  *
  * A minimally power-aware driver treats all messages as SUSPEND, fully
  * reinitializes its device during resume() -- whether or not it was reset
@@ -717,14 +720,26 @@ static inline void dpm_for_each_dev(void *data, void (*fn)(struct device *, void
 {
 }
 
-#define pm_generic_prepare      NULL
-#define pm_generic_suspend      NULL
-#define pm_generic_resume       NULL
-#define pm_generic_freeze       NULL
-#define pm_generic_thaw         NULL
-#define pm_generic_restore      NULL
-#define pm_generic_poweroff     NULL
-#define pm_generic_complete     NULL
+#define pm_generic_prepare              NULL
+#define pm_generic_suspend_late         NULL
+#define pm_generic_suspend_noirq        NULL
+#define pm_generic_suspend              NULL
+#define pm_generic_resume_early         NULL
+#define pm_generic_resume_noirq         NULL
+#define pm_generic_resume               NULL
+#define pm_generic_freeze_noirq         NULL
+#define pm_generic_freeze_late          NULL
+#define pm_generic_freeze               NULL
+#define pm_generic_thaw_noirq           NULL
+#define pm_generic_thaw_early           NULL
+#define pm_generic_thaw                 NULL
+#define pm_generic_restore_noirq        NULL
+#define pm_generic_restore_early        NULL
+#define pm_generic_restore              NULL
+#define pm_generic_poweroff_noirq       NULL
+#define pm_generic_poweroff_late        NULL
+#define pm_generic_poweroff             NULL
+#define pm_generic_complete             NULL
 #endif /* !CONFIG_PM_SLEEP */
 
 /* How to reorder dpm_list after device_move() */
diff --git a/include/linux/pm_qos.h b/include/linux/pm_qos.h
index 5a95013905c8..9ab4bf7c4646 100644
--- a/include/linux/pm_qos.h
+++ b/include/linux/pm_qos.h
@@ -32,7 +32,10 @@ enum pm_qos_flags_status {
 #define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
 #define PM_QOS_NETWORK_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
 #define PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE 0
-#define PM_QOS_DEV_LAT_DEFAULT_VALUE            0
+#define PM_QOS_RESUME_LATENCY_DEFAULT_VALUE     0
+#define PM_QOS_LATENCY_TOLERANCE_DEFAULT_VALUE  0
+#define PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT  (-1)
+#define PM_QOS_LATENCY_ANY                      ((s32)(~(__u32)0 >> 1))
 
 #define PM_QOS_FLAG_NO_POWER_OFF        (1 << 0)
 #define PM_QOS_FLAG_REMOTE_WAKEUP       (1 << 1)
@@ -49,7 +52,8 @@ struct pm_qos_flags_request {
 };
 
 enum dev_pm_qos_req_type {
-        DEV_PM_QOS_LATENCY = 1,
+        DEV_PM_QOS_RESUME_LATENCY = 1,
+        DEV_PM_QOS_LATENCY_TOLERANCE,
         DEV_PM_QOS_FLAGS,
 };
 
@@ -77,6 +81,7 @@ struct pm_qos_constraints {
         struct plist_head list;
         s32 target_value;       /* Do not change to 64 bit */
         s32 default_value;
+        s32 no_constraint_value;
         enum pm_qos_type type;
         struct blocking_notifier_head *notifiers;
 };
@@ -87,9 +92,11 @@ struct pm_qos_flags {
 };
 
 struct dev_pm_qos {
-        struct pm_qos_constraints latency;
+        struct pm_qos_constraints resume_latency;
+        struct pm_qos_constraints latency_tolerance;
         struct pm_qos_flags flags;
-        struct dev_pm_qos_request *latency_req;
+        struct dev_pm_qos_request *resume_latency_req;
+        struct dev_pm_qos_request *latency_tolerance_req;
         struct dev_pm_qos_request *flags_req;
 };
 
@@ -142,7 +149,8 @@ int dev_pm_qos_remove_global_notifier(struct notifier_block *notifier);
 void dev_pm_qos_constraints_init(struct device *dev);
 void dev_pm_qos_constraints_destroy(struct device *dev);
 int dev_pm_qos_add_ancestor_request(struct device *dev,
-                                    struct dev_pm_qos_request *req, s32 value);
+                                    struct dev_pm_qos_request *req,
+                                    enum dev_pm_qos_req_type type, s32 value);
 #else
 static inline enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev,
                                                           s32 mask)
@@ -185,7 +193,9 @@ static inline void dev_pm_qos_constraints_destroy(struct device *dev)
         dev->power.power_state = PMSG_INVALID;
 }
 static inline int dev_pm_qos_add_ancestor_request(struct device *dev,
-                                    struct dev_pm_qos_request *req, s32 value)
+                                                  struct dev_pm_qos_request *req,
+                                                  enum dev_pm_qos_req_type type,
+                                                  s32 value)
                         { return 0; }
 #endif
 
@@ -195,10 +205,12 @@ void dev_pm_qos_hide_latency_limit(struct device *dev);
 int dev_pm_qos_expose_flags(struct device *dev, s32 value);
 void dev_pm_qos_hide_flags(struct device *dev);
 int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set);
+s32 dev_pm_qos_get_user_latency_tolerance(struct device *dev);
+int dev_pm_qos_update_user_latency_tolerance(struct device *dev, s32 val);
 
-static inline s32 dev_pm_qos_requested_latency(struct device *dev)
+static inline s32 dev_pm_qos_requested_resume_latency(struct device *dev)
 {
-        return dev->power.qos->latency_req->data.pnode.prio;
+        return dev->power.qos->resume_latency_req->data.pnode.prio;
 }
 
 static inline s32 dev_pm_qos_requested_flags(struct device *dev)
@@ -214,8 +226,12 @@ static inline int dev_pm_qos_expose_flags(struct device *dev, s32 value)
 static inline void dev_pm_qos_hide_flags(struct device *dev) {}
 static inline int dev_pm_qos_update_flags(struct device *dev, s32 m, bool set)
                         { return 0; }
+static inline s32 dev_pm_qos_get_user_latency_tolerance(struct device *dev)
+                        { return PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT; }
+static inline int dev_pm_qos_update_user_latency_tolerance(struct device *dev, s32 val)
+                        { return 0; }
 
-static inline s32 dev_pm_qos_requested_latency(struct device *dev) { return 0; }
+static inline s32 dev_pm_qos_requested_resume_latency(struct device *dev) { return 0; }
 static inline s32 dev_pm_qos_requested_flags(struct device *dev) { return 0; }
 #endif
 
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index 16c9a62fa1c0..2a5897a4afbc 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -26,9 +26,13 @@
 #ifdef CONFIG_PM
 extern int pm_generic_runtime_suspend(struct device *dev);
 extern int pm_generic_runtime_resume(struct device *dev);
+extern int pm_runtime_force_suspend(struct device *dev);
+extern int pm_runtime_force_resume(struct device *dev);
 #else
 static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
 static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
+static inline int pm_runtime_force_suspend(struct device *dev) { return 0; }
+static inline int pm_runtime_force_resume(struct device *dev) { return 0; }
 #endif
 
 #ifdef CONFIG_PM_RUNTIME
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index dbaf99084112..8183b46fbaa2 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -247,9 +247,10 @@ static inline void list_splice_init_rcu(struct list_head *list,
  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
  */
 #define list_entry_rcu(ptr, type, member) \
-        ({typeof (*ptr) __rcu *__ptr = (typeof (*ptr) __rcu __force *)ptr; \
-         container_of((typeof(ptr))rcu_dereference_raw(__ptr), type, member); \
-        })
+({ \
+        typeof(*ptr) __rcu *__ptr = (typeof(*ptr) __rcu __force *)ptr; \
+        container_of((typeof(ptr))rcu_dereference_raw(__ptr), type, member); \
+})
 
 /**
  * Where are list_empty_rcu() and list_first_entry_rcu()?
@@ -285,11 +286,11 @@ static inline void list_splice_init_rcu(struct list_head *list,
  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
  */
 #define list_first_or_null_rcu(ptr, type, member) \
-        ({struct list_head *__ptr = (ptr); \
-          struct list_head *__next = ACCESS_ONCE(__ptr->next); \
-          likely(__ptr != __next) ? \
-                list_entry_rcu(__next, type, member) : NULL; \
-        })
+({ \
+        struct list_head *__ptr = (ptr); \
+        struct list_head *__next = ACCESS_ONCE(__ptr->next); \
+        likely(__ptr != __next) ? list_entry_rcu(__next, type, member) : NULL; \
+})
 
 /**
  * list_for_each_entry_rcu      -       iterate over rcu list of given type
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 72bf3a01a4ee..00a7fd61b3c6 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -12,8 +12,8 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * along with this program; if not, you can access it online at
+ * http://www.gnu.org/licenses/gpl-2.0.html.
  *
  * Copyright IBM Corporation, 2001
  *
@@ -44,7 +44,9 @@
 #include <linux/debugobjects.h>
 #include <linux/bug.h>
 #include <linux/compiler.h>
+#include <asm/barrier.h>
 
+extern int rcu_expedited; /* for sysctl */
 #ifdef CONFIG_RCU_TORTURE_TEST
 extern int rcutorture_runnable; /* for sysctl */
 #endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
@@ -314,7 +316,7 @@ static inline bool rcu_lockdep_current_cpu_online(void)
 
 static inline void rcu_lock_acquire(struct lockdep_map *map)
 {
-        lock_acquire(map, 0, 0, 2, 1, NULL, _THIS_IP_);
+        lock_acquire(map, 0, 0, 2, 0, NULL, _THIS_IP_);
 }
 
 static inline void rcu_lock_release(struct lockdep_map *map)
@@ -479,11 +481,9 @@ static inline void rcu_preempt_sleep_check(void)
         do {                                                            \
                 rcu_preempt_sleep_check();                              \
                 rcu_lockdep_assert(!lock_is_held(&rcu_bh_lock_map),     \
-                                   "Illegal context switch in RCU-bh"   \
-                                   " read-side critical section");      \
+                                   "Illegal context switch in RCU-bh read-side critical section"); \
                 rcu_lockdep_assert(!lock_is_held(&rcu_sched_lock_map),  \
-                                   "Illegal context switch in RCU-sched"\
-                                   " read-side critical section");      \
+                                   "Illegal context switch in RCU-sched read-side critical section"); \
         } while (0)
 
 #else /* #ifdef CONFIG_PROVE_RCU */
@@ -510,43 +510,40 @@ static inline void rcu_preempt_sleep_check(void)
 #endif /* #else #ifdef __CHECKER__ */
 
 #define __rcu_access_pointer(p, space) \
-        ({ \
-                typeof(*p) *_________p1 = (typeof(*p)*__force )ACCESS_ONCE(p); \
-                rcu_dereference_sparse(p, space); \
-                ((typeof(*p) __force __kernel *)(_________p1)); \
-        })
+({ \
+        typeof(*p) *_________p1 = (typeof(*p) *__force)ACCESS_ONCE(p); \
+        rcu_dereference_sparse(p, space); \
+        ((typeof(*p) __force __kernel *)(_________p1)); \
+})
 #define __rcu_dereference_check(p, c, space) \
-        ({ \
-                typeof(*p) *_________p1 = (typeof(*p)*__force )ACCESS_ONCE(p); \
-                rcu_lockdep_assert(c, "suspicious rcu_dereference_check()" \
-                                      " usage"); \
-                rcu_dereference_sparse(p, space); \
-                smp_read_barrier_depends(); \
-                ((typeof(*p) __force __kernel *)(_________p1)); \
-        })
+({ \
+        typeof(*p) *_________p1 = (typeof(*p) *__force)ACCESS_ONCE(p); \
+        rcu_lockdep_assert(c, "suspicious rcu_dereference_check() usage"); \
+        rcu_dereference_sparse(p, space); \
+        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
+        ((typeof(*p) __force __kernel *)(_________p1)); \
+})
 #define __rcu_dereference_protected(p, c, space) \
-        ({ \
-                rcu_lockdep_assert(c, "suspicious rcu_dereference_protected()" \
-                                      " usage"); \
-                rcu_dereference_sparse(p, space); \
-                ((typeof(*p) __force __kernel *)(p)); \
-        })
+({ \
+        rcu_lockdep_assert(c, "suspicious rcu_dereference_protected() usage"); \
+        rcu_dereference_sparse(p, space); \
+        ((typeof(*p) __force __kernel *)(p)); \
+})
 
 #define __rcu_access_index(p, space) \
-        ({ \
-                typeof(p) _________p1 = ACCESS_ONCE(p); \
-                rcu_dereference_sparse(p, space); \
-                (_________p1); \
-        })
+({ \
+        typeof(p) _________p1 = ACCESS_ONCE(p); \
+        rcu_dereference_sparse(p, space); \
+        (_________p1); \
+})
 #define __rcu_dereference_index_check(p, c) \
-        ({ \
-                typeof(p) _________p1 = ACCESS_ONCE(p); \
-                rcu_lockdep_assert(c, \
-                                   "suspicious rcu_dereference_index_check()" \
-                                   " usage"); \
-                smp_read_barrier_depends(); \
-                (_________p1); \
-        })
+({ \
+        typeof(p) _________p1 = ACCESS_ONCE(p); \
+        rcu_lockdep_assert(c, \
+                           "suspicious rcu_dereference_index_check() usage"); \
+        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
+        (_________p1); \
+})
 
 /**
  * RCU_INITIALIZER() - statically initialize an RCU-protected global variable
@@ -585,12 +582,7 @@ static inline void rcu_preempt_sleep_check(void)
  * please be careful when making changes to rcu_assign_pointer() and the
  * other macros that it invokes.
  */
-#define rcu_assign_pointer(p, v) \
-        do { \
-                smp_wmb(); \
-                ACCESS_ONCE(p) = RCU_INITIALIZER(v); \
-        } while (0)
-
+#define rcu_assign_pointer(p, v) smp_store_release(&p, RCU_INITIALIZER(v))
 
 /**
  * rcu_access_pointer() - fetch RCU pointer with no dereferencing
@@ -1015,11 +1007,21 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
 #define kfree_rcu(ptr, rcu_head)                                        \
         __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
 
-#ifdef CONFIG_RCU_NOCB_CPU
+#if defined(CONFIG_TINY_RCU) || defined(CONFIG_RCU_NOCB_CPU_ALL)
+static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
+{
+        *delta_jiffies = ULONG_MAX;
+        return 0;
+}
+#endif /* #if defined(CONFIG_TINY_RCU) || defined(CONFIG_RCU_NOCB_CPU_ALL) */
+
+#if defined(CONFIG_RCU_NOCB_CPU_ALL)
+static inline bool rcu_is_nocb_cpu(int cpu) { return true; }
+#elif defined(CONFIG_RCU_NOCB_CPU)
 bool rcu_is_nocb_cpu(int cpu);
 #else
 static inline bool rcu_is_nocb_cpu(int cpu) { return false; }
-#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */
+#endif
 
 
 /* Only for use by adaptive-ticks code. */
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index 6f01771b571c..425c659d54e5 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -12,8 +12,8 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * along with this program; if not, you can access it online at
+ * http://www.gnu.org/licenses/gpl-2.0.html.
  *
  * Copyright IBM Corporation, 2008
  *
@@ -27,6 +27,16 @@
 
 #include <linux/cache.h>
 
+static inline unsigned long get_state_synchronize_rcu(void)
+{
+        return 0;
+}
+
+static inline void cond_synchronize_rcu(unsigned long oldstate)
+{
+        might_sleep();
+}
+
 static inline void rcu_barrier_bh(void)
 {
         wait_rcu_gp(call_rcu_bh);
@@ -68,12 +78,6 @@ static inline void kfree_call_rcu(struct rcu_head *head,
         call_rcu(head, func);
 }
 
-static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
-{
-        *delta_jiffies = ULONG_MAX;
-        return 0;
-}
-
 static inline void rcu_note_context_switch(int cpu)
 {
         rcu_sched_qs(cpu);
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 72137ee8c603..a59ca05fd4e3 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -12,8 +12,8 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * along with this program; if not, you can access it online at
+ * http://www.gnu.org/licenses/gpl-2.0.html.
  *
  * Copyright IBM Corporation, 2008
  *
@@ -31,7 +31,9 @@
 #define __LINUX_RCUTREE_H
 
 void rcu_note_context_switch(int cpu);
+#ifndef CONFIG_RCU_NOCB_CPU_ALL
 int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies);
+#endif /* #ifndef CONFIG_RCU_NOCB_CPU_ALL */
 void rcu_cpu_stall_reset(void);
 
 /*
@@ -74,6 +76,8 @@ static inline void synchronize_rcu_bh_expedited(void)
 void rcu_barrier(void);
 void rcu_barrier_bh(void);
 void rcu_barrier_sched(void);
+unsigned long get_state_synchronize_rcu(void);
+void cond_synchronize_rcu(unsigned long oldstate);
 
 extern unsigned long rcutorture_testseq;
 extern unsigned long rcutorture_vernum;
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 4149f1a9b003..85691b9b4fa7 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -164,6 +164,9 @@ typedef void (*regmap_unlock)(void *);
  * @use_single_rw: If set, converts the bulk read and write operations into
  *                  a series of single read and write operations. This is useful
  *                  for device that does not support bulk read and write.
+ * @can_multi_write: If set, the device supports the multi write mode of bulk
+ *                   write operations, if clear multi write requests will be
+ *                   split into individual write operations
  *
  * @cache_type: The actual cache type.
  * @reg_defaults_raw: Power on reset values for registers (for use with
@@ -215,6 +218,7 @@ struct regmap_config {
         u8 write_flag_mask;
 
         bool use_single_rw;
+        bool can_multi_write;
 
         enum regmap_endian reg_format_endian;
         enum regmap_endian val_format_endian;
@@ -317,12 +321,16 @@ struct regmap *regmap_init(struct device *dev,
                            const struct regmap_bus *bus,
                            void *bus_context,
                            const struct regmap_config *config);
+int regmap_attach_dev(struct device *dev, struct regmap *map,
+                                 const struct regmap_config *config);
 struct regmap *regmap_init_i2c(struct i2c_client *i2c,
                                const struct regmap_config *config);
 struct regmap *regmap_init_spi(struct spi_device *dev,
                                const struct regmap_config *config);
-struct regmap *regmap_init_spmi(struct spmi_device *dev,
-                               const struct regmap_config *config);
+struct regmap *regmap_init_spmi_base(struct spmi_device *dev,
+                                     const struct regmap_config *config);
+struct regmap *regmap_init_spmi_ext(struct spmi_device *dev,
+                                    const struct regmap_config *config);
 struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
                                     void __iomem *regs,
                                     const struct regmap_config *config);
@@ -335,8 +343,10 @@ struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
                                     const struct regmap_config *config);
 struct regmap *devm_regmap_init_spi(struct spi_device *dev,
                                     const struct regmap_config *config);
-struct regmap *devm_regmap_init_spmi(struct spmi_device *dev,
-                                     const struct regmap_config *config);
+struct regmap *devm_regmap_init_spmi_base(struct spmi_device *dev,
+                                          const struct regmap_config *config);
+struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *dev,
+                                         const struct regmap_config *config);
 struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
                                          void __iomem *regs,
                                          const struct regmap_config *config);
@@ -386,8 +396,11 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
                      const void *val, size_t val_len);
 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
                         size_t val_count);
-int regmap_multi_reg_write(struct regmap *map, struct reg_default *regs,
+int regmap_multi_reg_write(struct regmap *map, const struct reg_default *regs,
                         int num_regs);
+int regmap_multi_reg_write_bypassed(struct regmap *map,
+                                    const struct reg_default *regs,
+                                    int num_regs);
 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
                            const void *val, size_t val_len);
 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
@@ -423,6 +436,8 @@ bool regmap_check_range_table(struct regmap *map, unsigned int reg,
 
 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
                           int num_regs);
+int regmap_parse_val(struct regmap *map, const void *buf,
+                                unsigned int *val);
 
 static inline bool regmap_reg_in_range(unsigned int reg,
                                        const struct regmap_range *range)
@@ -695,6 +710,13 @@ static inline int regmap_register_patch(struct regmap *map,
         return -EINVAL;
 }
 
+static inline int regmap_parse_val(struct regmap *map, const void *buf,
+                                unsigned int *val)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
 static inline struct regmap *dev_get_regmap(struct device *dev,
                                             const char *name)
 {
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 9370e65348a4..bbe03a1924c0 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -228,10 +228,14 @@ enum regulator_type {
  *                output when using regulator_set_voltage_sel_regmap
  * @enable_reg: Register for control when using regmap enable/disable ops
  * @enable_mask: Mask for control when using regmap enable/disable ops
+ * @enable_val: Enabling value for control when using regmap enable/disable ops
+ * @disable_val: Disabling value for control when using regmap enable/disable ops
  * @enable_is_inverted: A flag to indicate set enable_mask bits to disable
  *                      when using regulator_enable_regmap and friends APIs.
  * @bypass_reg: Register for control when using regmap set_bypass
  * @bypass_mask: Mask for control when using regmap set_bypass
+ * @bypass_val_on: Enabling value for control when using regmap set_bypass
+ * @bypass_val_off: Disabling value for control when using regmap set_bypass
  *
  * @enable_time: Time taken for initial enable of regulator (in uS).
  */
@@ -263,9 +267,13 @@ struct regulator_desc {
         unsigned int apply_bit;
         unsigned int enable_reg;
         unsigned int enable_mask;
+        unsigned int enable_val;
+        unsigned int disable_val;
         bool enable_is_inverted;
         unsigned int bypass_reg;
         unsigned int bypass_mask;
+        unsigned int bypass_val_on;
+        unsigned int bypass_val_off;
 
         unsigned int enable_time;
 };
diff --git a/include/linux/regulator/pfuze100.h b/include/linux/regulator/pfuze100.h
index 65d550bf3954..364f7a7c43db 100644
--- a/include/linux/regulator/pfuze100.h
+++ b/include/linux/regulator/pfuze100.h
@@ -35,6 +35,20 @@
 #define PFUZE100_VGEN6          14
 #define PFUZE100_MAX_REGULATOR  15
 
+#define PFUZE200_SW1AB          0
+#define PFUZE200_SW2            1
+#define PFUZE200_SW3A           2
+#define PFUZE200_SW3B           3
+#define PFUZE200_SWBST          4
+#define PFUZE200_VSNVS          5
+#define PFUZE200_VREFDDR        6
+#define PFUZE200_VGEN1          7
+#define PFUZE200_VGEN2          8
+#define PFUZE200_VGEN3          9
+#define PFUZE200_VGEN4          10
+#define PFUZE200_VGEN5          11
+#define PFUZE200_VGEN6          12
+
 struct regulator_init_data;
 
 struct pfuze_regulator_platform_data {
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 1da693d51255..b66c2110cb1f 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -250,8 +250,7 @@ struct rmap_walk_control {
         int (*rmap_one)(struct page *page, struct vm_area_struct *vma,
                                         unsigned long addr, void *arg);
         int (*done)(struct page *page);
-        int (*file_nonlinear)(struct page *, struct address_space *,
-                                        struct vm_area_struct *vma);
+        int (*file_nonlinear)(struct page *, struct address_space *, void *arg);
         struct anon_vma *(*anon_lock)(struct page *page);
         bool (*invalid_vma)(struct vm_area_struct *vma, void *arg);
 };
diff --git a/include/linux/sched.h b/include/linux/sched.h
index a781dec1cd0b..7cb07fd26680 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -3,6 +3,8 @@
 
 #include <uapi/linux/sched.h>
 
+#include <linux/sched/prio.h>
+
 
 struct sched_param {
         int sched_priority;
@@ -27,7 +29,7 @@ struct sched_param {
 
 #include <asm/page.h>
 #include <asm/ptrace.h>
-#include <asm/cputime.h>
+#include <linux/cputime.h>
 
 #include <linux/smp.h>
 #include <linux/sem.h>
@@ -292,10 +294,14 @@ extern int runqueue_is_locked(int cpu);
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
 extern void nohz_balance_enter_idle(int cpu);
 extern void set_cpu_sd_state_idle(void);
-extern int get_nohz_timer_target(void);
+extern int get_nohz_timer_target(int pinned);
 #else
 static inline void nohz_balance_enter_idle(int cpu) { }
 static inline void set_cpu_sd_state_idle(void) { }
+static inline int get_nohz_timer_target(int pinned)
+{
+        return smp_processor_id();
+}
 #endif
 
 /*
@@ -1077,6 +1083,7 @@ struct sched_entity {
 #endif
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
+        int                     depth;
         struct sched_entity     *parent;
         /* rq on which this entity is (to be) queued: */
         struct cfs_rq           *cfs_rq;
@@ -1460,6 +1467,9 @@ struct task_struct {
         struct mutex perf_event_mutex;
         struct list_head perf_event_list;
 #endif
+#ifdef CONFIG_DEBUG_PREEMPT
+        unsigned long preempt_disable_ip;
+#endif
 #ifdef CONFIG_NUMA
         struct mempolicy *mempolicy;    /* Protected by alloc_lock */
         short il_next;
@@ -1470,9 +1480,10 @@ struct task_struct {
         unsigned int numa_scan_period;
         unsigned int numa_scan_period_max;
         int numa_preferred_nid;
-        int numa_migrate_deferred;
         unsigned long numa_migrate_retry;
         u64 node_stamp;                 /* migration stamp  */
+        u64 last_task_numa_placement;
+        u64 last_sum_exec_runtime;
         struct callback_head numa_work;
 
         struct list_head numa_entry;
@@ -1483,15 +1494,22 @@ struct task_struct {
          * Scheduling placement decisions are made based on the these counts.
          * The values remain static for the duration of a PTE scan
          */
-        unsigned long *numa_faults;
+        unsigned long *numa_faults_memory;
         unsigned long total_numa_faults;
 
         /*
          * numa_faults_buffer records faults per node during the current
-         * scan window. When the scan completes, the counts in numa_faults
-         * decay and these values are copied.
+         * scan window. When the scan completes, the counts in
+         * numa_faults_memory decay and these values are copied.
          */
-        unsigned long *numa_faults_buffer;
+        unsigned long *numa_faults_buffer_memory;
+
+        /*
+         * Track the nodes the process was running on when a NUMA hinting
+         * fault was incurred.
+         */
+        unsigned long *numa_faults_cpu;
+        unsigned long *numa_faults_buffer_cpu;
 
         /*
          * numa_faults_locality tracks if faults recorded during the last
@@ -1596,8 +1614,8 @@ extern void task_numa_fault(int last_node, int node, int pages, int flags);
 extern pid_t task_numa_group_id(struct task_struct *p);
 extern void set_numabalancing_state(bool enabled);
 extern void task_numa_free(struct task_struct *p);
-
-extern unsigned int sysctl_numa_balancing_migrate_deferred;
+extern bool should_numa_migrate_memory(struct task_struct *p, struct page *page,
+                                        int src_nid, int dst_cpu);
 #else
 static inline void task_numa_fault(int last_node, int node, int pages,
                                    int flags)
@@ -1613,6 +1631,11 @@ static inline void set_numabalancing_state(bool enabled)
 static inline void task_numa_free(struct task_struct *p)
 {
 }
+static inline bool should_numa_migrate_memory(struct task_struct *p,
+                                struct page *page, int src_nid, int dst_cpu)
+{
+        return true;
+}
 #endif
 
 static inline struct pid *task_pid(struct task_struct *task)
@@ -2080,7 +2103,16 @@ static inline void sched_autogroup_exit(struct signal_struct *sig) { }
 extern bool yield_to(struct task_struct *p, bool preempt);
 extern void set_user_nice(struct task_struct *p, long nice);
 extern int task_prio(const struct task_struct *p);
-extern int task_nice(const struct task_struct *p);
+/**
+ * task_nice - return the nice value of a given task.
+ * @p: the task in question.
+ *
+ * Return: The nice value [ -20 ... 0 ... 19 ].
+ */
+static inline int task_nice(const struct task_struct *p)
+{
+        return PRIO_TO_NICE((p)->static_prio);
+}
 extern int can_nice(const struct task_struct *p, const int nice);
 extern int task_curr(const struct task_struct *p);
 extern int idle_cpu(int cpu);
diff --git a/include/linux/sched/prio.h b/include/linux/sched/prio.h
new file mode 100644
index 000000000000..ac322583c820
--- /dev/null
+++ b/include/linux/sched/prio.h
@@ -0,0 +1,44 @@
+#ifndef _SCHED_PRIO_H
+#define _SCHED_PRIO_H
+
+#define MAX_NICE        19
+#define MIN_NICE        -20
+#define NICE_WIDTH      (MAX_NICE - MIN_NICE + 1)
+
+/*
+ * Priority of a process goes from 0..MAX_PRIO-1, valid RT
+ * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
+ * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
+ * values are inverted: lower p->prio value means higher priority.
+ *
+ * The MAX_USER_RT_PRIO value allows the actual maximum
+ * RT priority to be separate from the value exported to
+ * user-space.  This allows kernel threads to set their
+ * priority to a value higher than any user task. Note:
+ * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
+ */
+
+#define MAX_USER_RT_PRIO        100
+#define MAX_RT_PRIO             MAX_USER_RT_PRIO
+
+#define MAX_PRIO                (MAX_RT_PRIO + NICE_WIDTH)
+#define DEFAULT_PRIO            (MAX_RT_PRIO + NICE_WIDTH / 2)
+
+/*
+ * Convert user-nice values [ -20 ... 0 ... 19 ]
+ * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
+ * and back.
+ */
+#define NICE_TO_PRIO(nice)      ((nice) + DEFAULT_PRIO)
+#define PRIO_TO_NICE(prio)      ((prio) - DEFAULT_PRIO)
+
+/*
+ * 'User priority' is the nice value converted to something we
+ * can work with better when scaling various scheduler parameters,
+ * it's a [ 0 ... 39 ] range.
+ */
+#define USER_PRIO(p)            ((p)-MAX_RT_PRIO)
+#define TASK_USER_PRIO(p)       USER_PRIO((p)->static_prio)
+#define MAX_USER_PRIO           (USER_PRIO(MAX_PRIO))
+
+#endif /* _SCHED_PRIO_H */
diff --git a/include/linux/sched/rt.h b/include/linux/sched/rt.h
index 34e4ebea8fce..6341f5be6e24 100644
--- a/include/linux/sched/rt.h
+++ b/include/linux/sched/rt.h
@@ -1,24 +1,7 @@
 #ifndef _SCHED_RT_H
 #define _SCHED_RT_H
 
-/*
- * Priority of a process goes from 0..MAX_PRIO-1, valid RT
- * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
- * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
- * values are inverted: lower p->prio value means higher priority.
- *
- * The MAX_USER_RT_PRIO value allows the actual maximum
- * RT priority to be separate from the value exported to
- * user-space.  This allows kernel threads to set their
- * priority to a value higher than any user task. Note:
- * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
- */
-
-#define MAX_USER_RT_PRIO        100
-#define MAX_RT_PRIO             MAX_USER_RT_PRIO
-
-#define MAX_PRIO                (MAX_RT_PRIO + 40)
-#define DEFAULT_PRIO            (MAX_RT_PRIO + 20)
+#include <linux/sched/prio.h>
 
 static inline int rt_prio(int prio)
 {
@@ -35,6 +18,7 @@ static inline int rt_task(struct task_struct *p)
 #ifdef CONFIG_RT_MUTEXES
 extern int rt_mutex_getprio(struct task_struct *p);
 extern void rt_mutex_setprio(struct task_struct *p, int prio);
+extern int rt_mutex_check_prio(struct task_struct *task, int newprio);
 extern struct task_struct *rt_mutex_get_top_task(struct task_struct *task);
 extern void rt_mutex_adjust_pi(struct task_struct *p);
 static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
@@ -46,6 +30,12 @@ static inline int rt_mutex_getprio(struct task_struct *p)
 {
         return p->normal_prio;
 }
+
+static inline int rt_mutex_check_prio(struct task_struct *task, int newprio)
+{
+        return 0;
+}
+
 static inline struct task_struct *rt_mutex_get_top_task(struct task_struct *task)
 {
         return NULL;
diff --git a/include/linux/security.h b/include/linux/security.h
index 5623a7f965b7..2fc42d191f79 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1040,6 +1040,7 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      Allocate a security structure to the xp->security field; the security
  *      field is initialized to NULL when the xfrm_policy is allocated.
  *      Return 0 if operation was successful (memory to allocate, legal context)
+ *      @gfp is to specify the context for the allocation
  * @xfrm_policy_clone_security:
  *      @old_ctx contains an existing xfrm_sec_ctx.
  *      @new_ctxp contains a new xfrm_sec_ctx being cloned from old.
@@ -1683,7 +1684,7 @@ struct security_operations {
 
 #ifdef CONFIG_SECURITY_NETWORK_XFRM
         int (*xfrm_policy_alloc_security) (struct xfrm_sec_ctx **ctxp,
-                        struct xfrm_user_sec_ctx *sec_ctx);
+                        struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp);
         int (*xfrm_policy_clone_security) (struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctx);
         void (*xfrm_policy_free_security) (struct xfrm_sec_ctx *ctx);
         int (*xfrm_policy_delete_security) (struct xfrm_sec_ctx *ctx);
@@ -2859,7 +2860,8 @@ static inline void security_skb_owned_by(struct sk_buff *skb, struct sock *sk)
 
 #ifdef CONFIG_SECURITY_NETWORK_XFRM
 
-int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp, struct xfrm_user_sec_ctx *sec_ctx);
+int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
+                               struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp);
 int security_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctxp);
 void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx);
 int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx);
@@ -2877,7 +2879,9 @@ void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl);
 
 #else   /* CONFIG_SECURITY_NETWORK_XFRM */
 
-static inline int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp, struct xfrm_user_sec_ctx *sec_ctx)
+static inline int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp,
+                                             struct xfrm_user_sec_ctx *sec_ctx,
+                                             gfp_t gfp)
 {
         return 0;
 }
diff --git a/include/linux/serial_bcm63xx.h b/include/linux/serial_bcm63xx.h
index 570e964dc899..a80aa1a5bee2 100644
--- a/include/linux/serial_bcm63xx.h
+++ b/include/linux/serial_bcm63xx.h
@@ -116,4 +116,6 @@
                                         UART_FIFO_PARERR_MASK |         \
                                         UART_FIFO_BRKDET_MASK)
 
+#define UART_REG_SIZE                   24
+
 #endif /* _LINUX_SERIAL_BCM63XX_H */
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index 22b3640c9424..6c5e3bb282b0 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -10,45 +10,59 @@
 
 #define SCIx_NOT_SUPPORTED      (-1)
 
-#define SCSCR_TIE       (1 << 7)
-#define SCSCR_RIE       (1 << 6)
-#define SCSCR_TE        (1 << 5)
-#define SCSCR_RE        (1 << 4)
-#define SCSCR_REIE      (1 << 3)        /* not supported by all parts */
-#define SCSCR_TOIE      (1 << 2)        /* not supported by all parts */
-#define SCSCR_CKE1      (1 << 1)
-#define SCSCR_CKE0      (1 << 0)
-
-/* SCxSR SCI */
-#define SCI_TDRE  0x80
-#define SCI_RDRF  0x40
-#define SCI_ORER  0x20
-#define SCI_FER   0x10
-#define SCI_PER   0x08
-#define SCI_TEND  0x04
+/* SCSMR (Serial Mode Register) */
+#define SCSMR_CHR       (1 << 6)        /* 7-bit Character Length */
+#define SCSMR_PE        (1 << 5)        /* Parity Enable */
+#define SCSMR_ODD       (1 << 4)        /* Odd Parity */
+#define SCSMR_STOP      (1 << 3)        /* Stop Bit Length */
+#define SCSMR_CKS       0x0003          /* Clock Select */
+
+/* Serial Control Register (@ = not supported by all parts) */
+#define SCSCR_TIE       (1 << 7)        /* Transmit Interrupt Enable */
+#define SCSCR_RIE       (1 << 6)        /* Receive Interrupt Enable */
+#define SCSCR_TE        (1 << 5)        /* Transmit Enable */
+#define SCSCR_RE        (1 << 4)        /* Receive Enable */
+#define SCSCR_REIE      (1 << 3)        /* Receive Error Interrupt Enable @ */
+#define SCSCR_TOIE      (1 << 2)        /* Timeout Interrupt Enable @ */
+#define SCSCR_CKE1      (1 << 1)        /* Clock Enable 1 */
+#define SCSCR_CKE0      (1 << 0)        /* Clock Enable 0 */
+/* SCIFA/SCIFB only */
+#define SCSCR_TDRQE     (1 << 15)       /* Tx Data Transfer Request Enable */
+#define SCSCR_RDRQE     (1 << 14)       /* Rx Data Transfer Request Enable */
+
+/* SCxSR (Serial Status Register) on SCI */
+#define SCI_TDRE  0x80                  /* Transmit Data Register Empty */
+#define SCI_RDRF  0x40                  /* Receive Data Register Full */
+#define SCI_ORER  0x20                  /* Overrun Error */
+#define SCI_FER   0x10                  /* Framing Error */
+#define SCI_PER   0x08                  /* Parity Error */
+#define SCI_TEND  0x04                  /* Transmit End */
 
 #define SCI_DEFAULT_ERROR_MASK (SCI_PER | SCI_FER)
 
-/* SCxSR SCIF, HSCIF */
-#define SCIF_ER    0x0080
-#define SCIF_TEND  0x0040
-#define SCIF_TDFE  0x0020
-#define SCIF_BRK   0x0010
-#define SCIF_FER   0x0008
-#define SCIF_PER   0x0004
-#define SCIF_RDF   0x0002
-#define SCIF_DR    0x0001
+/* SCxSR (Serial Status Register) on SCIF, HSCIF */
+#define SCIF_ER    0x0080               /* Receive Error */
+#define SCIF_TEND  0x0040               /* Transmission End */
+#define SCIF_TDFE  0x0020               /* Transmit FIFO Data Empty */
+#define SCIF_BRK   0x0010               /* Break Detect */
+#define SCIF_FER   0x0008               /* Framing Error */
+#define SCIF_PER   0x0004               /* Parity Error */
+#define SCIF_RDF   0x0002               /* Receive FIFO Data Full */
+#define SCIF_DR    0x0001               /* Receive Data Ready */
 
 #define SCIF_DEFAULT_ERROR_MASK (SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
 
-/* SCSPTR, optional */
-#define SCSPTR_RTSIO    (1 << 7)
-#define SCSPTR_CTSIO    (1 << 5)
-#define SCSPTR_SPB2IO   (1 << 1)
-#define SCSPTR_SPB2DT   (1 << 0)
+/* SCFCR (FIFO Control Register) */
+#define SCFCR_LOOP      (1 << 0)        /* Loopback Test */
+
+/* SCSPTR (Serial Port Register), optional */
+#define SCSPTR_RTSIO    (1 << 7)        /* Serial Port RTS Pin Input/Output */
+#define SCSPTR_CTSIO    (1 << 5)        /* Serial Port CTS Pin Input/Output */
+#define SCSPTR_SPB2IO   (1 << 1)        /* Serial Port Break Input/Output */
+#define SCSPTR_SPB2DT   (1 << 0)        /* Serial Port Break Data */
 
 /* HSSRR HSCIF */
-#define HSCIF_SRE       0x8000
+#define HSCIF_SRE       0x8000          /* Sampling Rate Register Enable */
 
 enum {
         SCIx_PROBE_REGTYPE,
@@ -73,10 +87,19 @@ enum {
  * Not all registers will exist on all parts.
  */
 enum {
-        SCSMR, SCBRR, SCSCR, SCxSR,
-        SCFCR, SCFDR, SCxTDR, SCxRDR,
-        SCLSR, SCTFDR, SCRFDR, SCSPTR,
-        HSSRR,
+        SCSMR,                          /* Serial Mode Register */
+        SCBRR,                          /* Bit Rate Register */
+        SCSCR,                          /* Serial Control Register */
+        SCxSR,                          /* Serial Status Register */
+        SCFCR,                          /* FIFO Control Register */
+        SCFDR,                          /* FIFO Data Count Register */
+        SCxTDR,                         /* Transmit (FIFO) Data Register */
+        SCxRDR,                         /* Receive (FIFO) Data Register */
+        SCLSR,                          /* Line Status Register */
+        SCTFDR,                         /* Transmit FIFO Data Count Register */
+        SCRFDR,                         /* Receive FIFO Data Count Register */
+        SCSPTR,                         /* Serial Port Register */
+        HSSRR,                          /* Sampling Rate Register */
 
         SCIx_NR_REGS,
 };
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index f589c9af8cbf..15ede6a823a6 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -2451,8 +2451,8 @@ int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
                     unsigned int flags);
 void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
 unsigned int skb_zerocopy_headlen(const struct sk_buff *from);
-void skb_zerocopy(struct sk_buff *to, const struct sk_buff *from,
-                  int len, int hlen);
+int skb_zerocopy(struct sk_buff *to, struct sk_buff *from,
+                 int len, int hlen);
 void skb_split(struct sk_buff *skb, struct sk_buff *skb1, const u32 len);
 int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen);
 void skb_scrub_packet(struct sk_buff *skb, bool xnet);
@@ -2725,7 +2725,7 @@ static inline void nf_reset(struct sk_buff *skb)
 
 static inline void nf_reset_trace(struct sk_buff *skb)
 {
-#if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE)
+#if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) || defined(CONFIG_NF_TABLES)
         skb->nf_trace = 0;
 #endif
 }
@@ -2742,6 +2742,9 @@ static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
         dst->nf_bridge  = src->nf_bridge;
         nf_bridge_get(src->nf_bridge);
 #endif
+#if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE) || defined(CONFIG_NF_TABLES)
+        dst->nf_trace = src->nf_trace;
+#endif
 }
 
 static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
@@ -2916,5 +2919,22 @@ static inline bool skb_head_is_locked(const struct sk_buff *skb)
 {
         return !skb->head_frag || skb_cloned(skb);
 }
+
+/**
+ * skb_gso_network_seglen - Return length of individual segments of a gso packet
+ *
+ * @skb: GSO skb
+ *
+ * skb_gso_network_seglen is used to determine the real size of the
+ * individual segments, including Layer3 (IP, IPv6) and L4 headers (TCP/UDP).
+ *
+ * The MAC/L2 header is not accounted for.
+ */
+static inline unsigned int skb_gso_network_seglen(const struct sk_buff *skb)
+{
+        unsigned int hdr_len = skb_transport_header(skb) -
+                               skb_network_header(skb);
+        return hdr_len + skb_gso_transport_seglen(skb);
+}
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_SKBUFF_H */
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 9260abdd67df..b5b2df60299e 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -410,7 +410,7 @@ static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
  *
  * %GFP_NOWAIT - Allocation will not sleep.
  *
- * %GFP_THISNODE - Allocate node-local memory only.
+ * %__GFP_THISNODE - Allocate node-local memory only.
  *
  * %GFP_DMA - Allocation suitable for DMA.
  *   Should only be used for kmalloc() caches. Otherwise, use a
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 6ae004e437ea..633f5edd7470 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -17,10 +17,7 @@ extern void cpu_idle(void);
 
 typedef void (*smp_call_func_t)(void *info);
 struct call_single_data {
-        union {
-                struct list_head list;
-                struct llist_node llist;
-        };
+        struct llist_node llist;
         smp_call_func_t func;
         void *info;
         u16 flags;
@@ -53,8 +50,7 @@ void on_each_cpu_cond(bool (*cond_func)(int cpu, void *info),
                 smp_call_func_t func, void *info, bool wait,
                 gfp_t gfp_flags);
 
-void __smp_call_function_single(int cpuid, struct call_single_data *data,
-                                int wait);
+int smp_call_function_single_async(int cpu, struct call_single_data *csd);
 
 #ifdef CONFIG_SMP
 
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 4203c66d8803..36c86ef51ff3 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -24,6 +24,9 @@
 #include <linux/slab.h>
 #include <linux/kthread.h>
 #include <linux/completion.h>
+#include <linux/scatterlist.h>
+
+struct dma_chan;
 
 /*
  * INTERFACES between SPI master-side drivers and SPI infrastructure.
@@ -266,6 +269,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * @auto_runtime_pm: the core should ensure a runtime PM reference is held
  *                   while the hardware is prepared, using the parent
  *                   device for the spidev
+ * @max_dma_len: Maximum length of a DMA transfer for the device.
  * @prepare_transfer_hardware: a message will soon arrive from the queue
  *      so the subsystem requests the driver to prepare the transfer hardware
  *      by issuing this call
@@ -348,6 +352,8 @@ struct spi_master {
 #define SPI_MASTER_HALF_DUPLEX  BIT(0)          /* can't do full duplex */
 #define SPI_MASTER_NO_RX        BIT(1)          /* can't do buffer read */
 #define SPI_MASTER_NO_TX        BIT(2)          /* can't do buffer write */
+#define SPI_MASTER_MUST_RX      BIT(3)          /* requires rx */
+#define SPI_MASTER_MUST_TX      BIT(4)          /* requires tx */
 
         /* lock and mutex for SPI bus locking */
         spinlock_t              bus_lock_spinlock;
@@ -390,6 +396,17 @@ struct spi_master {
         void                    (*cleanup)(struct spi_device *spi);
 
         /*
+         * Used to enable core support for DMA handling, if can_dma()
+         * exists and returns true then the transfer will be mapped
+         * prior to transfer_one() being called.  The driver should
+         * not modify or store xfer and dma_tx and dma_rx must be set
+         * while the device is prepared.
+         */
+        bool                    (*can_dma)(struct spi_master *master,
+                                           struct spi_device *spi,
+                                           struct spi_transfer *xfer);
+
+        /*
          * These hooks are for drivers that want to use the generic
          * master transfer queueing mechanism. If these are used, the
          * transfer() function above must NOT be specified by the driver.
@@ -407,7 +424,9 @@ struct spi_master {
         bool                            rt;
         bool                            auto_runtime_pm;
         bool                            cur_msg_prepared;
+        bool                            cur_msg_mapped;
         struct completion               xfer_completion;
+        size_t                          max_dma_len;
 
         int (*prepare_transfer_hardware)(struct spi_master *master);
         int (*transfer_one_message)(struct spi_master *master,
@@ -428,6 +447,14 @@ struct spi_master {
 
         /* gpio chip select */
         int                     *cs_gpios;
+
+        /* DMA channels for use with core dmaengine helpers */
+        struct dma_chan         *dma_tx;
+        struct dma_chan         *dma_rx;
+
+        /* dummy data for full duplex devices */
+        void                    *dummy_rx;
+        void                    *dummy_tx;
 };
 
 static inline void *spi_master_get_devdata(struct spi_master *master)
@@ -512,6 +539,8 @@ extern struct spi_master *spi_busnum_to_master(u16 busnum);
  *      (optionally) changing the chipselect status, then starting
  *      the next transfer or completing this @spi_message.
  * @transfer_list: transfers are sequenced through @spi_message.transfers
+ * @tx_sg: Scatterlist for transmit, currently not for client use
+ * @rx_sg: Scatterlist for receive, currently not for client use
  *
  * SPI transfers always write the same number of bytes as they read.
  * Protocol drivers should always provide @rx_buf and/or @tx_buf.
@@ -579,6 +608,8 @@ struct spi_transfer {
 
         dma_addr_t      tx_dma;
         dma_addr_t      rx_dma;
+        struct sg_table tx_sg;
+        struct sg_table rx_sg;
 
         unsigned        cs_change:1;
         unsigned        tx_nbits:3;
diff --git a/include/linux/spi/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
index daebaba886aa..85578d4be034 100644
--- a/include/linux/spi/spi_bitbang.h
+++ b/include/linux/spi/spi_bitbang.h
@@ -42,6 +42,6 @@ extern int spi_bitbang_setup_transfer(struct spi_device *spi,
 
 /* start or stop queue processing */
 extern int spi_bitbang_start(struct spi_bitbang *spi);
-extern int spi_bitbang_stop(struct spi_bitbang *spi);
+extern void spi_bitbang_stop(struct spi_bitbang *spi);
 
 #endif  /* __SPI_BITBANG_H */
diff --git a/include/linux/spmi.h b/include/linux/spmi.h
new file mode 100644
index 000000000000..91f5eab9e428
--- /dev/null
+++ b/include/linux/spmi.h
@@ -0,0 +1,191 @@
+/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef _LINUX_SPMI_H
+#define _LINUX_SPMI_H
+
+#include <linux/types.h>
+#include <linux/device.h>
+#include <linux/mod_devicetable.h>
+
+/* Maximum slave identifier */
+#define SPMI_MAX_SLAVE_ID               16
+
+/* SPMI Commands */
+#define SPMI_CMD_EXT_WRITE              0x00
+#define SPMI_CMD_RESET                  0x10
+#define SPMI_CMD_SLEEP                  0x11
+#define SPMI_CMD_SHUTDOWN               0x12
+#define SPMI_CMD_WAKEUP                 0x13
+#define SPMI_CMD_AUTHENTICATE           0x14
+#define SPMI_CMD_MSTR_READ              0x15
+#define SPMI_CMD_MSTR_WRITE             0x16
+#define SPMI_CMD_TRANSFER_BUS_OWNERSHIP 0x1A
+#define SPMI_CMD_DDB_MASTER_READ        0x1B
+#define SPMI_CMD_DDB_SLAVE_READ         0x1C
+#define SPMI_CMD_EXT_READ               0x20
+#define SPMI_CMD_EXT_WRITEL             0x30
+#define SPMI_CMD_EXT_READL              0x38
+#define SPMI_CMD_WRITE                  0x40
+#define SPMI_CMD_READ                   0x60
+#define SPMI_CMD_ZERO_WRITE             0x80
+
+/**
+ * struct spmi_device - Basic representation of an SPMI device
+ * @dev:        Driver model representation of the device.
+ * @ctrl:       SPMI controller managing the bus hosting this device.
+ * @usid:       This devices' Unique Slave IDentifier.
+ */
+struct spmi_device {
+        struct device           dev;
+        struct spmi_controller  *ctrl;
+        u8                      usid;
+};
+
+static inline struct spmi_device *to_spmi_device(struct device *d)
+{
+        return container_of(d, struct spmi_device, dev);
+}
+
+static inline void *spmi_device_get_drvdata(const struct spmi_device *sdev)
+{
+        return dev_get_drvdata(&sdev->dev);
+}
+
+static inline void spmi_device_set_drvdata(struct spmi_device *sdev, void *data)
+{
+        dev_set_drvdata(&sdev->dev, data);
+}
+
+struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl);
+
+static inline void spmi_device_put(struct spmi_device *sdev)
+{
+        if (sdev)
+                put_device(&sdev->dev);
+}
+
+int spmi_device_add(struct spmi_device *sdev);
+
+void spmi_device_remove(struct spmi_device *sdev);
+
+/**
+ * struct spmi_controller - interface to the SPMI master controller
+ * @dev:        Driver model representation of the device.
+ * @nr:         board-specific number identifier for this controller/bus
+ * @cmd:        sends a non-data command sequence on the SPMI bus.
+ * @read_cmd:   sends a register read command sequence on the SPMI bus.
+ * @write_cmd:  sends a register write command sequence on the SPMI bus.
+ */
+struct spmi_controller {
+        struct device           dev;
+        unsigned int            nr;
+        int     (*cmd)(struct spmi_controller *ctrl, u8 opcode, u8 sid);
+        int     (*read_cmd)(struct spmi_controller *ctrl, u8 opcode,
+                            u8 sid, u16 addr, u8 *buf, size_t len);
+        int     (*write_cmd)(struct spmi_controller *ctrl, u8 opcode,
+                             u8 sid, u16 addr, const u8 *buf, size_t len);
+};
+
+static inline struct spmi_controller *to_spmi_controller(struct device *d)
+{
+        return container_of(d, struct spmi_controller, dev);
+}
+
+static inline
+void *spmi_controller_get_drvdata(const struct spmi_controller *ctrl)
+{
+        return dev_get_drvdata(&ctrl->dev);
+}
+
+static inline void spmi_controller_set_drvdata(struct spmi_controller *ctrl,
+                                               void *data)
+{
+        dev_set_drvdata(&ctrl->dev, data);
+}
+
+struct spmi_controller *spmi_controller_alloc(struct device *parent,
+                                              size_t size);
+
+/**
+ * spmi_controller_put() - decrement controller refcount
+ * @ctrl        SPMI controller.
+ */
+static inline void spmi_controller_put(struct spmi_controller *ctrl)
+{
+        if (ctrl)
+                put_device(&ctrl->dev);
+}
+
+int spmi_controller_add(struct spmi_controller *ctrl);
+void spmi_controller_remove(struct spmi_controller *ctrl);
+
+/**
+ * struct spmi_driver - SPMI slave device driver
+ * @driver:     SPMI device drivers should initialize name and owner field of
+ *              this structure.
+ * @probe:      binds this driver to a SPMI device.
+ * @remove:     unbinds this driver from the SPMI device.
+ * @shutdown:   standard shutdown callback used during powerdown/halt.
+ * @suspend:    standard suspend callback used during system suspend.
+ * @resume:     standard resume callback used during system resume.
+ *
+ * If PM runtime support is desired for a slave, a device driver can call
+ * pm_runtime_put() from their probe() routine (and a balancing
+ * pm_runtime_get() in remove()).  PM runtime support for a slave is
+ * implemented by issuing a SLEEP command to the slave on runtime_suspend(),
+ * transitioning the slave into the SLEEP state.  On runtime_resume(), a WAKEUP
+ * command is sent to the slave to bring it back to ACTIVE.
+ */
+struct spmi_driver {
+        struct device_driver driver;
+        int     (*probe)(struct spmi_device *sdev);
+        void    (*remove)(struct spmi_device *sdev);
+};
+
+static inline struct spmi_driver *to_spmi_driver(struct device_driver *d)
+{
+        return container_of(d, struct spmi_driver, driver);
+}
+
+int spmi_driver_register(struct spmi_driver *sdrv);
+
+/**
+ * spmi_driver_unregister() - unregister an SPMI client driver
+ * @sdrv:       the driver to unregister
+ */
+static inline void spmi_driver_unregister(struct spmi_driver *sdrv)
+{
+        if (sdrv)
+                driver_unregister(&sdrv->driver);
+}
+
+#define module_spmi_driver(__spmi_driver) \
+        module_driver(__spmi_driver, spmi_driver_register, \
+                        spmi_driver_unregister)
+
+int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf);
+int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf,
+                           size_t len);
+int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf,
+                            size_t len);
+int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data);
+int spmi_register_zero_write(struct spmi_device *sdev, u8 data);
+int spmi_ext_register_write(struct spmi_device *sdev, u8 addr,
+                            const u8 *buf, size_t len);
+int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr,
+                             const u8 *buf, size_t len);
+int spmi_command_reset(struct spmi_device *sdev);
+int spmi_command_sleep(struct spmi_device *sdev);
+int spmi_command_wakeup(struct spmi_device *sdev);
+int spmi_command_shutdown(struct spmi_device *sdev);
+
+#endif
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 9b058eecd403..a2783cb5d275 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -12,8 +12,8 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * along with this program; if not, you can access it online at
+ * http://www.gnu.org/licenses/gpl-2.0.html.
  *
  * Copyright (C) IBM Corporation, 2006
  * Copyright (C) Fujitsu, 2012
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 40ed9e9a77e5..1e67b7a5968c 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -98,6 +98,8 @@ struct sigaltstack;
 #define __MAP(n,...) __MAP##n(__VA_ARGS__)
 
 #define __SC_DECL(t, a) t a
+#define __TYPE_IS_L(t)  (__same_type((t)0, 0L))
+#define __TYPE_IS_UL(t) (__same_type((t)0, 0UL))
 #define __TYPE_IS_LL(t) (__same_type((t)0, 0LL) || __same_type((t)0, 0ULL))
 #define __SC_LONG(t, a) __typeof(__builtin_choose_expr(__TYPE_IS_LL(t), 0LL, 0L)) a
 #define __SC_CAST(t, a) (t) a
@@ -281,13 +283,15 @@ asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,
 asmlinkage long sys_sched_setparam(pid_t pid,
                                         struct sched_param __user *param);
 asmlinkage long sys_sched_setattr(pid_t pid,
-                                        struct sched_attr __user *attr);
+                                        struct sched_attr __user *attr,
+                                        unsigned int flags);
 asmlinkage long sys_sched_getscheduler(pid_t pid);
 asmlinkage long sys_sched_getparam(pid_t pid,
                                         struct sched_param __user *param);
 asmlinkage long sys_sched_getattr(pid_t pid,
                                         struct sched_attr __user *attr,
-                                        unsigned int size);
+                                        unsigned int size,
+                                        unsigned int flags);
 asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
                                         unsigned long __user *user_mask_ptr);
 asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 30b2ebee6439..e0bf210ddffd 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -198,6 +198,7 @@ int __must_check sysfs_chmod_file(struct kobject *kobj,
                                   const struct attribute *attr, umode_t mode);
 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
                           const void *ns);
+bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr);
 void sysfs_remove_files(struct kobject *kobj, const struct attribute **attr);
 
 int __must_check sysfs_create_bin_file(struct kobject *kobj,
@@ -246,6 +247,11 @@ void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr);
 
 int __must_check sysfs_init(void);
 
+static inline void sysfs_enable_ns(struct kernfs_node *kn)
+{
+        return kernfs_enable_ns(kn);
+}
+
 #else /* CONFIG_SYSFS */
 
 static inline int sysfs_schedule_callback(struct kobject *kobj,
@@ -301,6 +307,12 @@ static inline void sysfs_remove_file_ns(struct kobject *kobj,
 {
 }
 
+static inline bool sysfs_remove_file_self(struct kobject *kobj,
+                                          const struct attribute *attr)
+{
+        return false;
+}
+
 static inline void sysfs_remove_files(struct kobject *kobj,
                                      const struct attribute **attr)
 {
@@ -418,6 +430,10 @@ static inline int __must_check sysfs_init(void)
         return 0;
 }
 
+static inline void sysfs_enable_ns(struct kernfs_node *kn)
+{
+}
+
 #endif /* CONFIG_SYSFS */
 
 static inline int __must_check sysfs_create_file(struct kobject *kobj,
diff --git a/include/linux/torture.h b/include/linux/torture.h
new file mode 100644
index 000000000000..b2e2b468e511
--- /dev/null
+++ b/include/linux/torture.h
@@ -0,0 +1,100 @@
+/*
+ * Common functions for in-kernel torture tests.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you can access it online at
+ * http://www.gnu.org/licenses/gpl-2.0.html.
+ *
+ * Copyright IBM Corporation, 2014
+ *
+ * Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
+ */
+
+#ifndef __LINUX_TORTURE_H
+#define __LINUX_TORTURE_H
+
+#include <linux/types.h>
+#include <linux/cache.h>
+#include <linux/spinlock.h>
+#include <linux/threads.h>
+#include <linux/cpumask.h>
+#include <linux/seqlock.h>
+#include <linux/lockdep.h>
+#include <linux/completion.h>
+#include <linux/debugobjects.h>
+#include <linux/bug.h>
+#include <linux/compiler.h>
+
+/* Definitions for a non-string torture-test module parameter. */
+#define torture_param(type, name, init, msg) \
+        static type name = init; \
+        module_param(name, type, 0444); \
+        MODULE_PARM_DESC(name, msg);
+
+#define TORTURE_FLAG "-torture:"
+#define TOROUT_STRING(s) \
+        pr_alert("%s" TORTURE_FLAG s "\n", torture_type)
+#define VERBOSE_TOROUT_STRING(s) \
+        do { if (verbose) pr_alert("%s" TORTURE_FLAG " %s\n", torture_type, s); } while (0)
+#define VERBOSE_TOROUT_ERRSTRING(s) \
+        do { if (verbose) pr_alert("%s" TORTURE_FLAG "!!! %s\n", torture_type, s); } while (0)
+
+/* Definitions for a non-string torture-test module parameter. */
+#define torture_parm(type, name, init, msg) \
+        static type name = init; \
+        module_param(name, type, 0444); \
+        MODULE_PARM_DESC(name, msg);
+
+/* Definitions for online/offline exerciser. */
+int torture_onoff_init(long ooholdoff, long oointerval);
+char *torture_onoff_stats(char *page);
+bool torture_onoff_failures(void);
+
+/* Low-rider random number generator. */
+struct torture_random_state {
+        unsigned long trs_state;
+        long trs_count;
+};
+#define DEFINE_TORTURE_RANDOM(name) struct torture_random_state name = { 0, 0 }
+unsigned long torture_random(struct torture_random_state *trsp);
+
+/* Task shuffler, which causes CPUs to occasionally go idle. */
+void torture_shuffle_task_register(struct task_struct *tp);
+int torture_shuffle_init(long shuffint);
+
+/* Test auto-shutdown handling. */
+void torture_shutdown_absorb(const char *title);
+int torture_shutdown_init(int ssecs, void (*cleanup)(void));
+
+/* Task stuttering, which forces load/no-load transitions. */
+void stutter_wait(const char *title);
+int torture_stutter_init(int s);
+
+/* Initialization and cleanup. */
+void torture_init_begin(char *ttype, bool v, int *runnable);
+void torture_init_end(void);
+bool torture_cleanup(void);
+bool torture_must_stop(void);
+bool torture_must_stop_irq(void);
+void torture_kthread_stopping(char *title);
+int _torture_create_kthread(int (*fn)(void *arg), void *arg, char *s, char *m,
+                             char *f, struct task_struct **tp);
+void _torture_stop_kthread(char *m, struct task_struct **tp);
+
+#define torture_create_kthread(n, arg, tp) \
+        _torture_create_kthread(n, (arg), #n, "Creating " #n " task", \
+                                "Failed to create " #n, &(tp))
+#define torture_stop_kthread(n, tp) \
+        _torture_stop_kthread("Stopping " #n " task", &(tp))
+
+#endif /* __LINUX_TORTURE_H */
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index accc497f8d72..7159a0a933df 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -60,6 +60,12 @@ struct tp_module {
         unsigned int num_tracepoints;
         struct tracepoint * const *tracepoints_ptrs;
 };
+bool trace_module_has_bad_taint(struct module *mod);
+#else
+static inline bool trace_module_has_bad_taint(struct module *mod)
+{
+        return false;
+}
 #endif /* CONFIG_MODULES */
 
 struct tracepoint_iter {
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 90b4fdc8a61f..b90b5c221ff0 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -208,7 +208,7 @@ struct tty_port {
         wait_queue_head_t       delta_msr_wait; /* Modem status change */
         unsigned long           flags;          /* TTY flags ASY_*/
         unsigned char           console:1,      /* port is a console */
-                                low_latency:1;  /* direct buffer flush */
+                                low_latency:1;  /* optional: tune for latency */
         struct mutex            mutex;          /* Locking */
         struct mutex            buf_mutex;      /* Buffer alloc lock */
         unsigned char           *xmit_buf;      /* Optional buffer */
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index b8347c207cb8..add26da2faeb 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -126,7 +126,6 @@
 
 #include <linux/fs.h>
 #include <linux/wait.h>
-#include <linux/wait.h>
 
 
 /*
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 7f6eb859873e..6b7ec376fb4d 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -57,6 +57,7 @@ struct ep_device;
  * @extra: descriptors following this endpoint in the configuration
  * @extralen: how many bytes of "extra" are valid
  * @enabled: URBs may be submitted to this endpoint
+ * @streams: number of USB-3 streams allocated on the endpoint
  *
  * USB requests are always queued to a given endpoint, identified by a
  * descriptor within an active interface in a given USB configuration.
@@ -71,6 +72,7 @@ struct usb_host_endpoint {
         unsigned char *extra;   /* Extra descriptors */
         int extralen;
         int enabled;
+        int streams;
 };
 
 /* host-side wrapper for one interface setting's parsed descriptors */
@@ -202,6 +204,8 @@ static inline void usb_set_intfdata(struct usb_interface *intf, void *data)
 struct usb_interface *usb_get_intf(struct usb_interface *intf);
 void usb_put_intf(struct usb_interface *intf);
 
+/* Hard limit */
+#define USB_MAXENDPOINTS        30
 /* this maximum is arbitrary */
 #define USB_MAXINTERFACES       32
 #define USB_MAXIADS             (USB_MAXINTERFACES/2)
@@ -366,6 +370,8 @@ struct usb_bus {
 #endif
 };
 
+struct usb_dev_state;
+
 /* ----------------------------------------------------------------------- */
 
 struct usb_tt;
@@ -749,6 +755,11 @@ extern struct usb_host_interface *usb_find_alt_setting(
                 unsigned int iface_num,
                 unsigned int alt_num);
 
+/* port claiming functions */
+int usb_hub_claim_port(struct usb_device *hdev, unsigned port1,
+                struct usb_dev_state *owner);
+int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
+                struct usb_dev_state *owner);
 
 /**
  * usb_make_path - returns stable device path in the usb tree
@@ -1666,6 +1677,10 @@ extern void usb_reset_endpoint(struct usb_device *dev, unsigned int epaddr);
 /* this request isn't really synchronous, but it belongs with the others */
 extern int usb_driver_set_configuration(struct usb_device *udev, int config);
 
+/* choose and set configuration for device */
+extern int usb_choose_configuration(struct usb_device *udev);
+extern int usb_set_configuration(struct usb_device *dev, int configuration);
+
 /*
  * timeouts, in milliseconds, used for sending/receiving control messages
  * they typically complete within a few frames (msec) after they're issued
diff --git a/include/linux/usb/cdc_ncm.h b/include/linux/usb/cdc_ncm.h
index c3fa80745996..2c14d9cdd57a 100644
--- a/include/linux/usb/cdc_ncm.h
+++ b/include/linux/usb/cdc_ncm.h
@@ -88,6 +88,7 @@
 #define cdc_ncm_data_intf_is_mbim(x)  ((x)->desc.bInterfaceProtocol == USB_CDC_MBIM_PROTO_NTB)
 
 struct cdc_ncm_ctx {
+        struct usb_cdc_ncm_ntb_parameters ncm_parm;
         struct hrtimer tx_timer;
         struct tasklet_struct bh;
 
diff --git a/include/linux/usb/chipidea.h b/include/linux/usb/chipidea.h
index 708bd119627f..bbe779f640be 100644
--- a/include/linux/usb/chipidea.h
+++ b/include/linux/usb/chipidea.h
@@ -25,6 +25,7 @@ struct ci_hdrc_platform_data {
          */
 #define CI_HDRC_DUAL_ROLE_NOT_OTG       BIT(4)
 #define CI_HDRC_IMX28_WRITE_FIX         BIT(5)
+#define CI_HDRC_FORCE_FULLSPEED         BIT(6)
         enum usb_dr_mode        dr_mode;
 #define CI_HDRC_CONTROLLER_RESET_EVENT          0
 #define CI_HDRC_CONTROLLER_STOPPED_EVENT        1
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index efe8d8a7c7ad..485cd5e2100c 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -143,6 +143,7 @@ struct usb_hcd {
         unsigned                authorized_default:1;
         unsigned                has_tt:1;       /* Integrated TT in root hub */
         unsigned                amd_resume_bug:1; /* AMD remote wakeup quirk */
+        unsigned                can_do_streams:1; /* HC supports streams */
 
         unsigned int            irq;            /* irq allocated */
         void __iomem            *regs;          /* device memory/io */
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index 6c0b1c513db7..353053a33f21 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -111,6 +111,13 @@ struct usb_phy {
         int     (*set_suspend)(struct usb_phy *x,
                                 int suspend);
 
+        /*
+         * Set wakeup enable for PHY, in that case, the PHY can be
+         * woken up from suspend status due to external events,
+         * like vbus change, dp/dm change and id.
+         */
+        int     (*set_wakeup)(struct usb_phy *x, bool enabled);
+
         /* notify phy connect status change */
         int     (*notify_connect)(struct usb_phy *x,
                         enum usb_device_speed speed);
@@ -265,6 +272,15 @@ usb_phy_set_suspend(struct usb_phy *x, int suspend)
 }
 
 static inline int
+usb_phy_set_wakeup(struct usb_phy *x, bool enabled)
+{
+        if (x && x->set_wakeup)
+                return x->set_wakeup(x, enabled);
+        else
+                return 0;
+}
+
+static inline int
 usb_phy_notify_connect(struct usb_phy *x, enum usb_device_speed speed)
 {
         if (x && x->notify_connect)
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 704a1ab8240c..9bb547c7bce7 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -190,7 +190,8 @@ static inline void usb_set_serial_data(struct usb_serial *serial, void *data)
  * @num_ports: the number of different ports this device will have.
  * @bulk_in_size: minimum number of bytes to allocate for bulk-in buffer
  *      (0 = end-point size)
- * @bulk_out_size: bytes to allocate for bulk-out buffer (0 = end-point size)
+ * @bulk_out_size: minimum number of bytes to allocate for bulk-out buffer
+ *      (0 = end-point size)
  * @calc_num_ports: pointer to a function to determine how many ports this
  *      device has dynamically.  It will be called after the probe()
  *      callback is called, but before attach()
diff --git a/include/linux/usb/uas.h b/include/linux/usb/uas.h
index 5499ab5c94bd..3fc8e8b9f043 100644
--- a/include/linux/usb/uas.h
+++ b/include/linux/usb/uas.h
@@ -9,7 +9,7 @@ struct iu {
         __u8 iu_id;
         __u8 rsvd1;
         __be16 tag;
-};
+} __attribute__((__packed__));
 
 enum {
         IU_ID_COMMAND           = 0x01,
@@ -52,7 +52,7 @@ struct command_iu {
         __u8 rsvd7;
         struct scsi_lun lun;
         __u8 cdb[16];   /* XXX: Overflow-checking tools may misunderstand */
-};
+} __attribute__((__packed__));
 
 struct task_mgmt_iu {
         __u8 iu_id;
@@ -62,7 +62,7 @@ struct task_mgmt_iu {
         __u8 rsvd2;
         __be16 task_tag;
         struct scsi_lun lun;
-};
+} __attribute__((__packed__));
 
 /*
  * Also used for the Read Ready and Write Ready IUs since they have the
@@ -77,15 +77,15 @@ struct sense_iu {
         __u8 rsvd7[7];
         __be16 len;
         __u8 sense[SCSI_SENSE_BUFFERSIZE];
-};
+} __attribute__((__packed__));
 
-struct response_ui {
+struct response_iu {
         __u8 iu_id;
         __u8 rsvd1;
         __be16 tag;
-        __be16 add_response_info;
+        __u8 add_response_info[3];
         __u8 response_code;
-};
+} __attribute__((__packed__));
 
 struct usb_pipe_usage_descriptor {
         __u8  bLength;
diff --git a/include/linux/usb/usbnet.h b/include/linux/usb/usbnet.h
index e303eef94dd5..0662e98fef72 100644
--- a/include/linux/usb/usbnet.h
+++ b/include/linux/usb/usbnet.h
@@ -30,7 +30,7 @@ struct usbnet {
         struct driver_info      *driver_info;
         const char              *driver_name;
         void                    *driver_priv;
-        wait_queue_head_t       *wait;
+        wait_queue_head_t       wait;
         struct mutex            phy_mutex;
         unsigned char           suspend_count;
         unsigned char           pkt_cnt, pkt_err;
diff --git a/include/linux/usb_usual.h b/include/linux/usb_usual.h
index 630356866030..1a64b26046ed 100644
--- a/include/linux/usb_usual.h
+++ b/include/linux/usb_usual.h
@@ -67,8 +67,10 @@
                 /* Initial READ(10) (and others) must be retried */     \
         US_FLAG(WRITE_CACHE,    0x00200000)                     \
                 /* Write Cache status is not available */       \
-        US_FLAG(NEEDS_CAP16,    0x00400000)
-                /* cannot handle READ_CAPACITY_10 */
+        US_FLAG(NEEDS_CAP16,    0x00400000)                     \
+                /* cannot handle READ_CAPACITY_10 */            \
+        US_FLAG(IGNORE_UAS,     0x00800000)                     \
+                /* Device advertises UAS but it is broken */
 
 #define US_FLAG(name, value)    US_FL_##name = value ,
 enum { US_DO_ALL_FLAGS };
diff --git a/include/linux/video_output.h b/include/linux/video_output.h
deleted file mode 100644
index ed5cdeb3604d..000000000000
--- a/include/linux/video_output.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- *
- *  Copyright (C) 2006 Luming Yu <luming.yu@intel.com>
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or (at
- *  your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful, but
- *  WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-#ifndef _LINUX_VIDEO_OUTPUT_H
-#define _LINUX_VIDEO_OUTPUT_H
-#include <linux/device.h>
-#include <linux/err.h>
-struct output_device;
-struct output_properties {
-        int (*set_state)(struct output_device *);
-        int (*get_status)(struct output_device *);
-};
-struct output_device {
-        int request_state;
-        struct output_properties *props;
-        struct device dev;
-};
-#define to_output_device(obj) container_of(obj, struct output_device, dev)
-#if     defined(CONFIG_VIDEO_OUTPUT_CONTROL) || defined(CONFIG_VIDEO_OUTPUT_CONTROL_MODULE)
-struct output_device *video_output_register(const char *name,
-        struct device *dev,
-        void *devdata,
-        struct output_properties *op);
-void video_output_unregister(struct output_device *dev);
-#else
-static struct output_device *video_output_register(const char *name,
-        struct device *dev,
-        void *devdata,
-        struct output_properties *op)
-{
-        return ERR_PTR(-ENODEV);
-}
-static void video_output_unregister(struct output_device *dev)
-{
-        return;
-}
-#endif
-#endif
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 594521ba0d43..1b22c42e9c2d 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -177,20 +177,10 @@ struct execute_work {
 #define DECLARE_DEFERRABLE_WORK(n, f)                                   \
         struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE)
 
-/*
- * initialize a work item's function pointer
- */
-#define PREPARE_WORK(_work, _func)                                      \
-        do {                                                            \
-                (_work)->func = (_func);                                \
-        } while (0)
-
-#define PREPARE_DELAYED_WORK(_work, _func)                              \
-        PREPARE_WORK(&(_work)->work, (_func))
-
 #ifdef CONFIG_DEBUG_OBJECTS_WORK
 extern void __init_work(struct work_struct *work, int onstack);
 extern void destroy_work_on_stack(struct work_struct *work);
+extern void destroy_delayed_work_on_stack(struct delayed_work *work);
 static inline unsigned int work_static(struct work_struct *work)
 {
         return *work_data_bits(work) & WORK_STRUCT_STATIC;
@@ -198,6 +188,7 @@ static inline unsigned int work_static(struct work_struct *work)
 #else
 static inline void __init_work(struct work_struct *work, int onstack) { }
 static inline void destroy_work_on_stack(struct work_struct *work) { }
+static inline void destroy_delayed_work_on_stack(struct delayed_work *work) { }
 static inline unsigned int work_static(struct work_struct *work) { return 0; }
 #endif
 
@@ -217,7 +208,7 @@ static inline unsigned int work_static(struct work_struct *work) { return 0; }
                 (_work)->data = (atomic_long_t) WORK_DATA_INIT();       \
                 lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0); \
                 INIT_LIST_HEAD(&(_work)->entry);                        \
-                PREPARE_WORK((_work), (_func));                         \
+                (_work)->func = (_func);                                \
         } while (0)
 #else
 #define __INIT_WORK(_work, _func, _onstack)                             \
@@ -225,7 +216,7 @@ static inline unsigned int work_static(struct work_struct *work) { return 0; }
                 __init_work((_work), _onstack);                         \
                 (_work)->data = (atomic_long_t) WORK_DATA_INIT();       \
                 INIT_LIST_HEAD(&(_work)->entry);                        \
-                PREPARE_WORK((_work), (_func));                         \
+                (_work)->func = (_func);                                \
         } while (0)
 #endif
 
@@ -295,17 +286,11 @@ static inline unsigned int work_static(struct work_struct *work) { return 0; }
  * Documentation/workqueue.txt.
  */
 enum {
-        /*
-         * All wqs are now non-reentrant making the following flag
-         * meaningless.  Will be removed.
-         */
-        WQ_NON_REENTRANT        = 1 << 0, /* DEPRECATED */
-
         WQ_UNBOUND              = 1 << 1, /* not bound to any cpu */
         WQ_FREEZABLE            = 1 << 2, /* freeze during suspend */
         WQ_MEM_RECLAIM          = 1 << 3, /* may be used for memory reclaim */
         WQ_HIGHPRI              = 1 << 4, /* high priority */
-        WQ_CPU_INTENSIVE        = 1 << 5, /* cpu instensive workqueue */
+        WQ_CPU_INTENSIVE        = 1 << 5, /* cpu intensive workqueue */
         WQ_SYSFS                = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */
 
         /*
@@ -419,10 +404,7 @@ __alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active,
         static struct lock_class_key __key;                             \
         const char *__lock_name;                                        \
                                                                         \
-        if (__builtin_constant_p(fmt))                                  \
-                __lock_name = (fmt);                                    \
-        else                                                            \
-                __lock_name = #fmt;                                     \
+        __lock_name = #fmt#args;                                        \
                                                                         \
         __alloc_workqueue_key((fmt), (flags), (max_active),             \
                               &__key, __lock_name, ##args);             \
@@ -605,21 +587,6 @@ static inline bool keventd_up(void)
         return system_wq != NULL;
 }
 
-/*
- * Like above, but uses del_timer() instead of del_timer_sync(). This means,
- * if it returns 0 the timer function may be running and the queueing is in
- * progress.
- */
-static inline bool __deprecated __cancel_delayed_work(struct delayed_work *work)
-{
-        bool ret;
-
-        ret = del_timer(&work->timer);
-        if (ret)
-                work_clear_pending(&work->work);
-        return ret;
-}
-
 /* used to be different but now identical to flush_work(), deprecated */
 static inline bool __deprecated flush_work_sync(struct work_struct *work)
 {
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index fc0e4320aa6d..021b8a319b9e 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -97,7 +97,7 @@ void writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
 int try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason);
 int try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
                                   enum wb_reason reason);
-void sync_inodes_sb(struct super_block *sb, unsigned long older_than_this);
+void sync_inodes_sb(struct super_block *);
 void wakeup_flusher_threads(long nr_pages, enum wb_reason reason);
 void inode_wait_for_writeback(struct inode *inode);