Merge tag 'v3.19-rc4' into next

Merge with mainline to bring in the latest thermal and other changes.

454 files changed, 13185 insertions, 5123 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 807cbc46d73e..d459cd17b477 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -28,6 +28,7 @@
 #include <linux/errno.h>
 #include <linux/ioport.h>       /* for struct resource */
 #include <linux/device.h>
+#include <linux/property.h>
 
 #ifndef _LINUX
 #define _LINUX
@@ -123,6 +124,10 @@ int acpi_numa_init (void);
 
 int acpi_table_init (void);
 int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
+int __init acpi_parse_entries(char *id, unsigned long table_size,
+                              acpi_tbl_entry_handler handler,
+                              struct acpi_table_header *table_header,
+                              int entry_id, unsigned int max_entries);
 int __init acpi_table_parse_entries(char *id, unsigned long table_size,
                                     int entry_id,
                                     acpi_tbl_entry_handler handler,
@@ -142,12 +147,13 @@ void acpi_numa_arch_fixup(void);
 
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 /* Arch dependent functions for cpu hotplug support */
-int acpi_map_lsapic(acpi_handle handle, int physid, int *pcpu);
-int acpi_unmap_lsapic(int cpu);
+int acpi_map_cpu(acpi_handle handle, int physid, int *pcpu);
+int acpi_unmap_cpu(int cpu);
 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
 
 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
+int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base);
 void acpi_irq_stats_init(void);
 extern u32 acpi_irq_handled;
 extern u32 acpi_irq_not_handled;
@@ -423,15 +429,13 @@ extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
                                                const struct device *dev);
 
-static inline bool acpi_driver_match_device(struct device *dev,
-                                            const struct device_driver *drv)
-{
-        return !!acpi_match_device(drv->acpi_match_table, dev);
-}
-
+extern bool acpi_driver_match_device(struct device *dev,
+                                     const struct device_driver *drv);
 int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
 int acpi_device_modalias(struct device *, char *, int);
+void acpi_walk_dep_device_list(acpi_handle handle);
 
+struct platform_device *acpi_create_platform_device(struct acpi_device *);
 #define ACPI_PTR(_ptr)  (_ptr)
 
 #else   /* !CONFIG_ACPI */
@@ -442,6 +446,23 @@ int acpi_device_modalias(struct device *, char *, int);
 #define ACPI_COMPANION_SET(dev, adev)   do { } while (0)
 #define ACPI_HANDLE(dev)                (NULL)
 
+struct fwnode_handle;
+
+static inline bool is_acpi_node(struct fwnode_handle *fwnode)
+{
+        return false;
+}
+
+static inline struct acpi_device *acpi_node(struct fwnode_handle *fwnode)
+{
+        return NULL;
+}
+
+static inline struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
+{
+        return NULL;
+}
+
 static inline const char *acpi_dev_name(struct acpi_device *adev)
 {
         return NULL;
@@ -552,16 +573,26 @@ static inline void arch_reserve_mem_area(acpi_physical_address addr,
 #define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0)
 #endif
 
-#if defined(CONFIG_ACPI) && defined(CONFIG_PM_RUNTIME)
+#if defined(CONFIG_ACPI) && defined(CONFIG_PM)
 int acpi_dev_runtime_suspend(struct device *dev);
 int acpi_dev_runtime_resume(struct device *dev);
 int acpi_subsys_runtime_suspend(struct device *dev);
 int acpi_subsys_runtime_resume(struct device *dev);
+struct acpi_device *acpi_dev_pm_get_node(struct device *dev);
+int acpi_dev_pm_attach(struct device *dev, bool power_on);
 #else
 static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; }
 static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; }
 static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }
 static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }
+static inline struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
+{
+        return NULL;
+}
+static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
+{
+        return -ENODEV;
+}
 #endif
 
 #if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)
@@ -584,22 +615,6 @@ static inline int acpi_subsys_suspend(struct device *dev) { return 0; }
 static inline int acpi_subsys_freeze(struct device *dev) { return 0; }
 #endif
 
-#if defined(CONFIG_ACPI) && defined(CONFIG_PM)
-struct acpi_device *acpi_dev_pm_get_node(struct device *dev);
-int acpi_dev_pm_attach(struct device *dev, bool power_on);
-void acpi_dev_pm_detach(struct device *dev, bool power_off);
-#else
-static inline struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
-{
-        return NULL;
-}
-static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
-{
-        return -ENODEV;
-}
-static inline void acpi_dev_pm_detach(struct device *dev, bool power_off) {}
-#endif
-
 #ifdef CONFIG_ACPI
 __printf(3, 4)
 void acpi_handle_printk(const char *level, acpi_handle handle,
@@ -660,4 +675,114 @@ do {									\
 #endif
 #endif
 
+struct acpi_gpio_params {
+        unsigned int crs_entry_index;
+        unsigned int line_index;
+        bool active_low;
+};
+
+struct acpi_gpio_mapping {
+        const char *name;
+        const struct acpi_gpio_params *data;
+        unsigned int size;
+};
+
+#if defined(CONFIG_ACPI) && defined(CONFIG_GPIOLIB)
+int acpi_dev_add_driver_gpios(struct acpi_device *adev,
+                              const struct acpi_gpio_mapping *gpios);
+
+static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev)
+{
+        if (adev)
+                adev->driver_gpios = NULL;
+}
+#else
+static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
+                              const struct acpi_gpio_mapping *gpios)
+{
+        return -ENXIO;
+}
+static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
+#endif
+
+/* Device properties */
+
+#define MAX_ACPI_REFERENCE_ARGS 8
+struct acpi_reference_args {
+        struct acpi_device *adev;
+        size_t nargs;
+        u64 args[MAX_ACPI_REFERENCE_ARGS];
+};
+
+#ifdef CONFIG_ACPI
+int acpi_dev_get_property(struct acpi_device *adev, const char *name,
+                          acpi_object_type type, const union acpi_object **obj);
+int acpi_dev_get_property_array(struct acpi_device *adev, const char *name,
+                                acpi_object_type type,
+                                const union acpi_object **obj);
+int acpi_dev_get_property_reference(struct acpi_device *adev,
+                                    const char *name, size_t index,
+                                    struct acpi_reference_args *args);
+
+int acpi_dev_prop_get(struct acpi_device *adev, const char *propname,
+                      void **valptr);
+int acpi_dev_prop_read_single(struct acpi_device *adev, const char *propname,
+                              enum dev_prop_type proptype, void *val);
+int acpi_dev_prop_read(struct acpi_device *adev, const char *propname,
+                       enum dev_prop_type proptype, void *val, size_t nval);
+
+struct acpi_device *acpi_get_next_child(struct device *dev,
+                                        struct acpi_device *child);
+#else
+static inline int acpi_dev_get_property(struct acpi_device *adev,
+                                        const char *name, acpi_object_type type,
+                                        const union acpi_object **obj)
+{
+        return -ENXIO;
+}
+static inline int acpi_dev_get_property_array(struct acpi_device *adev,
+                                              const char *name,
+                                              acpi_object_type type,
+                                              const union acpi_object **obj)
+{
+        return -ENXIO;
+}
+static inline int acpi_dev_get_property_reference(struct acpi_device *adev,
+                                const char *name, const char *cells_name,
+                                size_t index, struct acpi_reference_args *args)
+{
+        return -ENXIO;
+}
+
+static inline int acpi_dev_prop_get(struct acpi_device *adev,
+                                    const char *propname,
+                                    void **valptr)
+{
+        return -ENXIO;
+}
+
+static inline int acpi_dev_prop_read_single(struct acpi_device *adev,
+                                            const char *propname,
+                                            enum dev_prop_type proptype,
+                                            void *val)
+{
+        return -ENXIO;
+}
+
+static inline int acpi_dev_prop_read(struct acpi_device *adev,
+                                     const char *propname,
+                                     enum dev_prop_type proptype,
+                                     void *val, size_t nval)
+{
+        return -ENXIO;
+}
+
+static inline struct acpi_device *acpi_get_next_child(struct device *dev,
+                                                      struct acpi_device *child)
+{
+        return NULL;
+}
+
+#endif
+
 #endif  /*_LINUX_ACPI_H*/
diff --git a/include/linux/aer.h b/include/linux/aer.h
index c826d1c28f9c..4fef65e57023 100644
--- a/include/linux/aer.h
+++ b/include/linux/aer.h
@@ -7,6 +7,8 @@
 #ifndef _AER_H_
 #define _AER_H_
 
+#include <linux/types.h>
+
 #define AER_NONFATAL                    0
 #define AER_FATAL                       1
 #define AER_CORRECTABLE                 2
diff --git a/include/linux/ahci_platform.h b/include/linux/ahci_platform.h
index 09a947e8bc87..642d6ae4030c 100644
--- a/include/linux/ahci_platform.h
+++ b/include/linux/ahci_platform.h
@@ -22,19 +22,6 @@ 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);
-};
-
 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);
diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h
index fdd7e1b61f60..2afc618b15ce 100644
--- a/include/linux/amba/bus.h
+++ b/include/linux/amba/bus.h
@@ -23,6 +23,7 @@
 
 #define AMBA_NR_IRQS    9
 #define AMBA_CID        0xb105f00d
+#define CORESIGHT_CID   0xb105900d
 
 struct clk;
 
@@ -44,10 +45,15 @@ struct amba_driver {
         const struct amba_id    *id_table;
 };
 
+/*
+ * Constants for the designer field of the Peripheral ID register. When bit 7
+ * is set to '1', bits [6:0] should be the JEP106 manufacturer identity code.
+ */
 enum amba_vendor {
         AMBA_VENDOR_ARM = 0x41,
         AMBA_VENDOR_ST = 0x80,
         AMBA_VENDOR_QCOM = 0x51,
+        AMBA_VENDOR_LSI = 0xb6,
 };
 
 extern struct bus_type amba_bustype;
@@ -92,6 +98,16 @@ void amba_release_regions(struct amba_device *);
 #define amba_pclk_disable(d)    \
         do { if (!IS_ERR((d)->pclk)) clk_disable((d)->pclk); } while (0)
 
+static inline int amba_pclk_prepare(struct amba_device *dev)
+{
+        return clk_prepare(dev->pclk);
+}
+
+static inline void amba_pclk_unprepare(struct amba_device *dev)
+{
+        clk_unprepare(dev->pclk);
+}
+
 /* Some drivers don't use the struct amba_device */
 #define AMBA_CONFIG_BITS(a) (((a) >> 24) & 0xff)
 #define AMBA_REV_BITS(a) (((a) >> 20) & 0x0f)
diff --git a/include/linux/ata_platform.h b/include/linux/ata_platform.h
index b9fde17f767c..5c618a084225 100644
--- a/include/linux/ata_platform.h
+++ b/include/linux/ata_platform.h
@@ -8,11 +8,6 @@ struct pata_platform_info {
          * spacing used by ata_std_ports().
          */
         unsigned int ioport_shift;
-        /* 
-         * Indicate platform specific irq types and initial
-         * IRQ flags when call request_irq()
-         */
-        unsigned int irq_flags;
 };
 
 extern int __pata_platform_probe(struct device *dev,
diff --git a/include/linux/ath9k_platform.h b/include/linux/ath9k_platform.h
index a495a959e8a7..33eb274cd0e6 100644
--- a/include/linux/ath9k_platform.h
+++ b/include/linux/ath9k_platform.h
@@ -31,8 +31,11 @@ struct ath9k_platform_data {
         u32 gpio_mask;
         u32 gpio_val;
 
+        bool endian_check;
         bool is_clk_25mhz;
         bool tx_gain_buffalo;
+        bool disable_2ghz;
+        bool disable_5ghz;
 
         int (*get_mac_revision)(void);
         int (*external_reset)(void);
diff --git a/include/linux/atmel-mci.h b/include/linux/atmel-mci.h
index 4c7a4b2104bf..9177947bf032 100644
--- a/include/linux/atmel-mci.h
+++ b/include/linux/atmel-mci.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_ATMEL_MCI_H
 #define __LINUX_ATMEL_MCI_H
 
+#include <linux/types.h>
+
 #define ATMCI_MAX_NR_SLOTS      2
 
 /**
@@ -9,6 +11,7 @@
  * @detect_pin: GPIO pin wired to the card detect switch
  * @wp_pin: GPIO pin wired to the write protect sensor
  * @detect_is_active_high: The state of the detect pin when it is active
+ * @non_removable: The slot is not removable, only detect once
  *
  * If a given slot is not present on the board, @bus_width should be
  * set to 0. The other fields are ignored in this case.
@@ -24,6 +27,7 @@ struct mci_slot_pdata {
         int                     detect_pin;
         int                     wp_pin;
         bool                    detect_is_active_high;
+        bool                    non_removable;
 };
 
 /**
diff --git a/include/linux/atmel_tc.h b/include/linux/atmel_tc.h
index 89a931babecf..b87c1c7c242a 100644
--- a/include/linux/atmel_tc.h
+++ b/include/linux/atmel_tc.h
@@ -44,12 +44,13 @@ struct atmel_tcb_config {
 /**
  * struct atmel_tc - information about a Timer/Counter Block
  * @pdev: physical device
- * @iomem: resource associated with the I/O register
  * @regs: mapping through which the I/O registers can be accessed
+ * @id: block id
  * @tcb_config: configuration data from SoC
  * @irq: irq for each of the three channels
  * @clk: internal clock source for each of the three channels
  * @node: list node, for tclib internal use
+ * @allocated: if already used, for tclib internal use
  *
  * On some platforms, each TC channel has its own clocks and IRQs,
  * while on others, all TC channels share the same clock and IRQ.
@@ -61,15 +62,16 @@ struct atmel_tcb_config {
  */
 struct atmel_tc {
         struct platform_device  *pdev;
-        struct resource         *iomem;
         void __iomem            *regs;
+        int                     id;
         const struct atmel_tcb_config *tcb_config;
         int                     irq[3];
         struct clk              *clk[3];
         struct list_head        node;
+        bool                    allocated;
 };
 
-extern struct atmel_tc *atmel_tc_alloc(unsigned block, const char *name);
+extern struct atmel_tc *atmel_tc_alloc(unsigned block);
 extern void atmel_tc_free(struct atmel_tc *tc);
 
 /* platform-specific ATMEL_TC_TIMER_CLOCKx divisors (0 means 32KiHz) */
@@ -258,5 +260,10 @@ extern const u8 atmel_tc_divisors[5];
 #define     ATMEL_TC_LDRAS      (1 <<  5)       /* RA loading */
 #define     ATMEL_TC_LDRBS      (1 <<  6)       /* RB loading */
 #define     ATMEL_TC_ETRGS      (1 <<  7)       /* external trigger */
+#define     ATMEL_TC_ALL_IRQ    (ATMEL_TC_COVFS | ATMEL_TC_LOVRS | \
+                                 ATMEL_TC_CPAS | ATMEL_TC_CPBS | \
+                                 ATMEL_TC_CPCS | ATMEL_TC_LDRAS | \
+                                 ATMEL_TC_LDRBS | ATMEL_TC_ETRGS) \
+                                 /* all IRQs */
 
 #endif
diff --git a/include/linux/atomic.h b/include/linux/atomic.h
index fef3a809e7cf..5b08a8540ecf 100644
--- a/include/linux/atomic.h
+++ b/include/linux/atomic.h
@@ -3,42 +3,6 @@
 #define _LINUX_ATOMIC_H
 #include <asm/atomic.h>
 
-/*
- * Provide __deprecated wrappers for the new interface, avoid flag day changes.
- * We need the ugly external functions to break header recursion hell.
- */
-#ifndef smp_mb__before_atomic_inc
-static inline void __deprecated smp_mb__before_atomic_inc(void)
-{
-        extern void __smp_mb__before_atomic(void);
-        __smp_mb__before_atomic();
-}
-#endif
-
-#ifndef smp_mb__after_atomic_inc
-static inline void __deprecated smp_mb__after_atomic_inc(void)
-{
-        extern void __smp_mb__after_atomic(void);
-        __smp_mb__after_atomic();
-}
-#endif
-
-#ifndef smp_mb__before_atomic_dec
-static inline void __deprecated smp_mb__before_atomic_dec(void)
-{
-        extern void __smp_mb__before_atomic(void);
-        __smp_mb__before_atomic();
-}
-#endif
-
-#ifndef smp_mb__after_atomic_dec
-static inline void __deprecated smp_mb__after_atomic_dec(void)
-{
-        extern void __smp_mb__after_atomic(void);
-        __smp_mb__after_atomic();
-}
-#endif
-
 /**
  * atomic_add_unless - add unless the number is already a given value
  * @v: pointer of type atomic_t
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 22cfddb75566..af84234e1f6e 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -47,6 +47,7 @@ struct sk_buff;
 
 struct audit_krule {
         int                     vers_ops;
+        u32                     pflags;
         u32                     flags;
         u32                     listnr;
         u32                     action;
@@ -64,14 +65,21 @@ struct audit_krule {
         u64                     prio;
 };
 
+/* Flag to indicate legacy AUDIT_LOGINUID unset usage */
+#define AUDIT_LOGINUID_LEGACY           0x1
+
 struct audit_field {
         u32                             type;
-        u32                             val;
-        kuid_t                          uid;
-        kgid_t                          gid;
+        union {
+                u32                     val;
+                kuid_t                  uid;
+                kgid_t                  gid;
+                struct {
+                        char            *lsm_str;
+                        void            *lsm_rule;
+                };
+        };
         u32                             op;
-        char                            *lsm_str;
-        void                            *lsm_rule;
 };
 
 extern int is_audit_feature_set(int which);
@@ -86,7 +94,7 @@ extern unsigned compat_dir_class[];
 extern unsigned compat_chattr_class[];
 extern unsigned compat_signal_class[];
 
-extern int __weak audit_classify_compat_syscall(int abi, unsigned syscall);
+extern int audit_classify_compat_syscall(int abi, unsigned syscall);
 
 /* audit_names->type values */
 #define AUDIT_TYPE_UNKNOWN      0       /* we don't know yet */
@@ -109,12 +117,13 @@ extern void audit_log_session_info(struct audit_buffer *ab);
 #endif
 
 #ifdef CONFIG_AUDITSYSCALL
+#include <asm/syscall.h> /* for syscall_get_arch() */
+
 /* These are defined in auditsc.c */
                                 /* Public API */
 extern int  audit_alloc(struct task_struct *task);
 extern void __audit_free(struct task_struct *task);
-extern void __audit_syscall_entry(int arch,
-                                  int major, unsigned long a0, unsigned long a1,
+extern void __audit_syscall_entry(int major, unsigned long a0, unsigned long a1,
                                   unsigned long a2, unsigned long a3);
 extern void __audit_syscall_exit(int ret_success, long ret_value);
 extern struct filename *__audit_reusename(const __user char *uptr);
@@ -125,6 +134,7 @@ extern void audit_putname(struct filename *name);
 #define AUDIT_INODE_HIDDEN      2       /* audit record should be hidden */
 extern void __audit_inode(struct filename *name, const struct dentry *dentry,
                                 unsigned int flags);
+extern void __audit_file(const struct file *);
 extern void __audit_inode_child(const struct inode *parent,
                                 const struct dentry *dentry,
                                 const unsigned char type);
@@ -141,12 +151,12 @@ static inline void audit_free(struct task_struct *task)
         if (unlikely(task->audit_context))
                 __audit_free(task);
 }
-static inline void audit_syscall_entry(int arch, int major, unsigned long a0,
+static inline void audit_syscall_entry(int major, unsigned long a0,
                                        unsigned long a1, unsigned long a2,
                                        unsigned long a3)
 {
         if (unlikely(current->audit_context))
-                __audit_syscall_entry(arch, major, a0, a1, a2, a3);
+                __audit_syscall_entry(major, a0, a1, a2, a3);
 }
 static inline void audit_syscall_exit(void *pt_regs)
 {
@@ -178,6 +188,11 @@ static inline void audit_inode(struct filename *name,
                 __audit_inode(name, dentry, flags);
         }
 }
+static inline void audit_file(struct file *file)
+{
+        if (unlikely(!audit_dummy_context()))
+                __audit_file(file);
+}
 static inline void audit_inode_parent_hidden(struct filename *name,
                                                 const struct dentry *dentry)
 {
@@ -322,7 +337,7 @@ static inline int audit_alloc(struct task_struct *task)
 }
 static inline void audit_free(struct task_struct *task)
 { }
-static inline void audit_syscall_entry(int arch, int major, unsigned long a0,
+static inline void audit_syscall_entry(int major, unsigned long a0,
                                        unsigned long a1, unsigned long a2,
                                        unsigned long a3)
 { }
@@ -352,6 +367,9 @@ static inline void audit_inode(struct filename *name,
                                 const struct dentry *dentry,
                                 unsigned int parent)
 { }
+static inline void audit_file(struct file *file)
+{
+}
 static inline void audit_inode_parent_hidden(struct filename *name,
                                 const struct dentry *dentry)
 { }
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index e488e9459a93..5da6012b7a14 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -28,12 +28,10 @@ struct dentry;
  * Bits in backing_dev_info.state
  */
 enum bdi_state {
-        BDI_wb_alloc,           /* Default embedded wb allocated */
         BDI_async_congested,    /* The async (write) queue is getting full */
         BDI_sync_congested,     /* The sync queue is getting full */
         BDI_registered,         /* bdi_register() was done */
         BDI_writeback_running,  /* Writeback is in progress */
-        BDI_unused,             /* Available bits start here */
 };
 
 typedef int (congested_fn)(void *, int);
@@ -50,7 +48,6 @@ enum bdi_stat_item {
 
 struct bdi_writeback {
         struct backing_dev_info *bdi;   /* our parent bdi */
-        unsigned int nr;
 
         unsigned long last_old_flush;   /* last old data flush */
 
@@ -124,7 +121,6 @@ void bdi_start_background_writeback(struct backing_dev_info *bdi);
 void bdi_writeback_workfn(struct work_struct *work);
 int bdi_has_dirty_io(struct backing_dev_info *bdi);
 void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi);
-void bdi_lock_two(struct bdi_writeback *wb1, struct bdi_writeback *wb2);
 
 extern spinlock_t bdi_lock;
 extern struct list_head bdi_list;
diff --git a/include/linux/balloon_compaction.h b/include/linux/balloon_compaction.h
index 089743ade734..9b0a15d06a4f 100644
--- a/include/linux/balloon_compaction.h
+++ b/include/linux/balloon_compaction.h
@@ -27,10 +27,13 @@
  *      counter raised only while it is under our special handling;
  *
  * iii. after the lockless scan step have selected a potential balloon page for
- *      isolation, re-test the page->mapping flags and the page ref counter
+ *      isolation, re-test the PageBalloon mark and the PagePrivate flag
  *      under the proper page lock, to ensure isolating a valid balloon page
  *      (not yet isolated, nor under release procedure)
  *
+ *  iv. isolation or dequeueing procedure must clear PagePrivate flag under
+ *      page lock together with removing page from balloon device page list.
+ *
  * The functions provided by this interface are placed to help on coping with
  * the aforementioned balloon page corner case, as well as to ensure the simple
  * set of exposed rules are satisfied while we are dealing with balloon pages
@@ -54,43 +57,22 @@
  * balloon driver as a page book-keeper for its registered balloon devices.
  */
 struct balloon_dev_info {
-        void *balloon_device;           /* balloon device descriptor */
-        struct address_space *mapping;  /* balloon special page->mapping */
         unsigned long isolated_pages;   /* # of isolated pages for migration */
         spinlock_t pages_lock;          /* Protection to pages list */
         struct list_head pages;         /* Pages enqueued & handled to Host */
+        int (*migratepage)(struct balloon_dev_info *, struct page *newpage,
+                        struct page *page, enum migrate_mode mode);
 };
 
 extern struct page *balloon_page_enqueue(struct balloon_dev_info *b_dev_info);
 extern struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info);
-extern struct balloon_dev_info *balloon_devinfo_alloc(
-                                                void *balloon_dev_descriptor);
 
-static inline void balloon_devinfo_free(struct balloon_dev_info *b_dev_info)
-{
-        kfree(b_dev_info);
-}
-
-/*
- * balloon_page_free - release a balloon page back to the page free lists
- * @page: ballooned page to be set free
- *
- * This function must be used to properly set free an isolated/dequeued balloon
- * page at the end of a sucessful page migration, or at the balloon driver's
- * page release procedure.
- */
-static inline void balloon_page_free(struct page *page)
+static inline void balloon_devinfo_init(struct balloon_dev_info *balloon)
 {
-        /*
-         * Balloon pages always get an extra refcount before being isolated
-         * and before being dequeued to help on sorting out fortuite colisions
-         * between a thread attempting to isolate and another thread attempting
-         * to release the very same balloon page.
-         *
-         * Before we handle the page back to Buddy, lets drop its extra refcnt.
-         */
-        put_page(page);
-        __free_page(page);
+        balloon->isolated_pages = 0;
+        spin_lock_init(&balloon->pages_lock);
+        INIT_LIST_HEAD(&balloon->pages);
+        balloon->migratepage = NULL;
 }
 
 #ifdef CONFIG_BALLOON_COMPACTION
@@ -98,107 +80,58 @@ extern bool balloon_page_isolate(struct page *page);
 extern void balloon_page_putback(struct page *page);
 extern int balloon_page_migrate(struct page *newpage,
                                 struct page *page, enum migrate_mode mode);
-extern struct address_space
-*balloon_mapping_alloc(struct balloon_dev_info *b_dev_info,
-                        const struct address_space_operations *a_ops);
-
-static inline void balloon_mapping_free(struct address_space *balloon_mapping)
-{
-        kfree(balloon_mapping);
-}
 
 /*
- * page_flags_cleared - helper to perform balloon @page ->flags tests.
- *
- * As balloon pages are obtained from buddy and we do not play with page->flags
- * at driver level (exception made when we get the page lock for compaction),
- * we can safely identify a ballooned page by checking if the
- * PAGE_FLAGS_CHECK_AT_PREP page->flags are all cleared.  This approach also
- * helps us skip ballooned pages that are locked for compaction or release, thus
- * mitigating their racy check at balloon_page_movable()
- */
-static inline bool page_flags_cleared(struct page *page)
-{
-        return !(page->flags & PAGE_FLAGS_CHECK_AT_PREP);
-}
-
-/*
- * __is_movable_balloon_page - helper to perform @page mapping->flags tests
+ * __is_movable_balloon_page - helper to perform @page PageBalloon tests
  */
 static inline bool __is_movable_balloon_page(struct page *page)
 {
-        struct address_space *mapping = page->mapping;
-        return mapping_balloon(mapping);
+        return PageBalloon(page);
 }
 
 /*
- * balloon_page_movable - test page->mapping->flags to identify balloon pages
- *                        that can be moved by compaction/migration.
- *
- * This function is used at core compaction's page isolation scheme, therefore
- * most pages exposed to it are not enlisted as balloon pages and so, to avoid
- * undesired side effects like racing against __free_pages(), we cannot afford
- * holding the page locked while testing page->mapping->flags here.
+ * balloon_page_movable - test PageBalloon to identify balloon pages
+ *                        and PagePrivate to check that the page is not
+ *                        isolated and can be moved by compaction/migration.
  *
  * As we might return false positives in the case of a balloon page being just
- * released under us, the page->mapping->flags need to be re-tested later,
- * under the proper page lock, at the functions that will be coping with the
- * balloon page case.
+ * released under us, this need to be re-tested later, under the page lock.
  */
 static inline bool balloon_page_movable(struct page *page)
 {
-        /*
-         * Before dereferencing and testing mapping->flags, let's make sure
-         * this is not a page that uses ->mapping in a different way
-         */
-        if (page_flags_cleared(page) && !page_mapped(page) &&
-            page_count(page) == 1)
-                return __is_movable_balloon_page(page);
-
-        return false;
+        return PageBalloon(page) && PagePrivate(page);
 }
 
 /*
  * isolated_balloon_page - identify an isolated balloon page on private
  *                         compaction/migration page lists.
- *
- * After a compaction thread isolates a balloon page for migration, it raises
- * the page refcount to prevent concurrent compaction threads from re-isolating
- * the same page. For that reason putback_movable_pages(), or other routines
- * that need to identify isolated balloon pages on private pagelists, cannot
- * rely on balloon_page_movable() to accomplish the task.
  */
 static inline bool isolated_balloon_page(struct page *page)
 {
-        /* Already isolated balloon pages, by default, have a raised refcount */
-        if (page_flags_cleared(page) && !page_mapped(page) &&
-            page_count(page) >= 2)
-                return __is_movable_balloon_page(page);
-
-        return false;
+        return PageBalloon(page);
 }
 
 /*
  * balloon_page_insert - insert a page into the balloon's page list and make
- *                       the page->mapping assignment accordingly.
+ *                       the page->private assignment accordingly.
+ * @balloon : pointer to balloon device
  * @page    : page to be assigned as a 'balloon page'
- * @mapping : allocated special 'balloon_mapping'
- * @head    : balloon's device page list head
  *
  * Caller must ensure the page is locked and the spin_lock protecting balloon
  * pages list is held before inserting a page into the balloon device.
  */
-static inline void balloon_page_insert(struct page *page,
-                                       struct address_space *mapping,
-                                       struct list_head *head)
+static inline void balloon_page_insert(struct balloon_dev_info *balloon,
+                                       struct page *page)
 {
-        page->mapping = mapping;
-        list_add(&page->lru, head);
+        __SetPageBalloon(page);
+        SetPagePrivate(page);
+        set_page_private(page, (unsigned long)balloon);
+        list_add(&page->lru, &balloon->pages);
 }
 
 /*
  * balloon_page_delete - delete a page from balloon's page list and clear
- *                       the page->mapping assignement accordingly.
+ *                       the page->private assignement accordingly.
  * @page    : page to be released from balloon's page list
  *
  * Caller must ensure the page is locked and the spin_lock protecting balloon
@@ -206,8 +139,12 @@ static inline void balloon_page_insert(struct page *page,
  */
 static inline void balloon_page_delete(struct page *page)
 {
-        page->mapping = NULL;
-        list_del(&page->lru);
+        __ClearPageBalloon(page);
+        set_page_private(page, 0);
+        if (PagePrivate(page)) {
+                ClearPagePrivate(page);
+                list_del(&page->lru);
+        }
 }
 
 /*
@@ -216,11 +153,7 @@ static inline void balloon_page_delete(struct page *page)
  */
 static inline struct balloon_dev_info *balloon_page_device(struct page *page)
 {
-        struct address_space *mapping = page->mapping;
-        if (likely(mapping))
-                return mapping->private_data;
-
-        return NULL;
+        return (struct balloon_dev_info *)page_private(page);
 }
 
 static inline gfp_t balloon_mapping_gfp_mask(void)
@@ -228,34 +161,24 @@ static inline gfp_t balloon_mapping_gfp_mask(void)
         return GFP_HIGHUSER_MOVABLE;
 }
 
-static inline bool balloon_compaction_check(void)
-{
-        return true;
-}
-
 #else /* !CONFIG_BALLOON_COMPACTION */
 
-static inline void *balloon_mapping_alloc(void *balloon_device,
-                                const struct address_space_operations *a_ops)
-{
-        return ERR_PTR(-EOPNOTSUPP);
-}
-
-static inline void balloon_mapping_free(struct address_space *balloon_mapping)
+static inline void balloon_page_insert(struct balloon_dev_info *balloon,
+                                       struct page *page)
 {
-        return;
+        __SetPageBalloon(page);
+        list_add(&page->lru, &balloon->pages);
 }
 
-static inline void balloon_page_insert(struct page *page,
-                                       struct address_space *mapping,
-                                       struct list_head *head)
+static inline void balloon_page_delete(struct page *page)
 {
-        list_add(&page->lru, head);
+        __ClearPageBalloon(page);
+        list_del(&page->lru);
 }
 
-static inline void balloon_page_delete(struct page *page)
+static inline bool __is_movable_balloon_page(struct page *page)
 {
-        list_del(&page->lru);
+        return false;
 }
 
 static inline bool balloon_page_movable(struct page *page)
@@ -289,9 +212,5 @@ static inline gfp_t balloon_mapping_gfp_mask(void)
         return GFP_HIGHUSER;
 }
 
-static inline bool balloon_compaction_check(void)
-{
-        return false;
-}
 #endif /* CONFIG_BALLOON_COMPACTION */
 #endif /* _LINUX_BALLOON_COMPACTION_H */
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index 0272e49135d0..eb1c6a47b67f 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -267,7 +267,7 @@ struct bcma_device {
         u8 core_unit;
 
         u32 addr;
-        u32 addr1;
+        u32 addr_s[8];
         u32 wrap;
 
         void __iomem *io_addr;
@@ -323,6 +323,8 @@ struct bcma_bus {
                 struct pci_dev *host_pci;
                 /* Pointer to the SDIO device (only for BCMA_HOSTTYPE_SDIO) */
                 struct sdio_func *host_sdio;
+                /* Pointer to platform device (only for BCMA_HOSTTYPE_SOC) */
+                struct platform_device *host_pdev;
         };
 
         struct bcma_chipinfo chipinfo;
@@ -332,10 +334,10 @@ struct bcma_bus {
         struct bcma_device *mapped_core;
         struct list_head cores;
         u8 nr_cores;
-        u8 init_done:1;
         u8 num;
 
         struct bcma_drv_cc drv_cc;
+        struct bcma_drv_cc_b drv_cc_b;
         struct bcma_drv_pci drv_pci[2];
         struct bcma_drv_pcie2 drv_pcie2;
         struct bcma_drv_mips drv_mips;
@@ -445,4 +447,6 @@ extern u32 bcma_chipco_pll_read(struct bcma_drv_cc *cc, u32 offset);
 #define  BCMA_DMA_TRANSLATION_DMA64_CMT 0x80000000 /* Client Mode Translation for 64-bit DMA */
 extern u32 bcma_core_dma_translation(struct bcma_device *core);
 
+extern unsigned int bcma_core_irq(struct bcma_device *core, int num);
+
 #endif /* LINUX_BCMA_H_ */
diff --git a/include/linux/bcma/bcma_driver_chipcommon.h b/include/linux/bcma/bcma_driver_chipcommon.h
index 63d105cd14a3..db6fa217f98b 100644
--- a/include/linux/bcma/bcma_driver_chipcommon.h
+++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -644,6 +644,12 @@ struct bcma_drv_cc {
 #endif
 };
 
+struct bcma_drv_cc_b {
+        struct bcma_device *core;
+        u8 setup_done:1;
+        void __iomem *mii;
+};
+
 /* Register access */
 #define bcma_cc_read32(cc, offset) \
         bcma_read32((cc)->core, offset)
@@ -699,4 +705,6 @@ extern void bcma_pmu_spuravoid_pllupdate(struct bcma_drv_cc *cc, int spuravoid);
 
 extern u32 bcma_pmu_get_bus_clock(struct bcma_drv_cc *cc);
 
+void bcma_chipco_b_mii_write(struct bcma_drv_cc_b *ccb, u32 offset, u32 value);
+
 #endif /* LINUX_BCMA_DRIVER_CC_H_ */
diff --git a/include/linux/bcma/bcma_driver_mips.h b/include/linux/bcma/bcma_driver_mips.h
index fb61f3fb4ddb..0b3b32aeeb8a 100644
--- a/include/linux/bcma/bcma_driver_mips.h
+++ b/include/linux/bcma/bcma_driver_mips.h
@@ -43,12 +43,12 @@ struct bcma_drv_mips {
 extern void bcma_core_mips_init(struct bcma_drv_mips *mcore);
 extern void bcma_core_mips_early_init(struct bcma_drv_mips *mcore);
 
-extern unsigned int bcma_core_irq(struct bcma_device *core);
+extern unsigned int bcma_core_mips_irq(struct bcma_device *dev);
 #else
 static inline void bcma_core_mips_init(struct bcma_drv_mips *mcore) { }
 static inline void bcma_core_mips_early_init(struct bcma_drv_mips *mcore) { }
 
-static inline unsigned int bcma_core_irq(struct bcma_device *core)
+static inline unsigned int bcma_core_mips_irq(struct bcma_device *dev)
 {
         return 0;
 }
diff --git a/include/linux/bcma/bcma_regs.h b/include/linux/bcma/bcma_regs.h
index 917dcd7965e7..e64ae7bf80a1 100644
--- a/include/linux/bcma/bcma_regs.h
+++ b/include/linux/bcma/bcma_regs.h
@@ -39,6 +39,11 @@
 #define  BCMA_RESET_CTL_RESET           0x0001
 #define BCMA_RESET_ST                   0x0804
 
+#define BCMA_NS_ROM_IOST_BOOT_DEV_MASK  0x0003
+#define BCMA_NS_ROM_IOST_BOOT_DEV_NOR   0x0000
+#define BCMA_NS_ROM_IOST_BOOT_DEV_NAND  0x0001
+#define BCMA_NS_ROM_IOST_BOOT_DEV_ROM   0x0002
+
 /* BCMA PCI config space registers. */
 #define BCMA_PCI_PMCSR                  0x44
 #define  BCMA_PCI_PE                    0x100
diff --git a/include/linux/bcma/bcma_soc.h b/include/linux/bcma/bcma_soc.h
index 4203c5593b9f..f24d245f8394 100644
--- a/include/linux/bcma/bcma_soc.h
+++ b/include/linux/bcma/bcma_soc.h
@@ -10,6 +10,7 @@ struct bcma_soc {
 };
 
 int __init bcma_host_soc_register(struct bcma_soc *soc);
+int __init bcma_host_soc_init(struct bcma_soc *soc);
 
 int bcma_bus_register(struct bcma_bus *bus);
 
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index 61f29e5ea840..576e4639ca60 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -53,6 +53,10 @@ struct linux_binprm {
 #define BINPRM_FLAGS_EXECFD_BIT 1
 #define BINPRM_FLAGS_EXECFD (1 << BINPRM_FLAGS_EXECFD_BIT)
 
+/* filename of the binary will be inaccessible after exec */
+#define BINPRM_FLAGS_PATH_INACCESSIBLE_BIT 2
+#define BINPRM_FLAGS_PATH_INACCESSIBLE (1 << BINPRM_FLAGS_PATH_INACCESSIBLE_BIT)
+
 /* Function parameter for binfmt->coredump */
 struct coredump_params {
         const siginfo_t *siginfo;
diff --git a/include/linux/bio.h b/include/linux/bio.h
index b39e5000ff58..efead0b532c4 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -292,7 +292,24 @@ static inline unsigned bio_segments(struct bio *bio)
  */
 #define bio_get(bio)    atomic_inc(&(bio)->bi_cnt)
 
+enum bip_flags {
+        BIP_BLOCK_INTEGRITY     = 1 << 0, /* block layer owns integrity data */
+        BIP_MAPPED_INTEGRITY    = 1 << 1, /* ref tag has been remapped */
+        BIP_CTRL_NOCHECK        = 1 << 2, /* disable HBA integrity checking */
+        BIP_DISK_NOCHECK        = 1 << 3, /* disable disk integrity checking */
+        BIP_IP_CHECKSUM         = 1 << 4, /* IP checksum */
+};
+
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
+
+static inline struct bio_integrity_payload *bio_integrity(struct bio *bio)
+{
+        if (bio->bi_rw & REQ_INTEGRITY)
+                return bio->bi_integrity;
+
+        return NULL;
+}
+
 /*
  * bio integrity payload
  */
@@ -301,21 +318,40 @@ struct bio_integrity_payload {
 
         struct bvec_iter        bip_iter;
 
-        /* kill - should just use bip_vec */
-        void                    *bip_buf;       /* generated integrity data */
-
         bio_end_io_t            *bip_end_io;    /* saved I/O completion fn */
 
         unsigned short          bip_slab;       /* slab the bip came from */
         unsigned short          bip_vcnt;       /* # of integrity bio_vecs */
         unsigned short          bip_max_vcnt;   /* integrity bio_vec slots */
-        unsigned                bip_owns_buf:1; /* should free bip_buf */
+        unsigned short          bip_flags;      /* control flags */
 
         struct work_struct      bip_work;       /* I/O completion */
 
         struct bio_vec          *bip_vec;
         struct bio_vec          bip_inline_vecs[0];/* embedded bvec array */
 };
+
+static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
+{
+        struct bio_integrity_payload *bip = bio_integrity(bio);
+
+        if (bip)
+                return bip->bip_flags & flag;
+
+        return false;
+}
+
+static inline sector_t bip_get_seed(struct bio_integrity_payload *bip)
+{
+        return bip->bip_iter.bi_sector;
+}
+
+static inline void bip_set_seed(struct bio_integrity_payload *bip,
+                                sector_t seed)
+{
+        bip->bip_iter.bi_sector = seed;
+}
+
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 
 extern void bio_trim(struct bio *bio, int offset, int size);
@@ -342,6 +378,7 @@ static inline struct bio *bio_next_split(struct bio *bio, int sectors,
 }
 
 extern struct bio_set *bioset_create(unsigned int, unsigned int);
+extern struct bio_set *bioset_create_nobvec(unsigned int, unsigned int);
 extern void bioset_free(struct bio_set *);
 extern mempool_t *biovec_create_pool(int pool_entries);
 
@@ -353,7 +390,6 @@ extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
 extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);
 
 extern struct bio_set *fs_bio_set;
-unsigned int bio_integrity_tag_size(struct bio *bio);
 
 static inline struct bio *bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs)
 {
@@ -407,6 +443,11 @@ extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
 extern void bio_set_pages_dirty(struct bio *bio);
 extern void bio_check_pages_dirty(struct bio *bio);
 
+void generic_start_io_acct(int rw, unsigned long sectors,
+                           struct hd_struct *part);
+void generic_end_io_acct(int rw, struct hd_struct *part,
+                         unsigned long start_time);
+
 #ifndef ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
 # error "You should define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE for your platform"
 #endif
@@ -661,14 +702,10 @@ struct biovec_slab {
         for_each_bio(_bio)                                              \
                 bip_for_each_vec(_bvl, _bio->bi_integrity, _iter)
 
-#define bio_integrity(bio) (bio->bi_integrity != NULL)
-
 extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
 extern void bio_integrity_free(struct bio *);
 extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
-extern int bio_integrity_enabled(struct bio *bio);
-extern int bio_integrity_set_tag(struct bio *, void *, unsigned int);
-extern int bio_integrity_get_tag(struct bio *, void *, unsigned int);
+extern bool bio_integrity_enabled(struct bio *bio);
 extern int bio_integrity_prep(struct bio *);
 extern void bio_integrity_endio(struct bio *, int);
 extern void bio_integrity_advance(struct bio *, unsigned int);
@@ -680,14 +717,14 @@ extern void bio_integrity_init(void);
 
 #else /* CONFIG_BLK_DEV_INTEGRITY */
 
-static inline int bio_integrity(struct bio *bio)
+static inline void *bio_integrity(struct bio *bio)
 {
-        return 0;
+        return NULL;
 }
 
-static inline int bio_integrity_enabled(struct bio *bio)
+static inline bool bio_integrity_enabled(struct bio *bio)
 {
-        return 0;
+        return false;
 }
 
 static inline int bioset_integrity_create(struct bio_set *bs, int pool_size)
@@ -733,6 +770,11 @@ static inline void bio_integrity_init(void)
         return;
 }
 
+static inline bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
+{
+        return false;
+}
+
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 
 #endif /* CONFIG_BLOCK */
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index e1c8d080c427..202e4034fe26 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -45,6 +45,7 @@
  * bitmap_set(dst, pos, nbits)                  Set specified bit area
  * bitmap_clear(dst, pos, nbits)                Clear specified bit area
  * bitmap_find_next_zero_area(buf, len, pos, n, mask)   Find bit free area
+ * bitmap_find_next_zero_area_off(buf, len, pos, n, mask)       as above
  * bitmap_shift_right(dst, src, n, nbits)       *dst = *src >> n
  * bitmap_shift_left(dst, src, n, nbits)        *dst = *src << n
  * bitmap_remap(dst, src, old, new, nbits)      *dst = map(old, new)(src)
@@ -60,6 +61,7 @@
  * bitmap_find_free_region(bitmap, bits, order) Find and allocate bit region
  * bitmap_release_region(bitmap, pos, order)    Free specified bit region
  * bitmap_allocate_region(bitmap, pos, order)   Allocate specified bit region
+ * bitmap_print_to_pagebuf(list, buf, mask, nbits) Print bitmap src as list/hex
  */
 
 /*
@@ -114,11 +116,36 @@ extern int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);
 
 extern void bitmap_set(unsigned long *map, unsigned int start, int len);
 extern void bitmap_clear(unsigned long *map, unsigned int start, int len);
-extern unsigned long bitmap_find_next_zero_area(unsigned long *map,
-                                         unsigned long size,
-                                         unsigned long start,
-                                         unsigned int nr,
-                                         unsigned long align_mask);
+
+extern unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
+                                                    unsigned long size,
+                                                    unsigned long start,
+                                                    unsigned int nr,
+                                                    unsigned long align_mask,
+                                                    unsigned long align_offset);
+
+/**
+ * bitmap_find_next_zero_area - find a contiguous aligned zero area
+ * @map: The address to base the search on
+ * @size: The bitmap size in bits
+ * @start: The bitnumber to start searching at
+ * @nr: The number of zeroed bits we're looking for
+ * @align_mask: Alignment mask for zero area
+ *
+ * The @align_mask should be one less than a power of 2; the effect is that
+ * the bit offset of all zero areas this function finds is multiples of that
+ * power of 2. A @align_mask of 0 means no alignment is required.
+ */
+static inline unsigned long
+bitmap_find_next_zero_area(unsigned long *map,
+                           unsigned long size,
+                           unsigned long start,
+                           unsigned int nr,
+                           unsigned long align_mask)
+{
+        return bitmap_find_next_zero_area_off(map, size, start, nr,
+                                              align_mask, 0);
+}
 
 extern int bitmap_scnprintf(char *buf, unsigned int len,
                         const unsigned long *src, int nbits);
@@ -145,6 +172,8 @@ extern void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int o
 extern int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);
 extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits);
 extern int bitmap_ord_to_pos(const unsigned long *bitmap, int n, int bits);
+extern int bitmap_print_to_pagebuf(bool list, char *buf,
+                                   const unsigned long *maskp, int nmaskbits);
 
 #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG))
 #define BITMAP_LAST_WORD_MASK(nbits)                                    \
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index cbc5833fb221..5d858e02997f 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -18,8 +18,11 @@
  * position @h. For example
  * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000.
  */
-#define GENMASK(h, l)           (((U32_C(1) << ((h) - (l) + 1)) - 1) << (l))
-#define GENMASK_ULL(h, l)       (((U64_C(1) << ((h) - (l) + 1)) - 1) << (l))
+#define GENMASK(h, l) \
+        (((~0UL) << (l)) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
+
+#define GENMASK_ULL(h, l) \
+        (((~0ULL) << (l)) & (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h))))
 
 extern unsigned int __sw_hweight8(unsigned int w);
 extern unsigned int __sw_hweight16(unsigned int w);
@@ -32,26 +35,6 @@ extern unsigned long __sw_hweight64(__u64 w);
  */
 #include <asm/bitops.h>
 
-/*
- * Provide __deprecated wrappers for the new interface, avoid flag day changes.
- * We need the ugly external functions to break header recursion hell.
- */
-#ifndef smp_mb__before_clear_bit
-static inline void __deprecated smp_mb__before_clear_bit(void)
-{
-        extern void __smp_mb__before_atomic(void);
-        __smp_mb__before_atomic();
-}
-#endif
-
-#ifndef smp_mb__after_clear_bit
-static inline void __deprecated smp_mb__after_clear_bit(void)
-{
-        extern void __smp_mb__after_atomic(void);
-        __smp_mb__after_atomic();
-}
-#endif
-
 #define for_each_set_bit(bit, addr, size) \
         for ((bit) = find_first_bit((addr), (size));            \
              (bit) < (size);                                    \
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index a1e31f274fcd..8aded9ab2e4e 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -4,6 +4,7 @@
 #include <linux/blkdev.h>
 
 struct blk_mq_tags;
+struct blk_flush_queue;
 
 struct blk_mq_cpu_notifier {
         struct list_head list;
@@ -34,6 +35,7 @@ struct blk_mq_hw_ctx {
 
         struct request_queue    *queue;
         unsigned int            queue_num;
+        struct blk_flush_queue  *fq;
 
         void                    *driver_data;
 
@@ -77,8 +79,15 @@ struct blk_mq_tag_set {
         struct list_head        tag_list;
 };
 
-typedef int (queue_rq_fn)(struct blk_mq_hw_ctx *, struct request *);
+struct blk_mq_queue_data {
+        struct request *rq;
+        struct list_head *list;
+        bool last;
+};
+
+typedef int (queue_rq_fn)(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *);
 typedef struct blk_mq_hw_ctx *(map_queue_fn)(struct request_queue *, const int);
+typedef enum blk_eh_timer_return (timeout_fn)(struct request *, bool);
 typedef int (init_hctx_fn)(struct blk_mq_hw_ctx *, void *, unsigned int);
 typedef void (exit_hctx_fn)(struct blk_mq_hw_ctx *, unsigned int);
 typedef int (init_request_fn)(void *, struct request *, unsigned int,
@@ -86,6 +95,9 @@ typedef int (init_request_fn)(void *, struct request *, unsigned int,
 typedef void (exit_request_fn)(void *, struct request *, unsigned int,
                 unsigned int);
 
+typedef void (busy_iter_fn)(struct blk_mq_hw_ctx *, struct request *, void *,
+                bool);
+
 struct blk_mq_ops {
         /*
          * Queue request
@@ -100,7 +112,7 @@ struct blk_mq_ops {
         /*
          * Called on request timeout
          */
-        rq_timed_out_fn         *timeout;
+        timeout_fn              *timeout;
 
         softirq_done_fn         *complete;
 
@@ -115,6 +127,10 @@ struct blk_mq_ops {
         /*
          * Called for every command allocated by the block layer to allow
          * the driver to set up driver specific data.
+         *
+         * Tag greater than or equal to queue_depth is for setting up
+         * flush request.
+         *
          * Ditto for exit/teardown.
          */
         init_request_fn         *init_request;
@@ -130,6 +146,7 @@ enum {
         BLK_MQ_F_TAG_SHARED     = 1 << 1,
         BLK_MQ_F_SG_MERGE       = 1 << 2,
         BLK_MQ_F_SYSFS_UP       = 1 << 3,
+        BLK_MQ_F_DEFER_ISSUE    = 1 << 4,
 
         BLK_MQ_S_STOPPED        = 0,
         BLK_MQ_S_TAG_ACTIVE     = 1,
@@ -140,6 +157,7 @@ enum {
 };
 
 struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *);
+void blk_mq_finish_init(struct request_queue *q);
 int blk_mq_register_disk(struct gendisk *);
 void blk_mq_unregister_disk(struct gendisk *);
 
@@ -151,16 +169,35 @@ void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule);
 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);
+void blk_mq_free_hctx_request(struct blk_mq_hw_ctx *, struct request *rq);
 bool blk_mq_can_queue(struct blk_mq_hw_ctx *);
 struct request *blk_mq_alloc_request(struct request_queue *q, int rw,
                 gfp_t gfp, bool reserved);
 struct request *blk_mq_tag_to_rq(struct blk_mq_tags *tags, unsigned int tag);
 
+enum {
+        BLK_MQ_UNIQUE_TAG_BITS = 16,
+        BLK_MQ_UNIQUE_TAG_MASK = (1 << BLK_MQ_UNIQUE_TAG_BITS) - 1,
+};
+
+u32 blk_mq_unique_tag(struct request *rq);
+
+static inline u16 blk_mq_unique_tag_to_hwq(u32 unique_tag)
+{
+        return unique_tag >> BLK_MQ_UNIQUE_TAG_BITS;
+}
+
+static inline u16 blk_mq_unique_tag_to_tag(u32 unique_tag)
+{
+        return unique_tag & BLK_MQ_UNIQUE_TAG_MASK;
+}
+
 struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *, const int ctx_index);
 struct blk_mq_hw_ctx *blk_mq_alloc_single_hw_queue(struct blk_mq_tag_set *, unsigned int, int);
 
-void blk_mq_end_io(struct request *rq, int error);
-void __blk_mq_end_io(struct request *rq, int error);
+void blk_mq_start_request(struct request *rq);
+void blk_mq_end_request(struct request *rq, int error);
+void __blk_mq_end_request(struct request *rq, int error);
 
 void blk_mq_requeue_request(struct request *rq);
 void blk_mq_add_to_requeue_list(struct request *rq, bool at_head);
@@ -173,7 +210,8 @@ void blk_mq_stop_hw_queues(struct request_queue *q);
 void blk_mq_start_hw_queues(struct request_queue *q);
 void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async);
 void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs);
-void blk_mq_tag_busy_iter(struct blk_mq_tags *tags, void (*fn)(void *data, unsigned long *), void *data);
+void blk_mq_tag_busy_iter(struct blk_mq_hw_ctx *hctx, busy_iter_fn *fn,
+                void *priv);
 
 /*
  * Driver command data is immediately after the request. So subtract request
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 66c2167f04a9..445d59231bc4 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -78,9 +78,11 @@ struct bio {
         struct io_context       *bi_ioc;
         struct cgroup_subsys_state *bi_css;
 #endif
+        union {
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
-        struct bio_integrity_payload *bi_integrity;  /* data integrity */
+                struct bio_integrity_payload *bi_integrity; /* data integrity */
 #endif
+        };
 
         unsigned short          bi_vcnt;        /* how many bio_vec's */
 
@@ -118,10 +120,8 @@ struct bio {
 #define BIO_USER_MAPPED 6       /* contains user pages */
 #define BIO_EOPNOTSUPP  7       /* not supported */
 #define BIO_NULL_MAPPED 8       /* contains invalid user pages */
-#define BIO_FS_INTEGRITY 9      /* fs owns integrity data, not block layer */
-#define BIO_QUIET       10      /* Make BIO Quiet */
-#define BIO_MAPPED_INTEGRITY 11/* integrity metadata has been remapped */
-#define BIO_SNAP_STABLE 12      /* bio data must be snapshotted during write */
+#define BIO_QUIET       9       /* Make BIO Quiet */
+#define BIO_SNAP_STABLE 10      /* bio data must be snapshotted during write */
 
 /*
  * Flags starting here get preserved by bio_reset() - this includes
@@ -162,6 +162,7 @@ enum rq_flag_bits {
         __REQ_WRITE_SAME,       /* write same block many times */
 
         __REQ_NOIDLE,           /* don't anticipate more IO after this one */
+        __REQ_INTEGRITY,        /* I/O includes block integrity payload */
         __REQ_FUA,              /* forced unit access */
         __REQ_FLUSH,            /* request for cache flush */
 
@@ -186,9 +187,7 @@ enum rq_flag_bits {
         __REQ_FLUSH_SEQ,        /* request for flush sequence */
         __REQ_IO_STAT,          /* account I/O stat */
         __REQ_MIXED_MERGE,      /* merge of different types, fail separately */
-        __REQ_KERNEL,           /* direct IO to kernel pages */
         __REQ_PM,               /* runtime pm request */
-        __REQ_END,              /* last of chain of requests */
         __REQ_HASHED,           /* on IO scheduler merge hash */
         __REQ_MQ_INFLIGHT,      /* track inflight for MQ */
         __REQ_NR_BITS,          /* stops here */
@@ -204,13 +203,14 @@ enum rq_flag_bits {
 #define REQ_DISCARD             (1ULL << __REQ_DISCARD)
 #define REQ_WRITE_SAME          (1ULL << __REQ_WRITE_SAME)
 #define REQ_NOIDLE              (1ULL << __REQ_NOIDLE)
+#define REQ_INTEGRITY           (1ULL << __REQ_INTEGRITY)
 
 #define REQ_FAILFAST_MASK \
         (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
 #define REQ_COMMON_MASK \
         (REQ_WRITE | REQ_FAILFAST_MASK | REQ_SYNC | REQ_META | REQ_PRIO | \
          REQ_DISCARD | REQ_WRITE_SAME | REQ_NOIDLE | REQ_FLUSH | REQ_FUA | \
-         REQ_SECURE)
+         REQ_SECURE | REQ_INTEGRITY)
 #define REQ_CLONE_MASK          REQ_COMMON_MASK
 
 #define BIO_NO_ADVANCE_ITER_MASK        (REQ_DISCARD|REQ_WRITE_SAME)
@@ -240,9 +240,7 @@ enum rq_flag_bits {
 #define REQ_IO_STAT             (1ULL << __REQ_IO_STAT)
 #define REQ_MIXED_MERGE         (1ULL << __REQ_MIXED_MERGE)
 #define REQ_SECURE              (1ULL << __REQ_SECURE)
-#define REQ_KERNEL              (1ULL << __REQ_KERNEL)
 #define REQ_PM                  (1ULL << __REQ_PM)
-#define REQ_END                 (1ULL << __REQ_END)
 #define REQ_HASHED              (1ULL << __REQ_HASHED)
 #define REQ_MQ_INFLIGHT         (1ULL << __REQ_MQ_INFLIGHT)
 
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 518b46555b80..92f4b4b288dd 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -36,6 +36,7 @@ struct request;
 struct sg_io_hdr;
 struct bsg_job;
 struct blkcg_gq;
+struct blk_flush_queue;
 
 #define BLKDEV_MIN_RQ   4
 #define BLKDEV_MAX_RQ   128     /* Default maximum */
@@ -397,7 +398,7 @@ struct request_queue {
          */
         struct kobject mq_kobj;
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         struct device           *dev;
         int                     rpm_status;
         unsigned int            nr_pending;
@@ -455,14 +456,7 @@ struct request_queue {
          */
         unsigned int            flush_flags;
         unsigned int            flush_not_queueable:1;
-        unsigned int            flush_queue_delayed:1;
-        unsigned int            flush_pending_idx:1;
-        unsigned int            flush_running_idx:1;
-        unsigned long           flush_pending_since;
-        struct list_head        flush_queue[2];
-        struct list_head        flush_data_in_flight;
-        struct request          *flush_rq;
-        spinlock_t              mq_flush_lock;
+        struct blk_flush_queue  *fq;
 
         struct list_head        requeue_list;
         spinlock_t              requeue_lock;
@@ -865,7 +859,7 @@ extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
 
 static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
 {
-        return bdev->bd_disk->queue;
+        return bdev->bd_disk->queue;    /* this is never NULL */
 }
 
 /*
@@ -1063,7 +1057,7 @@ extern void blk_put_queue(struct request_queue *);
 /*
  * block layer runtime pm functions
  */
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);
 extern int blk_pre_runtime_suspend(struct request_queue *q);
 extern void blk_post_runtime_suspend(struct request_queue *q, int err);
@@ -1142,8 +1136,6 @@ static inline bool blk_needs_flush_plug(struct task_struct *tsk)
 /*
  * tag stuff
  */
-#define blk_rq_tagged(rq) \
-        ((rq)->mq_ctx || ((rq)->cmd_flags & REQ_QUEUED))
 extern int blk_queue_start_tag(struct request_queue *, struct request *);
 extern struct request *blk_queue_find_tag(struct request_queue *, int);
 extern void blk_queue_end_tag(struct request_queue *, struct request *);
@@ -1192,7 +1184,6 @@ extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
 enum blk_default_limits {
         BLK_MAX_SEGMENTS        = 128,
         BLK_SAFE_MAX_SECTORS    = 255,
-        BLK_DEF_MAX_SECTORS     = 1024,
         BLK_MAX_SEGMENT_SIZE    = 65536,
         BLK_SEG_BOUNDARY_MASK   = 0xFFFFFFFFUL,
 };
@@ -1285,10 +1276,9 @@ static inline int queue_alignment_offset(struct request_queue *q)
 static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
 {
         unsigned int granularity = max(lim->physical_block_size, lim->io_min);
-        unsigned int alignment = (sector << 9) & (granularity - 1);
+        unsigned int alignment = sector_div(sector, granularity >> 9) << 9;
 
-        return (granularity + lim->alignment_offset - alignment)
-                & (granularity - 1);
+        return (granularity + lim->alignment_offset - alignment) % granularity;
 }
 
 static inline int bdev_alignment_offset(struct block_device *bdev)
@@ -1464,32 +1454,31 @@ static inline uint64_t rq_io_start_time_ns(struct request *req)
 
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
 
-#define INTEGRITY_FLAG_READ     2       /* verify data integrity on read */
-#define INTEGRITY_FLAG_WRITE    4       /* generate data integrity on write */
+enum blk_integrity_flags {
+        BLK_INTEGRITY_VERIFY            = 1 << 0,
+        BLK_INTEGRITY_GENERATE          = 1 << 1,
+        BLK_INTEGRITY_DEVICE_CAPABLE    = 1 << 2,
+        BLK_INTEGRITY_IP_CHECKSUM       = 1 << 3,
+};
 
-struct blk_integrity_exchg {
+struct blk_integrity_iter {
         void                    *prot_buf;
         void                    *data_buf;
-        sector_t                sector;
+        sector_t                seed;
         unsigned int            data_size;
-        unsigned short          sector_size;
+        unsigned short          interval;
         const char              *disk_name;
 };
 
-typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
-typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
-typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
-typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
+typedef int (integrity_processing_fn) (struct blk_integrity_iter *);
 
 struct blk_integrity {
-        integrity_gen_fn        *generate_fn;
-        integrity_vrfy_fn       *verify_fn;
-        integrity_set_tag_fn    *set_tag_fn;
-        integrity_get_tag_fn    *get_tag_fn;
+        integrity_processing_fn *generate_fn;
+        integrity_processing_fn *verify_fn;
 
         unsigned short          flags;
         unsigned short          tuple_size;
-        unsigned short          sector_size;
+        unsigned short          interval;
         unsigned short          tag_size;
 
         const char              *name;
@@ -1504,10 +1493,10 @@ extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
 extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
                                    struct scatterlist *);
 extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
-extern int blk_integrity_merge_rq(struct request_queue *, struct request *,
-                                  struct request *);
-extern int blk_integrity_merge_bio(struct request_queue *, struct request *,
-                                   struct bio *);
+extern bool blk_integrity_merge_rq(struct request_queue *, struct request *,
+                                   struct request *);
+extern bool blk_integrity_merge_bio(struct request_queue *, struct request *,
+                                    struct bio *);
 
 static inline
 struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
@@ -1520,12 +1509,9 @@ static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
         return disk->integrity;
 }
 
-static inline int blk_integrity_rq(struct request *rq)
+static inline bool blk_integrity_rq(struct request *rq)
 {
-        if (rq->bio == NULL)
-                return 0;
-
-        return bio_integrity(rq->bio);
+        return rq->cmd_flags & REQ_INTEGRITY;
 }
 
 static inline void blk_queue_max_integrity_segments(struct request_queue *q,
@@ -1564,7 +1550,7 @@ static inline int blk_rq_map_integrity_sg(struct request_queue *q,
 }
 static inline struct blk_integrity *bdev_get_integrity(struct block_device *b)
 {
-        return 0;
+        return NULL;
 }
 static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
 {
@@ -1590,17 +1576,17 @@ static inline unsigned short queue_max_integrity_segments(struct request_queue *
 {
         return 0;
 }
-static inline int blk_integrity_merge_rq(struct request_queue *rq,
-                                         struct request *r1,
-                                         struct request *r2)
+static inline bool blk_integrity_merge_rq(struct request_queue *rq,
+                                          struct request *r1,
+                                          struct request *r2)
 {
-        return 0;
+        return true;
 }
-static inline int blk_integrity_merge_bio(struct request_queue *rq,
-                                          struct request *r,
-                                          struct bio *b)
+static inline bool blk_integrity_merge_bio(struct request_queue *rq,
+                                           struct request *r,
+                                           struct bio *b)
 {
-        return 0;
+        return true;
 }
 static inline bool blk_integrity_is_initialized(struct gendisk *g)
 {
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 4e2bd4c95b66..0995c2de8162 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -46,6 +46,7 @@ extern unsigned long init_bootmem_node(pg_data_t *pgdat,
 extern unsigned long init_bootmem(unsigned long addr, unsigned long memend);
 
 extern unsigned long free_all_bootmem(void);
+extern void reset_node_managed_pages(pg_data_t *pgdat);
 extern void reset_all_zones_managed_pages(void);
 
 extern void free_bootmem_node(pg_data_t *pgdat,
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
new file mode 100644
index 000000000000..bbfceb756452
--- /dev/null
+++ b/include/linux/bpf.h
@@ -0,0 +1,145 @@
+/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
+ *
+ * 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_BPF_H
+#define _LINUX_BPF_H 1
+
+#include <uapi/linux/bpf.h>
+#include <linux/workqueue.h>
+#include <linux/file.h>
+
+struct bpf_map;
+
+/* map is generic key/value storage optionally accesible by eBPF programs */
+struct bpf_map_ops {
+        /* funcs callable from userspace (via syscall) */
+        struct bpf_map *(*map_alloc)(union bpf_attr *attr);
+        void (*map_free)(struct bpf_map *);
+        int (*map_get_next_key)(struct bpf_map *map, void *key, void *next_key);
+
+        /* funcs callable from userspace and from eBPF programs */
+        void *(*map_lookup_elem)(struct bpf_map *map, void *key);
+        int (*map_update_elem)(struct bpf_map *map, void *key, void *value, u64 flags);
+        int (*map_delete_elem)(struct bpf_map *map, void *key);
+};
+
+struct bpf_map {
+        atomic_t refcnt;
+        enum bpf_map_type map_type;
+        u32 key_size;
+        u32 value_size;
+        u32 max_entries;
+        struct bpf_map_ops *ops;
+        struct work_struct work;
+};
+
+struct bpf_map_type_list {
+        struct list_head list_node;
+        struct bpf_map_ops *ops;
+        enum bpf_map_type type;
+};
+
+void bpf_register_map_type(struct bpf_map_type_list *tl);
+void bpf_map_put(struct bpf_map *map);
+struct bpf_map *bpf_map_get(struct fd f);
+
+/* function argument constraints */
+enum bpf_arg_type {
+        ARG_ANYTHING = 0,       /* any argument is ok */
+
+        /* the following constraints used to prototype
+         * bpf_map_lookup/update/delete_elem() functions
+         */
+        ARG_CONST_MAP_PTR,      /* const argument used as pointer to bpf_map */
+        ARG_PTR_TO_MAP_KEY,     /* pointer to stack used as map key */
+        ARG_PTR_TO_MAP_VALUE,   /* pointer to stack used as map value */
+
+        /* the following constraints used to prototype bpf_memcmp() and other
+         * functions that access data on eBPF program stack
+         */
+        ARG_PTR_TO_STACK,       /* any pointer to eBPF program stack */
+        ARG_CONST_STACK_SIZE,   /* number of bytes accessed from stack */
+};
+
+/* type of values returned from helper functions */
+enum bpf_return_type {
+        RET_INTEGER,                    /* function returns integer */
+        RET_VOID,                       /* function doesn't return anything */
+        RET_PTR_TO_MAP_VALUE_OR_NULL,   /* returns a pointer to map elem value or NULL */
+};
+
+/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs
+ * to in-kernel helper functions and for adjusting imm32 field in BPF_CALL
+ * instructions after verifying
+ */
+struct bpf_func_proto {
+        u64 (*func)(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
+        bool gpl_only;
+        enum bpf_return_type ret_type;
+        enum bpf_arg_type arg1_type;
+        enum bpf_arg_type arg2_type;
+        enum bpf_arg_type arg3_type;
+        enum bpf_arg_type arg4_type;
+        enum bpf_arg_type arg5_type;
+};
+
+/* bpf_context is intentionally undefined structure. Pointer to bpf_context is
+ * the first argument to eBPF programs.
+ * For socket filters: 'struct bpf_context *' == 'struct sk_buff *'
+ */
+struct bpf_context;
+
+enum bpf_access_type {
+        BPF_READ = 1,
+        BPF_WRITE = 2
+};
+
+struct bpf_verifier_ops {
+        /* return eBPF function prototype for verification */
+        const struct bpf_func_proto *(*get_func_proto)(enum bpf_func_id func_id);
+
+        /* return true if 'size' wide access at offset 'off' within bpf_context
+         * with 'type' (read or write) is allowed
+         */
+        bool (*is_valid_access)(int off, int size, enum bpf_access_type type);
+};
+
+struct bpf_prog_type_list {
+        struct list_head list_node;
+        struct bpf_verifier_ops *ops;
+        enum bpf_prog_type type;
+};
+
+void bpf_register_prog_type(struct bpf_prog_type_list *tl);
+
+struct bpf_prog;
+
+struct bpf_prog_aux {
+        atomic_t refcnt;
+        bool is_gpl_compatible;
+        enum bpf_prog_type prog_type;
+        struct bpf_verifier_ops *ops;
+        struct bpf_map **used_maps;
+        u32 used_map_cnt;
+        struct bpf_prog *prog;
+        struct work_struct work;
+};
+
+#ifdef CONFIG_BPF_SYSCALL
+void bpf_prog_put(struct bpf_prog *prog);
+#else
+static inline void bpf_prog_put(struct bpf_prog *prog) {}
+#endif
+struct bpf_prog *bpf_prog_get(u32 ufd);
+/* verify correctness of eBPF program */
+int bpf_check(struct bpf_prog *fp, union bpf_attr *attr);
+
+/* verifier prototypes for helper functions called from eBPF programs */
+extern struct bpf_func_proto bpf_map_lookup_elem_proto;
+extern struct bpf_func_proto bpf_map_update_elem_proto;
+extern struct bpf_func_proto bpf_map_delete_elem_proto;
+
+#endif /* _LINUX_BPF_H */
diff --git a/include/linux/brcmphy.h b/include/linux/brcmphy.h
index 61219b9b3445..7ccd928cc1f2 100644
--- a/include/linux/brcmphy.h
+++ b/include/linux/brcmphy.h
@@ -13,7 +13,11 @@
 #define PHY_ID_BCM5461                  0x002060c0
 #define PHY_ID_BCM57780                 0x03625d90
 
+#define PHY_ID_BCM7250                  0xae025280
+#define PHY_ID_BCM7364                  0xae025260
 #define PHY_ID_BCM7366                  0x600d8490
+#define PHY_ID_BCM7425                  0x03625e60
+#define PHY_ID_BCM7429                  0x600d8730
 #define PHY_ID_BCM7439                  0x600d8480
 #define PHY_ID_BCM7445                  0x600d8510
 
@@ -21,9 +25,9 @@
 #define PHY_BCM_OUI_1                   0x00206000
 #define PHY_BCM_OUI_2                   0x0143bc00
 #define PHY_BCM_OUI_3                   0x03625c00
-#define PHY_BCM_OUI_4                   0x600d0000
+#define PHY_BCM_OUI_4                   0x600d8400
 #define PHY_BCM_OUI_5                   0x03625e00
-
+#define PHY_BCM_OUI_6                   0xae025000
 
 #define PHY_BCM_FLAGS_MODE_COPPER       0x00000001
 #define PHY_BCM_FLAGS_MODE_1000BX       0x00000002
@@ -38,7 +42,8 @@
 #define PHY_BRCM_CLEAR_RGMII_MODE       0x00004000
 #define PHY_BRCM_DIS_TXCRXC_NOENRGY     0x00008000
 /* Broadcom BCM7xxx specific workarounds */
-#define PHY_BRCM_100MBPS_WAR            0x00010000
+#define PHY_BRCM_7XXX_REV(x)            (((x) >> 8) & 0xff)
+#define PHY_BRCM_7XXX_PATCH(x)          ((x) & 0xff)
 #define PHY_BCM_FLAGS_VALID             0x80000000
 
 /* Broadcom BCM54XX register definitions, common to most Broadcom PHYs */
@@ -92,4 +97,130 @@
 
 #define MII_BCM54XX_AUXCTL_SHDWSEL_AUXCTL       0x0000
 
+/*
+ * Broadcom LED source encodings.  These are used in BCM5461, BCM5481,
+ * BCM5482, and possibly some others.
+ */
+#define BCM_LED_SRC_LINKSPD1    0x0
+#define BCM_LED_SRC_LINKSPD2    0x1
+#define BCM_LED_SRC_XMITLED     0x2
+#define BCM_LED_SRC_ACTIVITYLED 0x3
+#define BCM_LED_SRC_FDXLED      0x4
+#define BCM_LED_SRC_SLAVE       0x5
+#define BCM_LED_SRC_INTR        0x6
+#define BCM_LED_SRC_QUALITY     0x7
+#define BCM_LED_SRC_RCVLED      0x8
+#define BCM_LED_SRC_MULTICOLOR1 0xa
+#define BCM_LED_SRC_OPENSHORT   0xb
+#define BCM_LED_SRC_OFF         0xe     /* Tied high */
+#define BCM_LED_SRC_ON          0xf     /* Tied low */
+
+
+/*
+ * BCM5482: Shadow registers
+ * Shadow values go into bits [14:10] of register 0x1c to select a shadow
+ * register to access.
+ */
+/* 00101: Spare Control Register 3 */
+#define BCM54XX_SHD_SCR3                0x05
+#define  BCM54XX_SHD_SCR3_DEF_CLK125    0x0001
+#define  BCM54XX_SHD_SCR3_DLLAPD_DIS    0x0002
+#define  BCM54XX_SHD_SCR3_TRDDAPD       0x0004
+
+/* 01010: Auto Power-Down */
+#define BCM54XX_SHD_APD                 0x0a
+#define  BCM54XX_SHD_APD_EN             0x0020
+
+#define BCM5482_SHD_LEDS1       0x0d    /* 01101: LED Selector 1 */
+                                        /* LED3 / ~LINKSPD[2] selector */
+#define BCM5482_SHD_LEDS1_LED3(src)     ((src & 0xf) << 4)
+                                        /* LED1 / ~LINKSPD[1] selector */
+#define BCM5482_SHD_LEDS1_LED1(src)     ((src & 0xf) << 0)
+#define BCM54XX_SHD_RGMII_MODE  0x0b    /* 01011: RGMII Mode Selector */
+#define BCM5482_SHD_SSD         0x14    /* 10100: Secondary SerDes control */
+#define BCM5482_SHD_SSD_LEDM    0x0008  /* SSD LED Mode enable */
+#define BCM5482_SHD_SSD_EN      0x0001  /* SSD enable */
+#define BCM5482_SHD_MODE        0x1f    /* 11111: Mode Control Register */
+#define BCM5482_SHD_MODE_1000BX 0x0001  /* Enable 1000BASE-X registers */
+
+
+/*
+ * EXPANSION SHADOW ACCESS REGISTERS.  (PHY REG 0x15, 0x16, and 0x17)
+ */
+#define MII_BCM54XX_EXP_AADJ1CH0                0x001f
+#define  MII_BCM54XX_EXP_AADJ1CH0_SWP_ABCD_OEN  0x0200
+#define  MII_BCM54XX_EXP_AADJ1CH0_SWSEL_THPF    0x0100
+#define MII_BCM54XX_EXP_AADJ1CH3                0x601f
+#define  MII_BCM54XX_EXP_AADJ1CH3_ADCCKADJ      0x0002
+#define MII_BCM54XX_EXP_EXP08                   0x0F08
+#define  MII_BCM54XX_EXP_EXP08_RJCT_2MHZ        0x0001
+#define  MII_BCM54XX_EXP_EXP08_EARLY_DAC_WAKE   0x0200
+#define MII_BCM54XX_EXP_EXP75                   0x0f75
+#define  MII_BCM54XX_EXP_EXP75_VDACCTRL         0x003c
+#define  MII_BCM54XX_EXP_EXP75_CM_OSC           0x0001
+#define MII_BCM54XX_EXP_EXP96                   0x0f96
+#define  MII_BCM54XX_EXP_EXP96_MYST             0x0010
+#define MII_BCM54XX_EXP_EXP97                   0x0f97
+#define  MII_BCM54XX_EXP_EXP97_MYST             0x0c0c
+
+/*
+ * BCM5482: Secondary SerDes registers
+ */
+#define BCM5482_SSD_1000BX_CTL          0x00    /* 1000BASE-X Control */
+#define BCM5482_SSD_1000BX_CTL_PWRDOWN  0x0800  /* Power-down SSD */
+#define BCM5482_SSD_SGMII_SLAVE         0x15    /* SGMII Slave Register */
+#define BCM5482_SSD_SGMII_SLAVE_EN      0x0002  /* Slave mode enable */
+#define BCM5482_SSD_SGMII_SLAVE_AD      0x0001  /* Slave auto-detection */
+
+
+/*****************************************************************************/
+/* Fast Ethernet Transceiver definitions. */
+/*****************************************************************************/
+
+#define MII_BRCM_FET_INTREG             0x1a    /* Interrupt register */
+#define MII_BRCM_FET_IR_MASK            0x0100  /* Mask all interrupts */
+#define MII_BRCM_FET_IR_LINK_EN         0x0200  /* Link status change enable */
+#define MII_BRCM_FET_IR_SPEED_EN        0x0400  /* Link speed change enable */
+#define MII_BRCM_FET_IR_DUPLEX_EN       0x0800  /* Duplex mode change enable */
+#define MII_BRCM_FET_IR_ENABLE          0x4000  /* Interrupt enable */
+
+#define MII_BRCM_FET_BRCMTEST           0x1f    /* Brcm test register */
+#define MII_BRCM_FET_BT_SRE             0x0080  /* Shadow register enable */
+
+
+/*** Shadow register definitions ***/
+
+#define MII_BRCM_FET_SHDW_MISCCTRL      0x10    /* Shadow misc ctrl */
+#define MII_BRCM_FET_SHDW_MC_FAME       0x4000  /* Force Auto MDIX enable */
+
+#define MII_BRCM_FET_SHDW_AUXMODE4      0x1a    /* Auxiliary mode 4 */
+#define MII_BRCM_FET_SHDW_AM4_LED_MASK  0x0003
+#define MII_BRCM_FET_SHDW_AM4_LED_MODE1 0x0001
+
+#define MII_BRCM_FET_SHDW_AUXSTAT2      0x1b    /* Auxiliary status 2 */
+#define MII_BRCM_FET_SHDW_AS2_APDE      0x0020  /* Auto power down enable */
+
+/*
+ * Indirect register access functions for the 1000BASE-T/100BASE-TX/10BASE-T
+ * 0x1c shadow registers.
+ */
+static inline int bcm54xx_shadow_read(struct phy_device *phydev, u16 shadow)
+{
+        phy_write(phydev, MII_BCM54XX_SHD, MII_BCM54XX_SHD_VAL(shadow));
+        return MII_BCM54XX_SHD_DATA(phy_read(phydev, MII_BCM54XX_SHD));
+}
+
+static inline int bcm54xx_shadow_write(struct phy_device *phydev, u16 shadow,
+                                       u16 val)
+{
+        return phy_write(phydev, MII_BCM54XX_SHD,
+                         MII_BCM54XX_SHD_WRITE |
+                         MII_BCM54XX_SHD_VAL(shadow) |
+                         MII_BCM54XX_SHD_DATA(val));
+}
+
+#define BRCM_CL45VEN_EEE_CONTROL        0x803d
+#define LPI_FEATURE_EN                  0x8000
+#define LPI_FEATURE_EN_DIG1000X         0x4000
+
 #endif /* _LINUX_BRCMPHY_H */
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 324329ceea1e..73b45225a7ca 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -175,12 +175,13 @@ void __wait_on_buffer(struct buffer_head *);
 wait_queue_head_t *bh_waitq_head(struct buffer_head *bh);
 struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block,
                         unsigned size);
-struct buffer_head *__getblk(struct block_device *bdev, sector_t block,
-                        unsigned size);
+struct buffer_head *__getblk_gfp(struct block_device *bdev, sector_t block,
+                                  unsigned size, gfp_t gfp);
 void __brelse(struct buffer_head *);
 void __bforget(struct buffer_head *);
 void __breadahead(struct block_device *, sector_t block, unsigned int size);
-struct buffer_head *__bread(struct block_device *, sector_t block, unsigned size);
+struct buffer_head *__bread_gfp(struct block_device *,
+                                sector_t block, unsigned size, gfp_t gfp);
 void invalidate_bh_lrus(void);
 struct buffer_head *alloc_buffer_head(gfp_t gfp_flags);
 void free_buffer_head(struct buffer_head * bh);
@@ -295,7 +296,13 @@ static inline void bforget(struct buffer_head *bh)
 static inline struct buffer_head *
 sb_bread(struct super_block *sb, sector_t block)
 {
-        return __bread(sb->s_bdev, block, sb->s_blocksize);
+        return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE);
+}
+
+static inline struct buffer_head *
+sb_bread_unmovable(struct super_block *sb, sector_t block)
+{
+        return __bread_gfp(sb->s_bdev, block, sb->s_blocksize, 0);
 }
 
 static inline void
@@ -307,7 +314,7 @@ sb_breadahead(struct super_block *sb, sector_t block)
 static inline struct buffer_head *
 sb_getblk(struct super_block *sb, sector_t block)
 {
-        return __getblk(sb->s_bdev, block, sb->s_blocksize);
+        return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE);
 }
 
 static inline struct buffer_head *
@@ -344,6 +351,36 @@ static inline void lock_buffer(struct buffer_head *bh)
                 __lock_buffer(bh);
 }
 
+static inline struct buffer_head *getblk_unmovable(struct block_device *bdev,
+                                                   sector_t block,
+                                                   unsigned size)
+{
+        return __getblk_gfp(bdev, block, size, 0);
+}
+
+static inline struct buffer_head *__getblk(struct block_device *bdev,
+                                           sector_t block,
+                                           unsigned size)
+{
+        return __getblk_gfp(bdev, block, size, __GFP_MOVABLE);
+}
+
+/**
+ *  __bread() - reads a specified block and returns the bh
+ *  @bdev: the block_device to read from
+ *  @block: number of block
+ *  @size: size (in bytes) to read
+ *
+ *  Reads a specified block, and returns buffer head that contains it.
+ *  The page cache is allocated from movable area so that it can be migrated.
+ *  It returns NULL if the block was unreadable.
+ */
+static inline struct buffer_head *
+__bread(struct block_device *bdev, sector_t block, unsigned size)
+{
+        return __bread_gfp(bdev, block, size, __GFP_MOVABLE);
+}
+
 extern int __set_page_dirty_buffers(struct page *page);
 
 #else /* CONFIG_BLOCK */
diff --git a/include/linux/cacheinfo.h b/include/linux/cacheinfo.h
new file mode 100644
index 000000000000..3daf5ed392c9
--- /dev/null
+++ b/include/linux/cacheinfo.h
@@ -0,0 +1,100 @@
+#ifndef _LINUX_CACHEINFO_H
+#define _LINUX_CACHEINFO_H
+
+#include <linux/bitops.h>
+#include <linux/cpumask.h>
+#include <linux/smp.h>
+
+struct device_node;
+struct attribute;
+
+enum cache_type {
+        CACHE_TYPE_NOCACHE = 0,
+        CACHE_TYPE_INST = BIT(0),
+        CACHE_TYPE_DATA = BIT(1),
+        CACHE_TYPE_SEPARATE = CACHE_TYPE_INST | CACHE_TYPE_DATA,
+        CACHE_TYPE_UNIFIED = BIT(2),
+};
+
+/**
+ * struct cacheinfo - represent a cache leaf node
+ * @type: type of the cache - data, inst or unified
+ * @level: represents the hierarcy in the multi-level cache
+ * @coherency_line_size: size of each cache line usually representing
+ *      the minimum amount of data that gets transferred from memory
+ * @number_of_sets: total number of sets, a set is a collection of cache
+ *      lines sharing the same index
+ * @ways_of_associativity: number of ways in which a particular memory
+ *      block can be placed in the cache
+ * @physical_line_partition: number of physical cache lines sharing the
+ *      same cachetag
+ * @size: Total size of the cache
+ * @shared_cpu_map: logical cpumask representing all the cpus sharing
+ *      this cache node
+ * @attributes: bitfield representing various cache attributes
+ * @of_node: if devicetree is used, this represents either the cpu node in
+ *      case there's no explicit cache node or the cache node itself in the
+ *      device tree
+ * @disable_sysfs: indicates whether this node is visible to the user via
+ *      sysfs or not
+ * @priv: pointer to any private data structure specific to particular
+ *      cache design
+ *
+ * While @of_node, @disable_sysfs and @priv are used for internal book
+ * keeping, the remaining members form the core properties of the cache
+ */
+struct cacheinfo {
+        enum cache_type type;
+        unsigned int level;
+        unsigned int coherency_line_size;
+        unsigned int number_of_sets;
+        unsigned int ways_of_associativity;
+        unsigned int physical_line_partition;
+        unsigned int size;
+        cpumask_t shared_cpu_map;
+        unsigned int attributes;
+#define CACHE_WRITE_THROUGH     BIT(0)
+#define CACHE_WRITE_BACK        BIT(1)
+#define CACHE_WRITE_POLICY_MASK         \
+        (CACHE_WRITE_THROUGH | CACHE_WRITE_BACK)
+#define CACHE_READ_ALLOCATE     BIT(2)
+#define CACHE_WRITE_ALLOCATE    BIT(3)
+#define CACHE_ALLOCATE_POLICY_MASK      \
+        (CACHE_READ_ALLOCATE | CACHE_WRITE_ALLOCATE)
+
+        struct device_node *of_node;
+        bool disable_sysfs;
+        void *priv;
+};
+
+struct cpu_cacheinfo {
+        struct cacheinfo *info_list;
+        unsigned int num_levels;
+        unsigned int num_leaves;
+};
+
+/*
+ * Helpers to make sure "func" is executed on the cpu whose cache
+ * attributes are being detected
+ */
+#define DEFINE_SMP_CALL_CACHE_FUNCTION(func)                    \
+static inline void _##func(void *ret)                           \
+{                                                               \
+        int cpu = smp_processor_id();                           \
+        *(int *)ret = __##func(cpu);                            \
+}                                                               \
+                                                                \
+int func(unsigned int cpu)                                      \
+{                                                               \
+        int ret;                                                \
+        smp_call_function_single(cpu, _##func, &ret, true);     \
+        return ret;                                             \
+}
+
+struct cpu_cacheinfo *get_cpu_cacheinfo(unsigned int cpu);
+int init_cache_level(unsigned int cpu);
+int populate_cache_leaves(unsigned int cpu);
+
+const struct attribute_group *cache_get_priv_group(struct cacheinfo *this_leaf);
+
+#endif /* _LINUX_CACHEINFO_H */
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index 6992afc6ba7f..c05ff0f9f9a5 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -99,6 +99,12 @@ inval_skb:
         return 1;
 }
 
+static inline bool can_is_canfd_skb(const struct sk_buff *skb)
+{
+        /* the CAN specific type of skb is identified by its data length */
+        return skb->len == CANFD_MTU;
+}
+
 /* get data length from can_dlc with sanitized can_dlc */
 u8 can_dlc2len(u8 can_dlc);
 
@@ -121,6 +127,9 @@ void unregister_candev(struct net_device *dev);
 int can_restart_now(struct net_device *dev);
 void can_bus_off(struct net_device *dev);
 
+void can_change_state(struct net_device *dev, struct can_frame *cf,
+                      enum can_state tx_state, enum can_state rx_state);
+
 void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
                       unsigned int idx);
 unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
diff --git a/include/linux/ceph/auth.h b/include/linux/ceph/auth.h
index 5f3386844134..260d78b587c4 100644
--- a/include/linux/ceph/auth.h
+++ b/include/linux/ceph/auth.h
@@ -13,6 +13,7 @@
 
 struct ceph_auth_client;
 struct ceph_authorizer;
+struct ceph_msg;
 
 struct ceph_auth_handshake {
         struct ceph_authorizer *authorizer;
@@ -20,6 +21,10 @@ struct ceph_auth_handshake {
         size_t authorizer_buf_len;
         void *authorizer_reply_buf;
         size_t authorizer_reply_buf_len;
+        int (*sign_message)(struct ceph_auth_handshake *auth,
+                            struct ceph_msg *msg);
+        int (*check_message_signature)(struct ceph_auth_handshake *auth,
+                                       struct ceph_msg *msg);
 };
 
 struct ceph_auth_client_ops {
@@ -66,6 +71,11 @@ struct ceph_auth_client_ops {
         void (*reset)(struct ceph_auth_client *ac);
 
         void (*destroy)(struct ceph_auth_client *ac);
+
+        int (*sign_message)(struct ceph_auth_handshake *auth,
+                            struct ceph_msg *msg);
+        int (*check_message_signature)(struct ceph_auth_handshake *auth,
+                                       struct ceph_msg *msg);
 };
 
 struct ceph_auth_client {
@@ -113,4 +123,20 @@ extern int ceph_auth_verify_authorizer_reply(struct ceph_auth_client *ac,
 extern void ceph_auth_invalidate_authorizer(struct ceph_auth_client *ac,
                                             int peer_type);
 
+static inline int ceph_auth_sign_message(struct ceph_auth_handshake *auth,
+                                         struct ceph_msg *msg)
+{
+        if (auth->sign_message)
+                return auth->sign_message(auth, msg);
+        return 0;
+}
+
+static inline
+int ceph_auth_check_message_signature(struct ceph_auth_handshake *auth,
+                                      struct ceph_msg *msg)
+{
+        if (auth->check_message_signature)
+                return auth->check_message_signature(auth, msg);
+        return 0;
+}
 #endif
diff --git a/include/linux/ceph/buffer.h b/include/linux/ceph/buffer.h
index 07ad423cc37f..07ca15e76100 100644
--- a/include/linux/ceph/buffer.h
+++ b/include/linux/ceph/buffer.h
@@ -10,8 +10,7 @@
 /*
  * a simple reference counted buffer.
  *
- * use kmalloc for small sizes (<= one page), vmalloc for larger
- * sizes.
+ * use kmalloc for smaller sizes, vmalloc for larger sizes.
  */
 struct ceph_buffer {
         struct kref kref;
diff --git a/include/linux/ceph/ceph_features.h b/include/linux/ceph/ceph_features.h
index d12659ce550d..71e05bbf8ceb 100644
--- a/include/linux/ceph/ceph_features.h
+++ b/include/linux/ceph/ceph_features.h
@@ -84,6 +84,7 @@ static inline u64 ceph_sanitize_features(u64 features)
          CEPH_FEATURE_PGPOOL3 |                 \
          CEPH_FEATURE_OSDENC |                  \
          CEPH_FEATURE_CRUSH_TUNABLES |          \
+         CEPH_FEATURE_MSG_AUTH |                \
          CEPH_FEATURE_CRUSH_TUNABLES2 |         \
          CEPH_FEATURE_REPLY_CREATE_INODE |      \
          CEPH_FEATURE_OSDHASHPSPOOL |           \
diff --git a/include/linux/ceph/ceph_fs.h b/include/linux/ceph/ceph_fs.h
index 3c97d5e9b951..c0dadaac26e3 100644
--- a/include/linux/ceph/ceph_fs.h
+++ b/include/linux/ceph/ceph_fs.h
@@ -522,8 +522,11 @@ struct ceph_mds_reply_dirfrag {
         __le32 dist[];
 } __attribute__ ((packed));
 
-#define CEPH_LOCK_FCNTL    1
-#define CEPH_LOCK_FLOCK    2
+#define CEPH_LOCK_FCNTL         1
+#define CEPH_LOCK_FLOCK         2
+#define CEPH_LOCK_FCNTL_INTR    3
+#define CEPH_LOCK_FLOCK_INTR    4
+
 
 #define CEPH_LOCK_SHARED   1
 #define CEPH_LOCK_EXCL     2
@@ -549,6 +552,7 @@ struct ceph_filelock {
 
 int ceph_flags_to_mode(int flags);
 
+#define CEPH_INLINE_NONE        ((__u64)-1)
 
 /* capability bits */
 #define CEPH_CAP_PIN         1  /* no specific capabilities beyond the pin */
@@ -613,6 +617,8 @@ int ceph_flags_to_mode(int flags);
                                  CEPH_CAP_LINK_SHARED | \
                                  CEPH_CAP_FILE_SHARED | \
                                  CEPH_CAP_XATTR_SHARED)
+#define CEPH_STAT_CAP_INLINE_DATA (CEPH_CAP_FILE_SHARED | \
+                                   CEPH_CAP_FILE_RD)
 
 #define CEPH_CAP_ANY_SHARED (CEPH_CAP_AUTH_SHARED |                     \
                               CEPH_CAP_LINK_SHARED |                    \
diff --git a/include/linux/ceph/libceph.h b/include/linux/ceph/libceph.h
index 279b0afac1c1..8b11a79ca1cb 100644
--- a/include/linux/ceph/libceph.h
+++ b/include/linux/ceph/libceph.h
@@ -29,6 +29,7 @@
 #define CEPH_OPT_NOSHARE          (1<<1) /* don't share client with other sbs */
 #define CEPH_OPT_MYIP             (1<<2) /* specified my ip */
 #define CEPH_OPT_NOCRC            (1<<3) /* no data crc on writes */
+#define CEPH_OPT_NOMSGAUTH        (1<<4) /* not require cephx message signature */
 
 #define CEPH_OPT_DEFAULT   (0)
 
@@ -184,7 +185,6 @@ extern bool libceph_compatible(void *data);
 extern const char *ceph_msg_type_name(int type);
 extern int ceph_check_fsid(struct ceph_client *client, struct ceph_fsid *fsid);
 extern void *ceph_kvmalloc(size_t size, gfp_t flags);
-extern void ceph_kvfree(const void *ptr);
 
 extern struct ceph_options *ceph_parse_options(char *options,
                               const char *dev_name, const char *dev_name_end,
@@ -211,7 +211,6 @@ extern struct page **ceph_get_direct_page_vector(const void __user *data,
                                                  bool write_page);
 extern void ceph_put_page_vector(struct page **pages, int num_pages,
                                  bool dirty);
-extern void ceph_release_page_vector(struct page **pages, int num_pages);
 extern struct page **ceph_alloc_page_vector(int num_pages, gfp_t flags);
 extern int ceph_copy_user_to_page_vector(struct page **pages,
                                          const void __user *data,
diff --git a/include/linux/ceph/messenger.h b/include/linux/ceph/messenger.h
index 40ae58e3e9db..d9d396c16503 100644
--- a/include/linux/ceph/messenger.h
+++ b/include/linux/ceph/messenger.h
@@ -42,6 +42,10 @@ struct ceph_connection_operations {
         struct ceph_msg * (*alloc_msg) (struct ceph_connection *con,
                                         struct ceph_msg_header *hdr,
                                         int *skip);
+        int (*sign_message) (struct ceph_connection *con, struct ceph_msg *msg);
+
+        int (*check_message_signature) (struct ceph_connection *con,
+                                        struct ceph_msg *msg);
 };
 
 /* use format string %s%d */
@@ -142,7 +146,10 @@ struct ceph_msg_data_cursor {
  */
 struct ceph_msg {
         struct ceph_msg_header hdr;     /* header */
-        struct ceph_msg_footer footer;  /* footer */
+        union {
+                struct ceph_msg_footer footer;          /* footer */
+                struct ceph_msg_footer_old old_footer;  /* old format footer */
+        };
         struct kvec front;              /* unaligned blobs of message */
         struct ceph_buffer *middle;
 
diff --git a/include/linux/ceph/msgr.h b/include/linux/ceph/msgr.h
index 3d94a73b5f30..1c1887206ffa 100644
--- a/include/linux/ceph/msgr.h
+++ b/include/linux/ceph/msgr.h
@@ -152,7 +152,8 @@ struct ceph_msg_header {
                              receiver: mask against ~PAGE_MASK */
 
         struct ceph_entity_name src;
-        __le32 reserved;
+        __le16 compat_version;
+        __le16 reserved;
         __le32 crc;       /* header crc32c */
 } __attribute__ ((packed));
 
@@ -164,13 +165,21 @@ struct ceph_msg_header {
 /*
  * follows data payload
  */
+struct ceph_msg_footer_old {
+        __le32 front_crc, middle_crc, data_crc;
+        __u8 flags;
+} __attribute__ ((packed));
+
 struct ceph_msg_footer {
         __le32 front_crc, middle_crc, data_crc;
+        // sig holds the 64 bits of the digital signature for the message PLR
+        __le64  sig;
         __u8 flags;
 } __attribute__ ((packed));
 
 #define CEPH_MSG_FOOTER_COMPLETE  (1<<0)   /* msg wasn't aborted */
 #define CEPH_MSG_FOOTER_NOCRC     (1<<1)   /* no data crc */
+#define CEPH_MSG_FOOTER_SIGNED    (1<<2)   /* msg was signed */
 
 
 #endif
diff --git a/include/linux/ceph/osd_client.h b/include/linux/ceph/osd_client.h
index 03aeb27fcc69..61b19c46bdb3 100644
--- a/include/linux/ceph/osd_client.h
+++ b/include/linux/ceph/osd_client.h
@@ -87,6 +87,13 @@ struct ceph_osd_req_op {
                         struct ceph_osd_data osd_data;
                 } extent;
                 struct {
+                        u32 name_len;
+                        u32 value_len;
+                        __u8 cmp_op;       /* CEPH_OSD_CMPXATTR_OP_* */
+                        __u8 cmp_mode;     /* CEPH_OSD_CMPXATTR_MODE_* */
+                        struct ceph_osd_data osd_data;
+                } xattr;
+                struct {
                         const char *class_name;
                         const char *method_name;
                         struct ceph_osd_data request_info;
@@ -295,6 +302,9 @@ extern void osd_req_op_cls_response_data_pages(struct ceph_osd_request *,
 extern void osd_req_op_cls_init(struct ceph_osd_request *osd_req,
                                         unsigned int which, u16 opcode,
                                         const char *class, const char *method);
+extern int osd_req_op_xattr_init(struct ceph_osd_request *osd_req, unsigned int which,
+                                 u16 opcode, const char *name, const void *value,
+                                 size_t size, u8 cmp_op, u8 cmp_mode);
 extern void osd_req_op_watch_init(struct ceph_osd_request *osd_req,
                                         unsigned int which, u16 opcode,
                                         u64 cookie, u64 version, int flag);
@@ -318,7 +328,8 @@ extern struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *,
                                       struct ceph_file_layout *layout,
                                       struct ceph_vino vino,
                                       u64 offset, u64 *len,
-                                      int num_ops, int opcode, int flags,
+                                      unsigned int which, int num_ops,
+                                      int opcode, int flags,
                                       struct ceph_snap_context *snapc,
                                       u32 truncate_seq, u64 truncate_size,
                                       bool use_mempool);
diff --git a/include/linux/ceph/pagelist.h b/include/linux/ceph/pagelist.h
index 9660d6b0a35d..13d71fe18b0c 100644
--- a/include/linux/ceph/pagelist.h
+++ b/include/linux/ceph/pagelist.h
@@ -1,7 +1,10 @@
 #ifndef __FS_CEPH_PAGELIST_H
 #define __FS_CEPH_PAGELIST_H
 
+#include <asm/byteorder.h>
+#include <linux/atomic.h>
 #include <linux/list.h>
+#include <linux/types.h>
 
 struct ceph_pagelist {
         struct list_head head;
@@ -10,6 +13,7 @@ struct ceph_pagelist {
         size_t room;
         struct list_head free_list;
         size_t num_pages_free;
+        atomic_t refcnt;
 };
 
 struct ceph_pagelist_cursor {
@@ -26,9 +30,10 @@ static inline void ceph_pagelist_init(struct ceph_pagelist *pl)
         pl->room = 0;
         INIT_LIST_HEAD(&pl->free_list);
         pl->num_pages_free = 0;
+        atomic_set(&pl->refcnt, 1);
 }
 
-extern int ceph_pagelist_release(struct ceph_pagelist *pl);
+extern void ceph_pagelist_release(struct ceph_pagelist *pl);
 
 extern int ceph_pagelist_append(struct ceph_pagelist *pl, const void *d, size_t l);
 
diff --git a/include/linux/ceph/rados.h b/include/linux/ceph/rados.h
index f20e0d8a2155..2f822dca1046 100644
--- a/include/linux/ceph/rados.h
+++ b/include/linux/ceph/rados.h
@@ -172,6 +172,7 @@ extern const char *ceph_osd_state_name(int s);
 #define CEPH_OSD_OP_MODE_WR    0x2000
 #define CEPH_OSD_OP_MODE_RMW   0x3000
 #define CEPH_OSD_OP_MODE_SUB   0x4000
+#define CEPH_OSD_OP_MODE_CACHE 0x8000
 
 #define CEPH_OSD_OP_TYPE       0x0f00
 #define CEPH_OSD_OP_TYPE_LOCK  0x0100
@@ -181,103 +182,135 @@ extern const char *ceph_osd_state_name(int s);
 #define CEPH_OSD_OP_TYPE_PG    0x0500
 #define CEPH_OSD_OP_TYPE_MULTI 0x0600 /* multiobject */
 
+#define __CEPH_OSD_OP1(mode, nr) \
+        (CEPH_OSD_OP_MODE_##mode | (nr))
+
+#define __CEPH_OSD_OP(mode, type, nr) \
+        (CEPH_OSD_OP_MODE_##mode | CEPH_OSD_OP_TYPE_##type | (nr))
+
+#define __CEPH_FORALL_OSD_OPS(f)                                            \
+        /** data **/                                                        \
+        /* read */                                                          \
+        f(READ,         __CEPH_OSD_OP(RD, DATA, 1),     "read")             \
+        f(STAT,         __CEPH_OSD_OP(RD, DATA, 2),     "stat")             \
+        f(MAPEXT,       __CEPH_OSD_OP(RD, DATA, 3),     "mapext")           \
+                                                                            \
+        /* fancy read */                                                    \
+        f(MASKTRUNC,    __CEPH_OSD_OP(RD, DATA, 4),     "masktrunc")        \
+        f(SPARSE_READ,  __CEPH_OSD_OP(RD, DATA, 5),     "sparse-read")      \
+                                                                            \
+        f(NOTIFY,       __CEPH_OSD_OP(RD, DATA, 6),     "notify")           \
+        f(NOTIFY_ACK,   __CEPH_OSD_OP(RD, DATA, 7),     "notify-ack")       \
+                                                                            \
+        /* versioning */                                                    \
+        f(ASSERT_VER,   __CEPH_OSD_OP(RD, DATA, 8),     "assert-version")   \
+                                                                            \
+        f(LIST_WATCHERS, __CEPH_OSD_OP(RD, DATA, 9),    "list-watchers")    \
+                                                                            \
+        f(LIST_SNAPS,   __CEPH_OSD_OP(RD, DATA, 10),    "list-snaps")       \
+                                                                            \
+        /* sync */                                                          \
+        f(SYNC_READ,    __CEPH_OSD_OP(RD, DATA, 11),    "sync_read")        \
+                                                                            \
+        /* write */                                                         \
+        f(WRITE,        __CEPH_OSD_OP(WR, DATA, 1),     "write")            \
+        f(WRITEFULL,    __CEPH_OSD_OP(WR, DATA, 2),     "writefull")        \
+        f(TRUNCATE,     __CEPH_OSD_OP(WR, DATA, 3),     "truncate")         \
+        f(ZERO,         __CEPH_OSD_OP(WR, DATA, 4),     "zero")             \
+        f(DELETE,       __CEPH_OSD_OP(WR, DATA, 5),     "delete")           \
+                                                                            \
+        /* fancy write */                                                   \
+        f(APPEND,       __CEPH_OSD_OP(WR, DATA, 6),     "append")           \
+        f(STARTSYNC,    __CEPH_OSD_OP(WR, DATA, 7),     "startsync")        \
+        f(SETTRUNC,     __CEPH_OSD_OP(WR, DATA, 8),     "settrunc")         \
+        f(TRIMTRUNC,    __CEPH_OSD_OP(WR, DATA, 9),     "trimtrunc")        \
+                                                                            \
+        f(TMAPUP,       __CEPH_OSD_OP(RMW, DATA, 10),   "tmapup")           \
+        f(TMAPPUT,      __CEPH_OSD_OP(WR, DATA, 11),    "tmapput")          \
+        f(TMAPGET,      __CEPH_OSD_OP(RD, DATA, 12),    "tmapget")          \
+                                                                            \
+        f(CREATE,       __CEPH_OSD_OP(WR, DATA, 13),    "create")           \
+        f(ROLLBACK,     __CEPH_OSD_OP(WR, DATA, 14),    "rollback")         \
+                                                                            \
+        f(WATCH,        __CEPH_OSD_OP(WR, DATA, 15),    "watch")            \
+                                                                            \
+        /* omap */                                                          \
+        f(OMAPGETKEYS,  __CEPH_OSD_OP(RD, DATA, 17),    "omap-get-keys")    \
+        f(OMAPGETVALS,  __CEPH_OSD_OP(RD, DATA, 18),    "omap-get-vals")    \
+        f(OMAPGETHEADER, __CEPH_OSD_OP(RD, DATA, 19),   "omap-get-header")  \
+        f(OMAPGETVALSBYKEYS, __CEPH_OSD_OP(RD, DATA, 20), "omap-get-vals-by-keys") \
+        f(OMAPSETVALS,  __CEPH_OSD_OP(WR, DATA, 21),    "omap-set-vals")    \
+        f(OMAPSETHEADER, __CEPH_OSD_OP(WR, DATA, 22),   "omap-set-header")  \
+        f(OMAPCLEAR,    __CEPH_OSD_OP(WR, DATA, 23),    "omap-clear")       \
+        f(OMAPRMKEYS,   __CEPH_OSD_OP(WR, DATA, 24),    "omap-rm-keys")     \
+        f(OMAP_CMP,     __CEPH_OSD_OP(RD, DATA, 25),    "omap-cmp")         \
+                                                                            \
+        /* tiering */                                                       \
+        f(COPY_FROM,    __CEPH_OSD_OP(WR, DATA, 26),    "copy-from")        \
+        f(COPY_GET_CLASSIC, __CEPH_OSD_OP(RD, DATA, 27), "copy-get-classic") \
+        f(UNDIRTY,      __CEPH_OSD_OP(WR, DATA, 28),    "undirty")          \
+        f(ISDIRTY,      __CEPH_OSD_OP(RD, DATA, 29),    "isdirty")          \
+        f(COPY_GET,     __CEPH_OSD_OP(RD, DATA, 30),    "copy-get")         \
+        f(CACHE_FLUSH,  __CEPH_OSD_OP(CACHE, DATA, 31), "cache-flush")      \
+        f(CACHE_EVICT,  __CEPH_OSD_OP(CACHE, DATA, 32), "cache-evict")      \
+        f(CACHE_TRY_FLUSH, __CEPH_OSD_OP(CACHE, DATA, 33), "cache-try-flush") \
+                                                                            \
+        /* convert tmap to omap */                                          \
+        f(TMAP2OMAP,    __CEPH_OSD_OP(RMW, DATA, 34),   "tmap2omap")        \
+                                                                            \
+        /* hints */                                                         \
+        f(SETALLOCHINT, __CEPH_OSD_OP(WR, DATA, 35),    "set-alloc-hint")   \
+                                                                            \
+        /** multi **/                                                       \
+        f(CLONERANGE,   __CEPH_OSD_OP(WR, MULTI, 1),    "clonerange")       \
+        f(ASSERT_SRC_VERSION, __CEPH_OSD_OP(RD, MULTI, 2), "assert-src-version") \
+        f(SRC_CMPXATTR, __CEPH_OSD_OP(RD, MULTI, 3),    "src-cmpxattr")     \
+                                                                            \
+        /** attrs **/                                                       \
+        /* read */                                                          \
+        f(GETXATTR,     __CEPH_OSD_OP(RD, ATTR, 1),     "getxattr")         \
+        f(GETXATTRS,    __CEPH_OSD_OP(RD, ATTR, 2),     "getxattrs")        \
+        f(CMPXATTR,     __CEPH_OSD_OP(RD, ATTR, 3),     "cmpxattr")         \
+                                                                            \
+        /* write */                                                         \
+        f(SETXATTR,     __CEPH_OSD_OP(WR, ATTR, 1),     "setxattr")         \
+        f(SETXATTRS,    __CEPH_OSD_OP(WR, ATTR, 2),     "setxattrs")        \
+        f(RESETXATTRS,  __CEPH_OSD_OP(WR, ATTR, 3),     "resetxattrs")      \
+        f(RMXATTR,      __CEPH_OSD_OP(WR, ATTR, 4),     "rmxattr")          \
+                                                                            \
+        /** subop **/                                                       \
+        f(PULL,         __CEPH_OSD_OP1(SUB, 1),         "pull")             \
+        f(PUSH,         __CEPH_OSD_OP1(SUB, 2),         "push")             \
+        f(BALANCEREADS, __CEPH_OSD_OP1(SUB, 3),         "balance-reads")    \
+        f(UNBALANCEREADS, __CEPH_OSD_OP1(SUB, 4),       "unbalance-reads")  \
+        f(SCRUB,        __CEPH_OSD_OP1(SUB, 5),         "scrub")            \
+        f(SCRUB_RESERVE, __CEPH_OSD_OP1(SUB, 6),        "scrub-reserve")    \
+        f(SCRUB_UNRESERVE, __CEPH_OSD_OP1(SUB, 7),      "scrub-unreserve")  \
+        f(SCRUB_STOP,   __CEPH_OSD_OP1(SUB, 8),         "scrub-stop")       \
+        f(SCRUB_MAP,    __CEPH_OSD_OP1(SUB, 9),         "scrub-map")        \
+                                                                            \
+        /** lock **/                                                        \
+        f(WRLOCK,       __CEPH_OSD_OP(WR, LOCK, 1),     "wrlock")           \
+        f(WRUNLOCK,     __CEPH_OSD_OP(WR, LOCK, 2),     "wrunlock")         \
+        f(RDLOCK,       __CEPH_OSD_OP(WR, LOCK, 3),     "rdlock")           \
+        f(RDUNLOCK,     __CEPH_OSD_OP(WR, LOCK, 4),     "rdunlock")         \
+        f(UPLOCK,       __CEPH_OSD_OP(WR, LOCK, 5),     "uplock")           \
+        f(DNLOCK,       __CEPH_OSD_OP(WR, LOCK, 6),     "dnlock")           \
+                                                                            \
+        /** exec **/                                                        \
+        /* note: the RD bit here is wrong; see special-case below in helper */ \
+        f(CALL,         __CEPH_OSD_OP(RD, EXEC, 1),     "call")             \
+                                                                            \
+        /** pg **/                                                          \
+        f(PGLS,         __CEPH_OSD_OP(RD, PG, 1),       "pgls")             \
+        f(PGLS_FILTER,  __CEPH_OSD_OP(RD, PG, 2),       "pgls-filter")      \
+        f(PG_HITSET_LS, __CEPH_OSD_OP(RD, PG, 3),       "pg-hitset-ls")     \
+        f(PG_HITSET_GET, __CEPH_OSD_OP(RD, PG, 4),      "pg-hitset-get")
+
 enum {
-        /** data **/
-        /* read */
-        CEPH_OSD_OP_READ      = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 1,
-        CEPH_OSD_OP_STAT      = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 2,
-        CEPH_OSD_OP_MAPEXT    = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 3,
-
-        /* fancy read */
-        CEPH_OSD_OP_MASKTRUNC   = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 4,
-        CEPH_OSD_OP_SPARSE_READ = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 5,
-
-        CEPH_OSD_OP_NOTIFY    = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 6,
-        CEPH_OSD_OP_NOTIFY_ACK = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 7,
-
-        /* versioning */
-        CEPH_OSD_OP_ASSERT_VER = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 8,
-
-        /* write */
-        CEPH_OSD_OP_WRITE     = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 1,
-        CEPH_OSD_OP_WRITEFULL = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 2,
-        CEPH_OSD_OP_TRUNCATE  = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 3,
-        CEPH_OSD_OP_ZERO      = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 4,
-        CEPH_OSD_OP_DELETE    = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 5,
-
-        /* fancy write */
-        CEPH_OSD_OP_APPEND    = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 6,
-        CEPH_OSD_OP_STARTSYNC = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 7,
-        CEPH_OSD_OP_SETTRUNC  = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 8,
-        CEPH_OSD_OP_TRIMTRUNC = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 9,
-
-        CEPH_OSD_OP_TMAPUP  = CEPH_OSD_OP_MODE_RMW | CEPH_OSD_OP_TYPE_DATA | 10,
-        CEPH_OSD_OP_TMAPPUT = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 11,
-        CEPH_OSD_OP_TMAPGET = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 12,
-
-        CEPH_OSD_OP_CREATE  = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 13,
-        CEPH_OSD_OP_ROLLBACK= CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 14,
-
-        CEPH_OSD_OP_WATCH   = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 15,
-
-        /* omap */
-        CEPH_OSD_OP_OMAPGETKEYS   = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 17,
-        CEPH_OSD_OP_OMAPGETVALS   = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 18,
-        CEPH_OSD_OP_OMAPGETHEADER = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 19,
-        CEPH_OSD_OP_OMAPGETVALSBYKEYS  =
-          CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 20,
-        CEPH_OSD_OP_OMAPSETVALS   = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 21,
-        CEPH_OSD_OP_OMAPSETHEADER = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 22,
-        CEPH_OSD_OP_OMAPCLEAR     = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 23,
-        CEPH_OSD_OP_OMAPRMKEYS    = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 24,
-        CEPH_OSD_OP_OMAP_CMP      = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_DATA | 25,
-
-        /* hints */
-        CEPH_OSD_OP_SETALLOCHINT = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_DATA | 35,
-
-        /** multi **/
-        CEPH_OSD_OP_CLONERANGE = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_MULTI | 1,
-        CEPH_OSD_OP_ASSERT_SRC_VERSION = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_MULTI | 2,
-        CEPH_OSD_OP_SRC_CMPXATTR = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_MULTI | 3,
-
-        /** attrs **/
-        /* read */
-        CEPH_OSD_OP_GETXATTR  = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_ATTR | 1,
-        CEPH_OSD_OP_GETXATTRS = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_ATTR | 2,
-        CEPH_OSD_OP_CMPXATTR  = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_ATTR | 3,
-
-        /* write */
-        CEPH_OSD_OP_SETXATTR  = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 1,
-        CEPH_OSD_OP_SETXATTRS = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 2,
-        CEPH_OSD_OP_RESETXATTRS = CEPH_OSD_OP_MODE_WR|CEPH_OSD_OP_TYPE_ATTR | 3,
-        CEPH_OSD_OP_RMXATTR   = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_ATTR | 4,
-
-        /** subop **/
-        CEPH_OSD_OP_PULL            = CEPH_OSD_OP_MODE_SUB | 1,
-        CEPH_OSD_OP_PUSH            = CEPH_OSD_OP_MODE_SUB | 2,
-        CEPH_OSD_OP_BALANCEREADS    = CEPH_OSD_OP_MODE_SUB | 3,
-        CEPH_OSD_OP_UNBALANCEREADS  = CEPH_OSD_OP_MODE_SUB | 4,
-        CEPH_OSD_OP_SCRUB           = CEPH_OSD_OP_MODE_SUB | 5,
-        CEPH_OSD_OP_SCRUB_RESERVE   = CEPH_OSD_OP_MODE_SUB | 6,
-        CEPH_OSD_OP_SCRUB_UNRESERVE = CEPH_OSD_OP_MODE_SUB | 7,
-        CEPH_OSD_OP_SCRUB_STOP      = CEPH_OSD_OP_MODE_SUB | 8,
-        CEPH_OSD_OP_SCRUB_MAP     = CEPH_OSD_OP_MODE_SUB | 9,
-
-        /** lock **/
-        CEPH_OSD_OP_WRLOCK    = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 1,
-        CEPH_OSD_OP_WRUNLOCK  = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 2,
-        CEPH_OSD_OP_RDLOCK    = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 3,
-        CEPH_OSD_OP_RDUNLOCK  = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 4,
-        CEPH_OSD_OP_UPLOCK    = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 5,
-        CEPH_OSD_OP_DNLOCK    = CEPH_OSD_OP_MODE_WR | CEPH_OSD_OP_TYPE_LOCK | 6,
-
-        /** exec **/
-        /* note: the RD bit here is wrong; see special-case below in helper */
-        CEPH_OSD_OP_CALL    = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_EXEC | 1,
-
-        /** pg **/
-        CEPH_OSD_OP_PGLS      = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_PG | 1,
-        CEPH_OSD_OP_PGLS_FILTER = CEPH_OSD_OP_MODE_RD | CEPH_OSD_OP_TYPE_PG | 2,
+#define GENERATE_ENUM_ENTRY(op, opcode, str)    CEPH_OSD_OP_##op = (opcode),
+__CEPH_FORALL_OSD_OPS(GENERATE_ENUM_ENTRY)
+#undef GENERATE_ENUM_ENTRY
 };
 
 static inline int ceph_osd_op_type_lock(int op)
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index b5223c570eba..da0dae0600e6 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -27,7 +27,6 @@
 
 struct cgroup_root;
 struct cgroup_subsys;
-struct inode;
 struct cgroup;
 
 extern int cgroup_init_early(void);
@@ -38,7 +37,8 @@ extern void cgroup_exit(struct task_struct *p);
 extern int cgroupstats_build(struct cgroupstats *stats,
                                 struct dentry *dentry);
 
-extern int proc_cgroup_show(struct seq_file *, void *);
+extern int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
+                            struct pid *pid, struct task_struct *tsk);
 
 /* define the enumeration of all cgroup subsystems */
 #define SUBSYS(_x) _x ## _cgrp_id,
@@ -113,6 +113,19 @@ static inline void css_get(struct cgroup_subsys_state *css)
 }
 
 /**
+ * css_get_many - obtain references on the specified css
+ * @css: target css
+ * @n: number of references to get
+ *
+ * The caller must already have a reference.
+ */
+static inline void css_get_many(struct cgroup_subsys_state *css, unsigned int n)
+{
+        if (!(css->flags & CSS_NO_REF))
+                percpu_ref_get_many(&css->refcnt, n);
+}
+
+/**
  * css_tryget - try to obtain a reference on the specified css
  * @css: target css
  *
@@ -159,13 +172,21 @@ static inline void css_put(struct cgroup_subsys_state *css)
                 percpu_ref_put(&css->refcnt);
 }
 
+/**
+ * css_put_many - put css references
+ * @css: target css
+ * @n: number of references to put
+ *
+ * Put references obtained via css_get() and css_tryget_online().
+ */
+static inline void css_put_many(struct cgroup_subsys_state *css, unsigned int n)
+{
+        if (!(css->flags & CSS_NO_REF))
+                percpu_ref_put_many(&css->refcnt, n);
+}
+
 /* bits in struct cgroup flags field */
 enum {
-        /*
-         * Control Group has previously had a child cgroup or a task,
-         * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
-         */
-        CGRP_RELEASABLE,
         /* Control Group requires release notifications to userspace */
         CGRP_NOTIFY_ON_RELEASE,
         /*
@@ -235,13 +256,6 @@ struct cgroup {
         struct list_head e_csets[CGROUP_SUBSYS_COUNT];
 
         /*
-         * Linked list running through all cgroups that can
-         * potentially be reaped by the release agent. Protected by
-         * release_list_lock
-         */
-        struct list_head release_list;
-
-        /*
          * list of pidlists, up to two for each namespace (one for procs, one
          * for tasks); created on demand.
          */
@@ -250,6 +264,9 @@ struct cgroup {
 
         /* used to wait for offlining of csses */
         wait_queue_head_t offline_waitq;
+
+        /* used to schedule release agent */
+        struct work_struct release_agent_work;
 };
 
 #define MAX_CGROUP_ROOT_NAMELEN 64
@@ -376,8 +393,8 @@ struct css_set {
  * struct cftype: handler definitions for cgroup control files
  *
  * When reading/writing to a file:
- *      - the cgroup to use is file->f_dentry->d_parent->d_fsdata
- *      - the 'cftype' of the file is file->f_dentry->d_fsdata
+ *      - the cgroup to use is file->f_path.dentry->d_parent->d_fsdata
+ *      - the 'cftype' of the file is file->f_path.dentry->d_fsdata
  */
 
 /* cftype->flags */
@@ -536,13 +553,10 @@ static inline bool cgroup_has_tasks(struct cgroup *cgrp)
         return !list_empty(&cgrp->cset_links);
 }
 
-/* returns ino associated with a cgroup, 0 indicates unmounted root */
+/* returns ino associated with a cgroup */
 static inline ino_t cgroup_ino(struct cgroup *cgrp)
 {
-        if (cgrp->kn)
-                return cgrp->kn->ino;
-        else
-                return 0;
+        return cgrp->kn->ino;
 }
 
 /* cft/css accessors for cftype->write() operation */
@@ -624,8 +638,10 @@ struct cgroup_subsys {
         struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
         int (*css_online)(struct cgroup_subsys_state *css);
         void (*css_offline)(struct cgroup_subsys_state *css);
+        void (*css_released)(struct cgroup_subsys_state *css);
         void (*css_free)(struct cgroup_subsys_state *css);
         void (*css_reset)(struct cgroup_subsys_state *css);
+        void (*css_e_css_changed)(struct cgroup_subsys_state *css);
 
         int (*can_attach)(struct cgroup_subsys_state *css,
                           struct cgroup_taskset *tset);
@@ -920,6 +936,8 @@ void css_task_iter_end(struct css_task_iter *it);
 int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
 int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
 
+struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
+                                             struct cgroup_subsys *ss);
 struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
                                                        struct cgroup_subsys *ss);
 
diff --git a/include/linux/clk-private.h b/include/linux/clk-private.h
index efbf70b9fd84..0ca5f6046920 100644
--- a/include/linux/clk-private.h
+++ b/include/linux/clk-private.h
@@ -46,8 +46,10 @@ struct clk {
         unsigned int            enable_count;
         unsigned int            prepare_count;
         unsigned long           accuracy;
+        int                     phase;
         struct hlist_head       children;
         struct hlist_node       child_node;
+        struct hlist_node       debug_node;
         unsigned int            notifier_count;
 #ifdef CONFIG_DEBUG_FS
         struct dentry           *dentry;
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index 411dd7eb2653..d936409520f8 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -13,6 +13,7 @@
 
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/of.h>
 
 #ifdef CONFIG_COMMON_CLK
 
@@ -129,6 +130,14 @@ struct dentry;
  *              set then clock accuracy will be initialized to parent accuracy
  *              or 0 (perfect clock) if clock has no parent.
  *
+ * @get_phase:  Queries the hardware to get the current phase of a clock.
+ *              Returned values are 0-359 degrees on success, negative
+ *              error codes on failure.
+ *
+ * @set_phase:  Shift the phase this clock signal in degrees specified
+ *              by the second argument. Valid values for degrees are
+ *              0-359. Return 0 on success, otherwise -EERROR.
+ *
  * @init:       Perform platform-specific initialization magic.
  *              This is not not used by any of the basic clock types.
  *              Please consider other ways of solving initialization problems
@@ -167,7 +176,7 @@ struct clk_ops {
                                         unsigned long *parent_rate);
         long            (*determine_rate)(struct clk_hw *hw, unsigned long rate,
                                         unsigned long *best_parent_rate,
-                                        struct clk **best_parent_clk);
+                                        struct clk_hw **best_parent_hw);
         int             (*set_parent)(struct clk_hw *hw, u8 index);
         u8              (*get_parent)(struct clk_hw *hw);
         int             (*set_rate)(struct clk_hw *hw, unsigned long rate,
@@ -177,6 +186,8 @@ struct clk_ops {
                                     unsigned long parent_rate, u8 index);
         unsigned long   (*recalc_accuracy)(struct clk_hw *hw,
                                            unsigned long parent_accuracy);
+        int             (*get_phase)(struct clk_hw *hw);
+        int             (*set_phase)(struct clk_hw *hw, int degrees);
         void            (*init)(struct clk_hw *hw);
         int             (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
 };
@@ -341,7 +352,6 @@ struct clk_divider {
 #define CLK_DIVIDER_READ_ONLY           BIT(5)
 
 extern const struct clk_ops clk_divider_ops;
-extern const struct clk_ops clk_divider_ro_ops;
 struct clk *clk_register_divider(struct device *dev, const char *name,
                 const char *parent_name, unsigned long flags,
                 void __iomem *reg, u8 shift, u8 width,
@@ -488,6 +498,28 @@ struct clk *clk_register_composite(struct device *dev, const char *name,
                 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
                 unsigned long flags);
 
+/***
+ * struct clk_gpio_gate - gpio gated clock
+ *
+ * @hw:         handle between common and hardware-specific interfaces
+ * @gpiod:      gpio descriptor
+ *
+ * Clock with a gpio control for enabling and disabling the parent clock.
+ * Implements .enable, .disable and .is_enabled
+ */
+
+struct clk_gpio {
+        struct clk_hw   hw;
+        struct gpio_desc *gpiod;
+};
+
+extern const struct clk_ops clk_gpio_gate_ops;
+struct clk *clk_register_gpio_gate(struct device *dev, const char *name,
+                const char *parent_name, struct gpio_desc *gpio,
+                unsigned long flags);
+
+void of_gpio_clk_gate_setup(struct device_node *node);
+
 /**
  * clk_register - allocate a new clock, register it and return an opaque cookie
  * @dev: device that is registering this clock
@@ -512,16 +544,14 @@ u8 __clk_get_num_parents(struct clk *clk);
 struct clk *__clk_get_parent(struct clk *clk);
 struct clk *clk_get_parent_by_index(struct clk *clk, u8 index);
 unsigned int __clk_get_enable_count(struct clk *clk);
-unsigned int __clk_get_prepare_count(struct clk *clk);
 unsigned long __clk_get_rate(struct clk *clk);
-unsigned long __clk_get_accuracy(struct clk *clk);
 unsigned long __clk_get_flags(struct clk *clk);
 bool __clk_is_prepared(struct clk *clk);
 bool __clk_is_enabled(struct clk *clk);
 struct clk *__clk_lookup(const char *name);
 long __clk_mux_determine_rate(struct clk_hw *hw, unsigned long rate,
                               unsigned long *best_parent_rate,
-                              struct clk **best_parent_p);
+                              struct clk_hw **best_parent_p);
 
 /*
  * FIXME clock api without lock protection
@@ -620,7 +650,7 @@ static inline void clk_writel(u32 val, u32 __iomem *reg)
 #endif  /* platform dependent I/O accessors */
 
 #ifdef CONFIG_DEBUG_FS
-struct dentry *clk_debugfs_add_file(struct clk *clk, char *name, umode_t mode,
+struct dentry *clk_debugfs_add_file(struct clk_hw *hw, char *name, umode_t mode,
                                 void *data, const struct file_operations *fops);
 #endif
 
diff --git a/include/linux/clk.h b/include/linux/clk.h
index fb5e097d8f72..c7f258a81761 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -106,6 +106,25 @@ int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
  */
 long clk_get_accuracy(struct clk *clk);
 
+/**
+ * clk_set_phase - adjust the phase shift of a clock signal
+ * @clk: clock signal source
+ * @degrees: number of degrees the signal is shifted
+ *
+ * Shifts the phase of a clock signal by the specified degrees. Returns 0 on
+ * success, -EERROR otherwise.
+ */
+int clk_set_phase(struct clk *clk, int degrees);
+
+/**
+ * clk_get_phase - return the phase shift of a clock signal
+ * @clk: clock signal source
+ *
+ * Returns the phase shift of a clock node in degrees, otherwise returns
+ * -EERROR.
+ */
+int clk_get_phase(struct clk *clk);
+
 #else
 
 static inline long clk_get_accuracy(struct clk *clk)
@@ -113,6 +132,16 @@ static inline long clk_get_accuracy(struct clk *clk)
         return -ENOTSUPP;
 }
 
+static inline long clk_set_phase(struct clk *clk, int phase)
+{
+        return -ENOTSUPP;
+}
+
+static inline long clk_get_phase(struct clk *clk)
+{
+        return -ENOTSUPP;
+}
+
 #endif
 
 /**
@@ -238,7 +267,7 @@ void clk_put(struct clk *clk);
 
 /**
  * devm_clk_put - "free" a managed clock source
- * @dev: device used to acuqire the clock
+ * @dev: device used to acquire the clock
  * @clk: clock source acquired with devm_clk_get()
  *
  * Note: drivers must ensure that all clk_enable calls made on this
diff --git a/include/linux/clk/at91_pmc.h b/include/linux/clk/at91_pmc.h
index de4268d4987a..c8e3b3d1eded 100644
--- a/include/linux/clk/at91_pmc.h
+++ b/include/linux/clk/at91_pmc.h
@@ -125,6 +125,7 @@ extern void __iomem *at91_pmc_base;
 #define         AT91_PMC_PLLADIV2       (1 << 12)               /* PLLA divisor by 2 [some SAM9 only] */
 #define                 AT91_PMC_PLLADIV2_OFF           (0 << 12)
 #define                 AT91_PMC_PLLADIV2_ON            (1 << 12)
+#define         AT91_PMC_H32MXDIV       BIT(24)
 
 #define AT91_PMC_USB            0x38                    /* USB Clock Register [some SAM9 only] */
 #define         AT91_PMC_USBS           (0x1 <<  0)             /* USB OHCI Input clock selection */
diff --git a/include/linux/clk/ti.h b/include/linux/clk/ti.h
index e8d8a35034a5..55ef529a0dbf 100644
--- a/include/linux/clk/ti.h
+++ b/include/linux/clk/ti.h
@@ -254,13 +254,26 @@ extern const struct clk_ops ti_clk_mux_ops;
 void omap2_init_clk_hw_omap_clocks(struct clk *clk);
 int omap3_noncore_dpll_enable(struct clk_hw *hw);
 void omap3_noncore_dpll_disable(struct clk_hw *hw);
+int omap3_noncore_dpll_set_parent(struct clk_hw *hw, u8 index);
 int omap3_noncore_dpll_set_rate(struct clk_hw *hw, unsigned long rate,
                                 unsigned long parent_rate);
+int omap3_noncore_dpll_set_rate_and_parent(struct clk_hw *hw,
+                                           unsigned long rate,
+                                           unsigned long parent_rate,
+                                           u8 index);
+long omap3_noncore_dpll_determine_rate(struct clk_hw *hw,
+                                       unsigned long rate,
+                                       unsigned long *best_parent_rate,
+                                       struct clk_hw **best_parent_clk);
 unsigned long omap4_dpll_regm4xen_recalc(struct clk_hw *hw,
                                          unsigned long parent_rate);
 long omap4_dpll_regm4xen_round_rate(struct clk_hw *hw,
                                     unsigned long target_rate,
                                     unsigned long *parent_rate);
+long omap4_dpll_regm4xen_determine_rate(struct clk_hw *hw,
+                                        unsigned long rate,
+                                        unsigned long *best_parent_rate,
+                                        struct clk_hw **best_parent_clk);
 u8 omap2_init_dpll_parent(struct clk_hw *hw);
 unsigned long omap3_dpll_recalc(struct clk_hw *hw, unsigned long parent_rate);
 long omap2_dpll_round_rate(struct clk_hw *hw, unsigned long target_rate,
@@ -278,6 +291,8 @@ int omap2_clk_disable_autoidle_all(void);
 void omap2_clk_enable_init_clocks(const char **clk_names, u8 num_clocks);
 int omap3_dpll4_set_rate(struct clk_hw *clk, unsigned long rate,
                          unsigned long parent_rate);
+int omap3_dpll4_set_rate_and_parent(struct clk_hw *hw, unsigned long rate,
+                                    unsigned long parent_rate, u8 index);
 int omap2_dflt_clk_enable(struct clk_hw *hw);
 void omap2_dflt_clk_disable(struct clk_hw *hw);
 int omap2_dflt_clk_is_enabled(struct clk_hw *hw);
@@ -292,6 +307,7 @@ void omap2xxx_clkt_vps_init(void);
 void __iomem *ti_clk_get_reg_addr(struct device_node *node, int index);
 void ti_dt_clocks_register(struct ti_dt_clk *oclks);
 void ti_dt_clk_init_provider(struct device_node *np, int index);
+void ti_dt_clk_init_retry_clks(void);
 void ti_dt_clockdomains_setup(void);
 int ti_clk_retry_init(struct device_node *node, struct clk_hw *hw,
                       ti_of_clk_init_cb_t func);
diff --git a/include/linux/clock_cooling.h b/include/linux/clock_cooling.h
new file mode 100644
index 000000000000..4d1019d56f7f
--- /dev/null
+++ b/include/linux/clock_cooling.h
@@ -0,0 +1,65 @@
+/*
+ *  linux/include/linux/clock_cooling.h
+ *
+ *  Copyright (C) 2014 Eduardo Valentin <edubezval@gmail.com>
+ *
+ *  Copyright (C) 2013  Texas Instruments Inc.
+ *  Contact:  Eduardo Valentin <eduardo.valentin@ti.com>
+ *
+ *  Highly based on cpu_cooling.c.
+ *  Copyright (C) 2012  Samsung Electronics Co., Ltd(http://www.samsung.com)
+ *  Copyright (C) 2012  Amit Daniel <amit.kachhap@linaro.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  General Public License for more details.
+ */
+
+#ifndef __CPU_COOLING_H__
+#define __CPU_COOLING_H__
+
+#include <linux/of.h>
+#include <linux/thermal.h>
+#include <linux/cpumask.h>
+
+#ifdef CONFIG_CLOCK_THERMAL
+/**
+ * clock_cooling_register - function to create clock cooling device.
+ * @dev: struct device pointer to the device used as clock cooling device.
+ * @clock_name: string containing the clock used as cooling mechanism.
+ */
+struct thermal_cooling_device *
+clock_cooling_register(struct device *dev, const char *clock_name);
+
+/**
+ * clock_cooling_unregister - function to remove clock cooling device.
+ * @cdev: thermal cooling device pointer.
+ */
+void clock_cooling_unregister(struct thermal_cooling_device *cdev);
+
+unsigned long clock_cooling_get_level(struct thermal_cooling_device *cdev,
+                                      unsigned long freq);
+#else /* !CONFIG_CLOCK_THERMAL */
+static inline struct thermal_cooling_device *
+clock_cooling_register(struct device *dev, const char *clock_name)
+{
+        return NULL;
+}
+static inline
+void clock_cooling_unregister(struct thermal_cooling_device *cdev)
+{
+}
+static inline
+unsigned long clock_cooling_get_level(struct thermal_cooling_device *cdev,
+                                      unsigned long freq)
+{
+        return THERMAL_CSTATE_INVALID;
+}
+#endif  /* CONFIG_CLOCK_THERMAL */
+
+#endif /* __CPU_COOLING_H__ */
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 653f0e2b6ca9..abcafaa20b86 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -287,7 +287,7 @@ extern struct clocksource* clocksource_get_next(void);
 extern void clocksource_change_rating(struct clocksource *cs, int rating);
 extern void clocksource_suspend(void);
 extern void clocksource_resume(void);
-extern struct clocksource * __init __weak clocksource_default_clock(void);
+extern struct clocksource * __init clocksource_default_clock(void);
 extern void clocksource_mark_unstable(struct clocksource *cs);
 
 extern u64
diff --git a/include/linux/cma.h b/include/linux/cma.h
index 371b93042520..9384ba66e975 100644
--- a/include/linux/cma.h
+++ b/include/linux/cma.h
@@ -15,13 +15,17 @@
 
 struct cma;
 
+extern unsigned long totalcma_pages;
 extern phys_addr_t cma_get_base(struct cma *cma);
 extern unsigned long cma_get_size(struct cma *cma);
 
-extern int __init cma_declare_contiguous(phys_addr_t size,
-                        phys_addr_t base, phys_addr_t limit,
+extern int __init cma_declare_contiguous(phys_addr_t base,
+                        phys_addr_t size, phys_addr_t limit,
                         phys_addr_t alignment, unsigned int order_per_bit,
                         bool fixed, struct cma **res_cma);
+extern int cma_init_reserved_mem(phys_addr_t base,
+                                        phys_addr_t size, int order_per_bit,
+                                        struct cma **res_cma);
 extern struct page *cma_alloc(struct cma *cma, int count, unsigned int align);
 extern bool cma_release(struct cma *cma, struct page *pages, int count);
 #endif
diff --git a/include/linux/com20020.h b/include/linux/com20020.h
index 5dcfb944b6ce..85898995b234 100644
--- a/include/linux/com20020.h
+++ b/include/linux/com20020.h
@@ -41,6 +41,35 @@ extern const struct net_device_ops com20020_netdev_ops;
 #define BUS_ALIGN  1
 #endif
 
+#define PLX_PCI_MAX_CARDS 2
+
+struct com20020_pci_channel_map {
+        u32 bar;
+        u32 offset;
+        u32 size;               /* 0x00 - auto, e.g. length of entire bar */
+};
+
+struct com20020_pci_card_info {
+        const char *name;
+        int devcount;
+
+        struct com20020_pci_channel_map chan_map_tbl[PLX_PCI_MAX_CARDS];
+
+        unsigned int flags;
+};
+
+struct com20020_priv {
+        struct com20020_pci_card_info *ci;
+        struct list_head list_dev;
+};
+
+struct com20020_dev {
+        struct list_head list;
+        struct net_device *dev;
+
+        struct com20020_priv *pci_priv;
+        int index;
+};
 
 #define _INTMASK  (ioaddr+BUS_ALIGN*0)  /* writable */
 #define _STATUS   (ioaddr+BUS_ALIGN*0)  /* readable */
diff --git a/include/linux/compaction.h b/include/linux/compaction.h
index 01e3132820da..3238ffa33f68 100644
--- a/include/linux/compaction.h
+++ b/include/linux/compaction.h
@@ -2,14 +2,24 @@
 #define _LINUX_COMPACTION_H
 
 /* Return values for compact_zone() and try_to_compact_pages() */
+/* compaction didn't start as it was deferred due to past failures */
+#define COMPACT_DEFERRED        0
 /* compaction didn't start as it was not possible or direct reclaim was more suitable */
-#define COMPACT_SKIPPED         0
+#define COMPACT_SKIPPED         1
 /* compaction should continue to another pageblock */
-#define COMPACT_CONTINUE        1
+#define COMPACT_CONTINUE        2
 /* direct compaction partially compacted a zone and there are suitable pages */
-#define COMPACT_PARTIAL         2
+#define COMPACT_PARTIAL         3
 /* The full zone was compacted */
-#define COMPACT_COMPLETE        3
+#define COMPACT_COMPLETE        4
+
+/* Used to signal whether compaction detected need_sched() or lock contention */
+/* No contention detected */
+#define COMPACT_CONTENDED_NONE  0
+/* Either need_sched() was true or fatal signal pending */
+#define COMPACT_CONTENDED_SCHED 1
+/* Zone lock or lru_lock was contended in async compaction */
+#define COMPACT_CONTENDED_LOCK  2
 
 #ifdef CONFIG_COMPACTION
 extern int sysctl_compact_memory;
@@ -22,10 +32,12 @@ extern int sysctl_extfrag_handler(struct ctl_table *table, int write,
 extern int fragmentation_index(struct zone *zone, unsigned int order);
 extern unsigned long try_to_compact_pages(struct zonelist *zonelist,
                         int order, gfp_t gfp_mask, nodemask_t *mask,
-                        enum migrate_mode mode, bool *contended);
+                        enum migrate_mode mode, int *contended,
+                        int alloc_flags, int classzone_idx);
 extern void compact_pgdat(pg_data_t *pgdat, int order);
 extern void reset_isolation_suitable(pg_data_t *pgdat);
-extern unsigned long compaction_suitable(struct zone *zone, int order);
+extern unsigned long compaction_suitable(struct zone *zone, int order,
+                                        int alloc_flags, int classzone_idx);
 
 /* Do not skip compaction more than 64 times */
 #define COMPACT_MAX_DEFER_SHIFT 6
@@ -91,7 +103,8 @@ static inline bool compaction_restarting(struct zone *zone, int order)
 #else
 static inline unsigned long try_to_compact_pages(struct zonelist *zonelist,
                         int order, gfp_t gfp_mask, nodemask_t *nodemask,
-                        enum migrate_mode mode, bool *contended)
+                        enum migrate_mode mode, int *contended,
+                        int alloc_flags, int classzone_idx)
 {
         return COMPACT_CONTINUE;
 }
@@ -104,7 +117,8 @@ static inline void reset_isolation_suitable(pg_data_t *pgdat)
 {
 }
 
-static inline unsigned long compaction_suitable(struct zone *zone, int order)
+static inline unsigned long compaction_suitable(struct zone *zone, int order,
+                                        int alloc_flags, int classzone_idx)
 {
         return COMPACT_SKIPPED;
 }
diff --git a/include/linux/compat.h b/include/linux/compat.h
index e6494261eaff..7450ca2ac1fc 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -357,6 +357,9 @@ 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,
                      const compat_uptr_t __user *envp);
+asmlinkage long compat_sys_execveat(int dfd, const char __user *filename,
+                     const compat_uptr_t __user *argv,
+                     const compat_uptr_t __user *envp, int flags);
 
 asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
                 compat_ulong_t __user *outp, compat_ulong_t __user *exp,
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index 2507fd2a1eb4..d1a558239b1a 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -71,7 +71,6 @@
  *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
  *
  * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
- * Fixed in GCC 4.8.2 and later versions.
  *
  * (asm goto is automatically volatile - the naming reflects this.)
  */
diff --git a/include/linux/compiler-gcc5.h b/include/linux/compiler-gcc5.h
new file mode 100644
index 000000000000..c8c565952548
--- /dev/null
+++ b/include/linux/compiler-gcc5.h
@@ -0,0 +1,65 @@
+#ifndef __LINUX_COMPILER_H
+#error "Please don't include <linux/compiler-gcc5.h> directly, include <linux/compiler.h> instead."
+#endif
+
+#define __used                          __attribute__((__used__))
+#define __must_check                    __attribute__((warn_unused_result))
+#define __compiler_offsetof(a, b)       __builtin_offsetof(a, b)
+
+/* Mark functions as cold. gcc will assume any path leading to a call
+   to them will be unlikely.  This means a lot of manual unlikely()s
+   are unnecessary now for any paths leading to the usual suspects
+   like BUG(), printk(), panic() etc. [but let's keep them for now for
+   older compilers]
+
+   Early snapshots of gcc 4.3 don't support this and we can't detect this
+   in the preprocessor, but we can live with this because they're unreleased.
+   Maketime probing would be overkill here.
+
+   gcc also has a __attribute__((__hot__)) to move hot functions into
+   a special section, but I don't see any sense in this right now in
+   the kernel context */
+#define __cold                  __attribute__((__cold__))
+
+#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
+
+#ifndef __CHECKER__
+# define __compiletime_warning(message) __attribute__((warning(message)))
+# define __compiletime_error(message) __attribute__((error(message)))
+#endif /* __CHECKER__ */
+
+/*
+ * Mark a position in code as unreachable.  This can be used to
+ * suppress control flow warnings after asm blocks that transfer
+ * control elsewhere.
+ *
+ * Early snapshots of gcc 4.5 don't support this and we can't detect
+ * this in the preprocessor, but we can live with this because they're
+ * unreleased.  Really, we need to have autoconf for the kernel.
+ */
+#define unreachable() __builtin_unreachable()
+
+/* Mark a function definition as prohibited from being cloned. */
+#define __noclone       __attribute__((__noclone__))
+
+/*
+ * Tell the optimizer that something else uses this function or variable.
+ */
+#define __visible __attribute__((externally_visible))
+
+/*
+ * GCC 'asm goto' miscompiles certain code sequences:
+ *
+ *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
+ *
+ * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
+ *
+ * (asm goto is automatically volatile - the naming reflects this.)
+ */
+#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0)
+
+#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
+#define __HAVE_BUILTIN_BSWAP32__
+#define __HAVE_BUILTIN_BSWAP64__
+#define __HAVE_BUILTIN_BSWAP16__
+#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index d5ad7b1118fc..a1c81f80978e 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -186,6 +186,80 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 # define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
 #endif
 
+#include <uapi/linux/types.h>
+
+static __always_inline void data_access_exceeds_word_size(void)
+#ifdef __compiletime_warning
+__compiletime_warning("data access exceeds word size and won't be atomic")
+#endif
+;
+
+static __always_inline void data_access_exceeds_word_size(void)
+{
+}
+
+static __always_inline void __read_once_size(volatile void *p, void *res, int size)
+{
+        switch (size) {
+        case 1: *(__u8 *)res = *(volatile __u8 *)p; break;
+        case 2: *(__u16 *)res = *(volatile __u16 *)p; break;
+        case 4: *(__u32 *)res = *(volatile __u32 *)p; break;
+#ifdef CONFIG_64BIT
+        case 8: *(__u64 *)res = *(volatile __u64 *)p; break;
+#endif
+        default:
+                barrier();
+                __builtin_memcpy((void *)res, (const void *)p, size);
+                data_access_exceeds_word_size();
+                barrier();
+        }
+}
+
+static __always_inline void __assign_once_size(volatile void *p, void *res, int size)
+{
+        switch (size) {
+        case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
+        case 2: *(volatile __u16 *)p = *(__u16 *)res; break;
+        case 4: *(volatile __u32 *)p = *(__u32 *)res; break;
+#ifdef CONFIG_64BIT
+        case 8: *(volatile __u64 *)p = *(__u64 *)res; break;
+#endif
+        default:
+                barrier();
+                __builtin_memcpy((void *)p, (const void *)res, size);
+                data_access_exceeds_word_size();
+                barrier();
+        }
+}
+
+/*
+ * Prevent the compiler from merging or refetching reads or writes. The
+ * compiler is also forbidden from reordering successive instances of
+ * READ_ONCE, ASSIGN_ONCE and ACCESS_ONCE (see below), but only when the
+ * compiler is aware of some particular ordering.  One way to make the
+ * compiler aware of ordering is to put the two invocations of READ_ONCE,
+ * ASSIGN_ONCE or ACCESS_ONCE() in different C statements.
+ *
+ * In contrast to ACCESS_ONCE these two macros will also work on aggregate
+ * data types like structs or unions. If the size of the accessed data
+ * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)
+ * READ_ONCE() and ASSIGN_ONCE()  will fall back to memcpy and print a
+ * compile-time warning.
+ *
+ * Their two major use cases are: (1) Mediating communication between
+ * process-level code and irq/NMI handlers, all running on the same CPU,
+ * and (2) Ensuring that the compiler does not  fold, spindle, or otherwise
+ * mutilate accesses that either do not require ordering or that interact
+ * with an explicit memory barrier or atomic instruction that provides the
+ * required ordering.
+ */
+
+#define READ_ONCE(x) \
+        ({ typeof(x) __val; __read_once_size(&x, &__val, sizeof(__val)); __val; })
+
+#define ASSIGN_ONCE(val, x) \
+        ({ typeof(x) __val; __val = val; __assign_once_size(&x, &__val, sizeof(__val)); __val; })
+
 #endif /* __KERNEL__ */
 
 #endif /* __ASSEMBLY__ */
diff --git a/include/linux/coresight.h b/include/linux/coresight.h
new file mode 100644
index 000000000000..5d3c54311f7a
--- /dev/null
+++ b/include/linux/coresight.h
@@ -0,0 +1,263 @@
+/* Copyright (c) 2012, 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_CORESIGHT_H
+#define _LINUX_CORESIGHT_H
+
+#include <linux/device.h>
+
+/* Peripheral id registers (0xFD0-0xFEC) */
+#define CORESIGHT_PERIPHIDR4    0xfd0
+#define CORESIGHT_PERIPHIDR5    0xfd4
+#define CORESIGHT_PERIPHIDR6    0xfd8
+#define CORESIGHT_PERIPHIDR7    0xfdC
+#define CORESIGHT_PERIPHIDR0    0xfe0
+#define CORESIGHT_PERIPHIDR1    0xfe4
+#define CORESIGHT_PERIPHIDR2    0xfe8
+#define CORESIGHT_PERIPHIDR3    0xfeC
+/* Component id registers (0xFF0-0xFFC) */
+#define CORESIGHT_COMPIDR0      0xff0
+#define CORESIGHT_COMPIDR1      0xff4
+#define CORESIGHT_COMPIDR2      0xff8
+#define CORESIGHT_COMPIDR3      0xffC
+
+#define ETM_ARCH_V3_3           0x23
+#define ETM_ARCH_V3_5           0x25
+#define PFT_ARCH_V1_0           0x30
+#define PFT_ARCH_V1_1           0x31
+
+#define CORESIGHT_UNLOCK        0xc5acce55
+
+extern struct bus_type coresight_bustype;
+
+enum coresight_dev_type {
+        CORESIGHT_DEV_TYPE_NONE,
+        CORESIGHT_DEV_TYPE_SINK,
+        CORESIGHT_DEV_TYPE_LINK,
+        CORESIGHT_DEV_TYPE_LINKSINK,
+        CORESIGHT_DEV_TYPE_SOURCE,
+};
+
+enum coresight_dev_subtype_sink {
+        CORESIGHT_DEV_SUBTYPE_SINK_NONE,
+        CORESIGHT_DEV_SUBTYPE_SINK_PORT,
+        CORESIGHT_DEV_SUBTYPE_SINK_BUFFER,
+};
+
+enum coresight_dev_subtype_link {
+        CORESIGHT_DEV_SUBTYPE_LINK_NONE,
+        CORESIGHT_DEV_SUBTYPE_LINK_MERG,
+        CORESIGHT_DEV_SUBTYPE_LINK_SPLIT,
+        CORESIGHT_DEV_SUBTYPE_LINK_FIFO,
+};
+
+enum coresight_dev_subtype_source {
+        CORESIGHT_DEV_SUBTYPE_SOURCE_NONE,
+        CORESIGHT_DEV_SUBTYPE_SOURCE_PROC,
+        CORESIGHT_DEV_SUBTYPE_SOURCE_BUS,
+        CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE,
+};
+
+/**
+ * struct coresight_dev_subtype - further characterisation of a type
+ * @sink_subtype:       type of sink this component is, as defined
+                        by @coresight_dev_subtype_sink.
+ * @link_subtype:       type of link this component is, as defined
+                        by @coresight_dev_subtype_link.
+ * @source_subtype:     type of source this component is, as defined
+                        by @coresight_dev_subtype_source.
+ */
+struct coresight_dev_subtype {
+        enum coresight_dev_subtype_sink sink_subtype;
+        enum coresight_dev_subtype_link link_subtype;
+        enum coresight_dev_subtype_source source_subtype;
+};
+
+/**
+ * struct coresight_platform_data - data harvested from the DT specification
+ * @cpu:        the CPU a source belongs to. Only applicable for ETM/PTMs.
+ * @name:       name of the component as shown under sysfs.
+ * @nr_inport:  number of input ports for this component.
+ * @outports:   list of remote endpoint port number.
+ * @child_names:name of all child components connected to this device.
+ * @child_ports:child component port number the current component is
+                connected  to.
+ * @nr_outport: number of output ports for this component.
+ * @clk:        The clock this component is associated to.
+ */
+struct coresight_platform_data {
+        int cpu;
+        const char *name;
+        int nr_inport;
+        int *outports;
+        const char **child_names;
+        int *child_ports;
+        int nr_outport;
+        struct clk *clk;
+};
+
+/**
+ * struct coresight_desc - description of a component required from drivers
+ * @type:       as defined by @coresight_dev_type.
+ * @subtype:    as defined by @coresight_dev_subtype.
+ * @ops:        generic operations for this component, as defined
+                by @coresight_ops.
+ * @pdata:      platform data collected from DT.
+ * @dev:        The device entity associated to this component.
+ * @groups:     operations specific to this component. These will end up
+                in the component's sysfs sub-directory.
+ */
+struct coresight_desc {
+        enum coresight_dev_type type;
+        struct coresight_dev_subtype subtype;
+        const struct coresight_ops *ops;
+        struct coresight_platform_data *pdata;
+        struct device *dev;
+        const struct attribute_group **groups;
+};
+
+/**
+ * struct coresight_connection - representation of a single connection
+ * @outport:    a connection's output port number.
+ * @chid_name:  remote component's name.
+ * @child_port: remote component's port number @output is connected to.
+ * @child_dev:  a @coresight_device representation of the component
+                connected to @outport.
+ */
+struct coresight_connection {
+        int outport;
+        const char *child_name;
+        int child_port;
+        struct coresight_device *child_dev;
+};
+
+/**
+ * struct coresight_device - representation of a device as used by the framework
+ * @conns:      array of coresight_connections associated to this component.
+ * @nr_inport:  number of input port associated to this component.
+ * @nr_outport: number of output port associated to this component.
+ * @type:       as defined by @coresight_dev_type.
+ * @subtype:    as defined by @coresight_dev_subtype.
+ * @ops:        generic operations for this component, as defined
+                by @coresight_ops.
+ * @dev:        The device entity associated to this component.
+ * @refcnt:     keep track of what is in use.
+ * @path_link:  link of current component into the path being enabled.
+ * @orphan:     true if the component has connections that haven't been linked.
+ * @enable:     'true' if component is currently part of an active path.
+ * @activated:  'true' only if a _sink_ has been activated.  A sink can be
+                activated but not yet enabled.  Enabling for a _sink_
+                happens when a source has been selected for that it.
+ */
+struct coresight_device {
+        struct coresight_connection *conns;
+        int nr_inport;
+        int nr_outport;
+        enum coresight_dev_type type;
+        struct coresight_dev_subtype subtype;
+        const struct coresight_ops *ops;
+        struct device dev;
+        atomic_t *refcnt;
+        struct list_head path_link;
+        bool orphan;
+        bool enable;    /* true only if configured as part of a path */
+        bool activated; /* true only if a sink is part of a path */
+};
+
+#define to_coresight_device(d) container_of(d, struct coresight_device, dev)
+
+#define source_ops(csdev)       csdev->ops->source_ops
+#define sink_ops(csdev)         csdev->ops->sink_ops
+#define link_ops(csdev)         csdev->ops->link_ops
+
+#define CORESIGHT_DEBUGFS_ENTRY(__name, __entry_name,                   \
+                                 __mode, __get, __set, __fmt)           \
+DEFINE_SIMPLE_ATTRIBUTE(__name ## _ops, __get, __set, __fmt);           \
+static const struct coresight_ops_entry __name ## _entry = {            \
+        .name = __entry_name,                                           \
+        .mode = __mode,                                                 \
+        .ops  = &__name ## _ops                                         \
+}
+
+/**
+ * struct coresight_ops_sink - basic operations for a sink
+ * Operations available for sinks
+ * @enable:     enables the sink.
+ * @disable:    disables the sink.
+ */
+struct coresight_ops_sink {
+        int (*enable)(struct coresight_device *csdev);
+        void (*disable)(struct coresight_device *csdev);
+};
+
+/**
+ * struct coresight_ops_link - basic operations for a link
+ * Operations available for links.
+ * @enable:     enables flow between iport and oport.
+ * @disable:    disables flow between iport and oport.
+ */
+struct coresight_ops_link {
+        int (*enable)(struct coresight_device *csdev, int iport, int oport);
+        void (*disable)(struct coresight_device *csdev, int iport, int oport);
+};
+
+/**
+ * struct coresight_ops_source - basic operations for a source
+ * Operations available for sources.
+ * @trace_id:   returns the value of the component's trace ID as known
+                to the HW.
+ * @enable:     enables tracing from a source.
+ * @disable:    disables tracing for a source.
+ */
+struct coresight_ops_source {
+        int (*trace_id)(struct coresight_device *csdev);
+        int (*enable)(struct coresight_device *csdev);
+        void (*disable)(struct coresight_device *csdev);
+};
+
+struct coresight_ops {
+        const struct coresight_ops_sink *sink_ops;
+        const struct coresight_ops_link *link_ops;
+        const struct coresight_ops_source *source_ops;
+};
+
+#ifdef CONFIG_CORESIGHT
+extern struct coresight_device *
+coresight_register(struct coresight_desc *desc);
+extern void coresight_unregister(struct coresight_device *csdev);
+extern int coresight_enable(struct coresight_device *csdev);
+extern void coresight_disable(struct coresight_device *csdev);
+extern int coresight_is_bit_set(u32 val, int position, int value);
+extern int coresight_timeout(void __iomem *addr, u32 offset,
+                             int position, int value);
+#ifdef CONFIG_OF
+extern struct coresight_platform_data *of_get_coresight_platform_data(
+                                struct device *dev, struct device_node *node);
+#endif
+#else
+static inline struct coresight_device *
+coresight_register(struct coresight_desc *desc) { return NULL; }
+static inline void coresight_unregister(struct coresight_device *csdev) {}
+static inline int
+coresight_enable(struct coresight_device *csdev) { return -ENOSYS; }
+static inline void coresight_disable(struct coresight_device *csdev) {}
+static inline int coresight_is_bit_set(u32 val, int position, int value)
+                                         { return 0; }
+static inline int coresight_timeout(void __iomem *addr, u32 offset,
+                                     int position, int value) { return 1; }
+#ifdef CONFIG_OF
+static inline struct coresight_platform_data *of_get_coresight_platform_data(
+        struct device *dev, struct device_node *node) { return NULL; }
+#endif
+#endif
+
+#endif
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 95978ad7fcdd..4260e8594bd7 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -19,6 +19,7 @@
 
 struct device;
 struct device_node;
+struct attribute_group;
 
 struct cpu {
         int node_id;            /* The node which contains the CPU */
@@ -39,6 +40,9 @@ extern void cpu_remove_dev_attr(struct device_attribute *attr);
 extern int cpu_add_dev_attr_group(struct attribute_group *attrs);
 extern void cpu_remove_dev_attr_group(struct attribute_group *attrs);
 
+extern struct device *cpu_device_create(struct device *parent, void *drvdata,
+                                        const struct attribute_group **groups,
+                                        const char *fmt, ...);
 #ifdef CONFIG_HOTPLUG_CPU
 extern void unregister_cpu(struct cpu *cpu);
 extern ssize_t arch_cpu_probe(const char *, size_t);
@@ -213,6 +217,7 @@ extern struct bus_type cpu_subsys;
 extern void cpu_hotplug_begin(void);
 extern void cpu_hotplug_done(void);
 extern void get_online_cpus(void);
+extern bool try_get_online_cpus(void);
 extern void put_online_cpus(void);
 extern void cpu_hotplug_disable(void);
 extern void cpu_hotplug_enable(void);
@@ -230,6 +235,7 @@ int cpu_down(unsigned int cpu);
 static inline void cpu_hotplug_begin(void) {}
 static inline void cpu_hotplug_done(void) {}
 #define get_online_cpus()       do { } while (0)
+#define try_get_online_cpus()   true
 #define put_online_cpus()       do { } while (0)
 #define cpu_hotplug_disable()   do { } while (0)
 #define cpu_hotplug_enable()    do { } while (0)
diff --git a/include/linux/cpu_cooling.h b/include/linux/cpu_cooling.h
index c303d383def1..bd955270d5aa 100644
--- a/include/linux/cpu_cooling.h
+++ b/include/linux/cpu_cooling.h
@@ -50,7 +50,7 @@ static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 #endif
 
@@ -65,13 +65,13 @@ unsigned long cpufreq_cooling_get_level(unsigned int cpu, unsigned int freq);
 static inline struct thermal_cooling_device *
 cpufreq_cooling_register(const struct cpumask *clip_cpus)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 static inline
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
diff --git a/include/linux/cpufreq-dt.h b/include/linux/cpufreq-dt.h
new file mode 100644
index 000000000000..0414009e2c30
--- /dev/null
+++ b/include/linux/cpufreq-dt.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2014 Marvell
+ * Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+ *
+ * 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 __CPUFREQ_DT_H__
+#define __CPUFREQ_DT_H__
+
+struct cpufreq_dt_platform_data {
+        /*
+         * True when each CPU has its own clock to control its
+         * frequency, false when all CPUs are controlled by a single
+         * clock.
+         */
+        bool independent_clocks;
+};
+
+#endif /* __CPUFREQ_DT_H__ */
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 7d1955afa62c..4d078cebafd2 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -112,6 +112,9 @@ struct cpufreq_policy {
         spinlock_t              transition_lock;
         wait_queue_head_t       transition_wait;
         struct task_struct      *transition_task; /* Task which is doing the transition */
+
+        /* For cpufreq driver's internal use */
+        void                    *driver_data;
 };
 
 /* Only for ACPI */
@@ -214,25 +217,26 @@ __ATTR(_name, 0644, show_##_name, store_##_name)
 
 
 struct cpufreq_driver {
-        char                    name[CPUFREQ_NAME_LEN];
-        u8                      flags;
+        char            name[CPUFREQ_NAME_LEN];
+        u8              flags;
+        void            *driver_data;
 
         /* needed by all drivers */
-        int     (*init)         (struct cpufreq_policy *policy);
-        int     (*verify)       (struct cpufreq_policy *policy);
+        int             (*init)(struct cpufreq_policy *policy);
+        int             (*verify)(struct cpufreq_policy *policy);
 
         /* define one out of two */
-        int     (*setpolicy)    (struct cpufreq_policy *policy);
+        int             (*setpolicy)(struct cpufreq_policy *policy);
 
         /*
          * On failure, should always restore frequency to policy->restore_freq
          * (i.e. old freq).
          */
-        int     (*target)       (struct cpufreq_policy *policy, /* Deprecated */
-                                 unsigned int target_freq,
-                                 unsigned int relation);
-        int     (*target_index) (struct cpufreq_policy *policy,
-                                 unsigned int index);
+        int             (*target)(struct cpufreq_policy *policy,
+                                  unsigned int target_freq,
+                                  unsigned int relation);       /* Deprecated */
+        int             (*target_index)(struct cpufreq_policy *policy,
+                                        unsigned int index);
         /*
          * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION
          * unset.
@@ -248,27 +252,31 @@ struct cpufreq_driver {
          * wish to switch to intermediate frequency for some target frequency.
          * In that case core will directly call ->target_index().
          */
-        unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
-                                         unsigned int index);
-        int     (*target_intermediate)(struct cpufreq_policy *policy,
-                                       unsigned int index);
+        unsigned int    (*get_intermediate)(struct cpufreq_policy *policy,
+                                            unsigned int index);
+        int             (*target_intermediate)(struct cpufreq_policy *policy,
+                                               unsigned int index);
 
         /* should be defined, if possible */
-        unsigned int    (*get)  (unsigned int cpu);
+        unsigned int    (*get)(unsigned int cpu);
 
         /* optional */
-        int     (*bios_limit)   (int cpu, unsigned int *limit);
+        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);
+
+        /* Will be called after the driver is fully initialized */
+        void            (*ready)(struct cpufreq_policy *policy);
 
-        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;
+        struct freq_attr **attr;
 
         /* platform specific boost support code */
-        bool                    boost_supported;
-        bool                    boost_enabled;
-        int     (*set_boost)    (int state);
+        bool            boost_supported;
+        bool            boost_enabled;
+        int             (*set_boost)(int state);
 };
 
 /* flags */
@@ -309,6 +317,7 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data);
 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
 
 const char *cpufreq_get_current_driver(void);
+void *cpufreq_get_driver_data(void);
 
 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy,
                 unsigned int min, unsigned int max)
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 25e0df6155a4..ab70f3bc44ad 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -53,7 +53,6 @@ struct cpuidle_state {
 };
 
 /* Idle State Flags */
-#define CPUIDLE_FLAG_TIME_VALID (0x01) /* is residency time measurable? */
 #define CPUIDLE_FLAG_COUPLED    (0x02) /* state applies to multiple cpus */
 #define CPUIDLE_FLAG_TIMER_STOP (0x04)  /* timer is stopped on this state */
 
@@ -89,8 +88,6 @@ DECLARE_PER_CPU(struct cpuidle_device, cpuidle_dev);
 /**
  * cpuidle_get_last_residency - retrieves the last state's residency time
  * @dev: the target CPU
- *
- * NOTE: this value is invalid if CPUIDLE_FLAG_TIME_VALID isn't set
  */
 static inline int cpuidle_get_last_residency(struct cpuidle_device *dev)
 {
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 2997af6d2ccd..b950e9d6008b 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -666,10 +666,19 @@ static inline size_t cpumask_size(void)
  *
  * This code makes NR_CPUS length memcopy and brings to a memory corruption.
  * cpumask_copy() provide safe copy functionality.
+ *
+ * Note that there is another evil here: If you define a cpumask_var_t
+ * as a percpu variable then the way to obtain the address of the cpumask
+ * structure differently influences what this_cpu_* operation needs to be
+ * used. Please use this_cpu_cpumask_var_t in those cases. The direct use
+ * of this_cpu_ptr() or this_cpu_read() will lead to failures when the
+ * other type of cpumask_var_t implementation is configured.
  */
 #ifdef CONFIG_CPUMASK_OFFSTACK
 typedef struct cpumask *cpumask_var_t;
 
+#define this_cpu_cpumask_var_ptr(x) this_cpu_read(x)
+
 bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node);
 bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags);
 bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node);
@@ -681,6 +690,8 @@ void free_bootmem_cpumask_var(cpumask_var_t mask);
 #else
 typedef struct cpumask cpumask_var_t[1];
 
+#define this_cpu_cpumask_var_ptr(x) this_cpu_ptr(x)
+
 static inline bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags)
 {
         return true;
@@ -792,6 +803,23 @@ static inline const struct cpumask *get_cpu_mask(unsigned int cpu)
 }
 #endif /* NR_CPUS > BITS_PER_LONG */
 
+/**
+ * cpumap_print_to_pagebuf  - copies the cpumask into the buffer either
+ *      as comma-separated list of cpus or hex values of cpumask
+ * @list: indicates whether the cpumap must be list
+ * @mask: the cpumask to copy
+ * @buf: the buffer to copy into
+ *
+ * Returns the length of the (null-terminated) @buf string, zero if
+ * nothing is copied.
+ */
+static inline ssize_t
+cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask)
+{
+        return bitmap_print_to_pagebuf(list, buf, cpumask_bits(mask),
+                                      nr_cpumask_bits);
+}
+
 /*
  *
  * From here down, all obsolete.  Use cpumask_ variants!
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 6e39c9bb0dae..1b357997cac5 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -48,29 +48,16 @@ extern nodemask_t cpuset_mems_allowed(struct task_struct *p);
 void cpuset_init_current_mems_allowed(void);
 int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask);
 
-extern int __cpuset_node_allowed_softwall(int node, gfp_t gfp_mask);
-extern int __cpuset_node_allowed_hardwall(int node, gfp_t gfp_mask);
+extern int __cpuset_node_allowed(int node, gfp_t gfp_mask);
 
-static inline int cpuset_node_allowed_softwall(int node, gfp_t gfp_mask)
+static inline int cpuset_node_allowed(int node, gfp_t gfp_mask)
 {
-        return nr_cpusets() <= 1 ||
-                __cpuset_node_allowed_softwall(node, gfp_mask);
+        return nr_cpusets() <= 1 || __cpuset_node_allowed(node, gfp_mask);
 }
 
-static inline int cpuset_node_allowed_hardwall(int node, gfp_t gfp_mask)
+static inline int cpuset_zone_allowed(struct zone *z, gfp_t gfp_mask)
 {
-        return nr_cpusets() <= 1 ||
-                __cpuset_node_allowed_hardwall(node, gfp_mask);
-}
-
-static inline int cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask)
-{
-        return cpuset_node_allowed_softwall(zone_to_nid(z), gfp_mask);
-}
-
-static inline int cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask)
-{
-        return cpuset_node_allowed_hardwall(zone_to_nid(z), gfp_mask);
+        return cpuset_node_allowed(zone_to_nid(z), gfp_mask);
 }
 
 extern int cpuset_mems_allowed_intersects(const struct task_struct *tsk1,
@@ -86,7 +73,8 @@ extern void __cpuset_memory_pressure_bump(void);
 
 extern void cpuset_task_status_allowed(struct seq_file *m,
                                         struct task_struct *task);
-extern int proc_cpuset_show(struct seq_file *, void *);
+extern int proc_cpuset_show(struct seq_file *m, struct pid_namespace *ns,
+                            struct pid *pid, struct task_struct *tsk);
 
 extern int cpuset_mem_spread_node(void);
 extern int cpuset_slab_spread_node(void);
@@ -178,22 +166,12 @@ static inline int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask)
         return 1;
 }
 
-static inline int cpuset_node_allowed_softwall(int node, gfp_t gfp_mask)
-{
-        return 1;
-}
-
-static inline int cpuset_node_allowed_hardwall(int node, gfp_t gfp_mask)
-{
-        return 1;
-}
-
-static inline int cpuset_zone_allowed_softwall(struct zone *z, gfp_t gfp_mask)
+static inline int cpuset_node_allowed(int node, gfp_t gfp_mask)
 {
         return 1;
 }
 
-static inline int cpuset_zone_allowed_hardwall(struct zone *z, gfp_t gfp_mask)
+static inline int cpuset_zone_allowed(struct zone *z, gfp_t gfp_mask)
 {
         return 1;
 }
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index 72ab536ad3de..3849fce7ecfe 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
@@ -14,14 +14,13 @@
 extern unsigned long long elfcorehdr_addr;
 extern unsigned long long elfcorehdr_size;
 
-extern int __weak elfcorehdr_alloc(unsigned long long *addr,
-                                   unsigned long long *size);
-extern void __weak elfcorehdr_free(unsigned long long addr);
-extern ssize_t __weak elfcorehdr_read(char *buf, size_t count, u64 *ppos);
-extern ssize_t __weak elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos);
-extern int __weak remap_oldmem_pfn_range(struct vm_area_struct *vma,
-                                         unsigned long from, unsigned long pfn,
-                                         unsigned long size, pgprot_t prot);
+extern int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size);
+extern void elfcorehdr_free(unsigned long long addr);
+extern ssize_t elfcorehdr_read(char *buf, size_t count, u64 *ppos);
+extern ssize_t elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos);
+extern int remap_oldmem_pfn_range(struct vm_area_struct *vma,
+                                  unsigned long from, unsigned long pfn,
+                                  unsigned long size, pgprot_t prot);
 
 extern ssize_t copy_oldmem_page(unsigned long, char *, size_t,
                                                 unsigned long, int);
diff --git a/include/linux/crc-t10dif.h b/include/linux/crc-t10dif.h
index b3cb71f0d3b0..cf53d0773ce3 100644
--- a/include/linux/crc-t10dif.h
+++ b/include/linux/crc-t10dif.h
@@ -6,7 +6,8 @@
 #define CRC_T10DIF_DIGEST_SIZE 2
 #define CRC_T10DIF_BLOCK_SIZE 1
 
-__u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer, size_t len);
-__u16 crc_t10dif(unsigned char const *, size_t);
+extern __u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer,
+                                size_t len);
+extern __u16 crc_t10dif(unsigned char const *, size_t);
 
 #endif
diff --git a/include/linux/cred.h b/include/linux/cred.h
index b2d0820837c4..2fb2ca2127ed 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -68,6 +68,7 @@ extern void groups_free(struct group_info *);
 extern int set_current_groups(struct group_info *);
 extern void set_groups(struct cred *, struct group_info *);
 extern int groups_search(const struct group_info *, kgid_t);
+extern bool may_setgroups(void);
 
 /* access the groups "array" with this macro */
 #define GROUP_AT(gi, i) \
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index d45e949699ea..9c8776d0ada8 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -26,6 +26,19 @@
 #include <linux/uaccess.h>
 
 /*
+ * Autoloaded crypto modules should only use a prefixed name to avoid allowing
+ * arbitrary modules to be loaded. Loading from userspace may still need the
+ * unprefixed names, so retains those aliases as well.
+ * This uses __MODULE_INFO directly instead of MODULE_ALIAS because pre-4.3
+ * gcc (e.g. avr32 toolchain) uses __LINE__ for uniqueness, and this macro
+ * expands twice on the same line. Instead, use a separate base name for the
+ * alias.
+ */
+#define MODULE_ALIAS_CRYPTO(name)       \
+                __MODULE_INFO(alias, alias_userspace, name);    \
+                __MODULE_INFO(alias, alias_crypto, "crypto-" name)
+
+/*
  * Algorithm masks and types.
  */
 #define CRYPTO_ALG_TYPE_MASK            0x0000000f
@@ -127,6 +140,13 @@ struct skcipher_givcrypt_request;
 
 typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
 
+/**
+ * DOC: Block Cipher Context Data Structures
+ *
+ * These data structures define the operating context for each block cipher
+ * type.
+ */
+
 struct crypto_async_request {
         struct list_head list;
         crypto_completion_t complete;
@@ -194,9 +214,63 @@ struct hash_desc {
         u32 flags;
 };
 
-/*
- * Algorithms: modular crypto algorithm implementations, managed
- * via crypto_register_alg() and crypto_unregister_alg().
+/**
+ * DOC: Block Cipher Algorithm Definitions
+ *
+ * These data structures define modular crypto algorithm implementations,
+ * managed via crypto_register_alg() and crypto_unregister_alg().
+ */
+
+/**
+ * struct ablkcipher_alg - asynchronous block cipher definition
+ * @min_keysize: Minimum key size supported by the transformation. This is the
+ *               smallest key length supported by this transformation algorithm.
+ *               This must be set to one of the pre-defined values as this is
+ *               not hardware specific. Possible values for this field can be
+ *               found via git grep "_MIN_KEY_SIZE" include/crypto/
+ * @max_keysize: Maximum key size supported by the transformation. This is the
+ *               largest key length supported by this transformation algorithm.
+ *               This must be set to one of the pre-defined values as this is
+ *               not hardware specific. Possible values for this field can be
+ *               found via git grep "_MAX_KEY_SIZE" include/crypto/
+ * @setkey: Set key for the transformation. This function is used to either
+ *          program a supplied key into the hardware or store the key in the
+ *          transformation context for programming it later. Note that this
+ *          function does modify the transformation context. This function can
+ *          be called multiple times during the existence of the transformation
+ *          object, so one must make sure the key is properly reprogrammed into
+ *          the hardware. This function is also responsible for checking the key
+ *          length for validity. In case a software fallback was put in place in
+ *          the @cra_init call, this function might need to use the fallback if
+ *          the algorithm doesn't support all of the key sizes.
+ * @encrypt: Encrypt a scatterlist of blocks. This function is used to encrypt
+ *           the supplied scatterlist containing the blocks of data. The crypto
+ *           API consumer is responsible for aligning the entries of the
+ *           scatterlist properly and making sure the chunks are correctly
+ *           sized. In case a software fallback was put in place in the
+ *           @cra_init call, this function might need to use the fallback if
+ *           the algorithm doesn't support all of the key sizes. In case the
+ *           key was stored in transformation context, the key might need to be
+ *           re-programmed into the hardware in this function. This function
+ *           shall not modify the transformation context, as this function may
+ *           be called in parallel with the same transformation object.
+ * @decrypt: Decrypt a single block. This is a reverse counterpart to @encrypt
+ *           and the conditions are exactly the same.
+ * @givencrypt: Update the IV for encryption. With this function, a cipher
+ *              implementation may provide the function on how to update the IV
+ *              for encryption.
+ * @givdecrypt: Update the IV for decryption. This is the reverse of
+ *              @givencrypt .
+ * @geniv: The transformation implementation may use an "IV generator" provided
+ *         by the kernel crypto API. Several use cases have a predefined
+ *         approach how IVs are to be updated. For such use cases, the kernel
+ *         crypto API provides ready-to-use implementations that can be
+ *         referenced with this variable.
+ * @ivsize: IV size applicable for transformation. The consumer must provide an
+ *          IV of exactly that size to perform the encrypt or decrypt operation.
+ *
+ * All fields except @givencrypt , @givdecrypt , @geniv and @ivsize are
+ * mandatory and must be filled.
  */
 struct ablkcipher_alg {
         int (*setkey)(struct crypto_ablkcipher *tfm, const u8 *key,
@@ -213,6 +287,32 @@ struct ablkcipher_alg {
         unsigned int ivsize;
 };
 
+/**
+ * struct aead_alg - AEAD cipher definition
+ * @maxauthsize: Set the maximum authentication tag size supported by the
+ *               transformation. A transformation may support smaller tag sizes.
+ *               As the authentication tag is a message digest to ensure the
+ *               integrity of the encrypted data, a consumer typically wants the
+ *               largest authentication tag possible as defined by this
+ *               variable.
+ * @setauthsize: Set authentication size for the AEAD transformation. This
+ *               function is used to specify the consumer requested size of the
+ *               authentication tag to be either generated by the transformation
+ *               during encryption or the size of the authentication tag to be
+ *               supplied during the decryption operation. This function is also
+ *               responsible for checking the authentication tag size for
+ *               validity.
+ * @setkey: see struct ablkcipher_alg
+ * @encrypt: see struct ablkcipher_alg
+ * @decrypt: see struct ablkcipher_alg
+ * @givencrypt: see struct ablkcipher_alg
+ * @givdecrypt: see struct ablkcipher_alg
+ * @geniv: see struct ablkcipher_alg
+ * @ivsize: see struct ablkcipher_alg
+ *
+ * All fields except @givencrypt , @givdecrypt , @geniv and @ivsize are
+ * mandatory and must be filled.
+ */
 struct aead_alg {
         int (*setkey)(struct crypto_aead *tfm, const u8 *key,
                       unsigned int keylen);
@@ -228,6 +328,18 @@ struct aead_alg {
         unsigned int maxauthsize;
 };
 
+/**
+ * struct blkcipher_alg - synchronous block cipher definition
+ * @min_keysize: see struct ablkcipher_alg
+ * @max_keysize: see struct ablkcipher_alg
+ * @setkey: see struct ablkcipher_alg
+ * @encrypt: see struct ablkcipher_alg
+ * @decrypt: see struct ablkcipher_alg
+ * @geniv: see struct ablkcipher_alg
+ * @ivsize: see struct ablkcipher_alg
+ *
+ * All fields except @geniv and @ivsize are mandatory and must be filled.
+ */
 struct blkcipher_alg {
         int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
                       unsigned int keylen);
@@ -245,6 +357,53 @@ struct blkcipher_alg {
         unsigned int ivsize;
 };
 
+/**
+ * struct cipher_alg - single-block symmetric ciphers definition
+ * @cia_min_keysize: Minimum key size supported by the transformation. This is
+ *                   the smallest key length supported by this transformation
+ *                   algorithm. This must be set to one of the pre-defined
+ *                   values as this is not hardware specific. Possible values
+ *                   for this field can be found via git grep "_MIN_KEY_SIZE"
+ *                   include/crypto/
+ * @cia_max_keysize: Maximum key size supported by the transformation. This is
+ *                  the largest key length supported by this transformation
+ *                  algorithm. This must be set to one of the pre-defined values
+ *                  as this is not hardware specific. Possible values for this
+ *                  field can be found via git grep "_MAX_KEY_SIZE"
+ *                  include/crypto/
+ * @cia_setkey: Set key for the transformation. This function is used to either
+ *              program a supplied key into the hardware or store the key in the
+ *              transformation context for programming it later. Note that this
+ *              function does modify the transformation context. This function
+ *              can be called multiple times during the existence of the
+ *              transformation object, so one must make sure the key is properly
+ *              reprogrammed into the hardware. This function is also
+ *              responsible for checking the key length for validity.
+ * @cia_encrypt: Encrypt a single block. This function is used to encrypt a
+ *               single block of data, which must be @cra_blocksize big. This
+ *               always operates on a full @cra_blocksize and it is not possible
+ *               to encrypt a block of smaller size. The supplied buffers must
+ *               therefore also be at least of @cra_blocksize size. Both the
+ *               input and output buffers are always aligned to @cra_alignmask.
+ *               In case either of the input or output buffer supplied by user
+ *               of the crypto API is not aligned to @cra_alignmask, the crypto
+ *               API will re-align the buffers. The re-alignment means that a
+ *               new buffer will be allocated, the data will be copied into the
+ *               new buffer, then the processing will happen on the new buffer,
+ *               then the data will be copied back into the original buffer and
+ *               finally the new buffer will be freed. In case a software
+ *               fallback was put in place in the @cra_init call, this function
+ *               might need to use the fallback if the algorithm doesn't support
+ *               all of the key sizes. In case the key was stored in
+ *               transformation context, the key might need to be re-programmed
+ *               into the hardware in this function. This function shall not
+ *               modify the transformation context, as this function may be
+ *               called in parallel with the same transformation object.
+ * @cia_decrypt: Decrypt a single block. This is a reverse counterpart to
+ *               @cia_encrypt, and the conditions are exactly the same.
+ *
+ * All fields are mandatory and must be filled.
+ */
 struct cipher_alg {
         unsigned int cia_min_keysize;
         unsigned int cia_max_keysize;
@@ -261,6 +420,25 @@ struct compress_alg {
                               unsigned int slen, u8 *dst, unsigned int *dlen);
 };
 
+/**
+ * struct rng_alg - random number generator definition
+ * @rng_make_random: The function defined by this variable obtains a random
+ *                   number. The random number generator transform must generate
+ *                   the random number out of the context provided with this
+ *                   call.
+ * @rng_reset: Reset of the random number generator by clearing the entire state.
+ *             With the invocation of this function call, the random number
+ *             generator shall completely reinitialize its state. If the random
+ *             number generator requires a seed for setting up a new state,
+ *             the seed must be provided by the consumer while invoking this
+ *             function. The required size of the seed is defined with
+ *             @seedsize .
+ * @seedsize: The seed size required for a random number generator
+ *            initialization defined with this variable. Some random number
+ *            generators like the SP800-90A DRBG does not require a seed as the
+ *            seeding is implemented internally without the need of support by
+ *            the consumer. In this case, the seed size is set to zero.
+ */
 struct rng_alg {
         int (*rng_make_random)(struct crypto_rng *tfm, u8 *rdata,
                                unsigned int dlen);
@@ -277,6 +455,81 @@ struct rng_alg {
 #define cra_compress    cra_u.compress
 #define cra_rng         cra_u.rng
 
+/**
+ * struct crypto_alg - definition of a cryptograpic cipher algorithm
+ * @cra_flags: Flags describing this transformation. See include/linux/crypto.h
+ *             CRYPTO_ALG_* flags for the flags which go in here. Those are
+ *             used for fine-tuning the description of the transformation
+ *             algorithm.
+ * @cra_blocksize: Minimum block size of this transformation. The size in bytes
+ *                 of the smallest possible unit which can be transformed with
+ *                 this algorithm. The users must respect this value.
+ *                 In case of HASH transformation, it is possible for a smaller
+ *                 block than @cra_blocksize to be passed to the crypto API for
+ *                 transformation, in case of any other transformation type, an
+ *                 error will be returned upon any attempt to transform smaller
+ *                 than @cra_blocksize chunks.
+ * @cra_ctxsize: Size of the operational context of the transformation. This
+ *               value informs the kernel crypto API about the memory size
+ *               needed to be allocated for the transformation context.
+ * @cra_alignmask: Alignment mask for the input and output data buffer. The data
+ *                 buffer containing the input data for the algorithm must be
+ *                 aligned to this alignment mask. The data buffer for the
+ *                 output data must be aligned to this alignment mask. Note that
+ *                 the Crypto API will do the re-alignment in software, but
+ *                 only under special conditions and there is a performance hit.
+ *                 The re-alignment happens at these occasions for different
+ *                 @cra_u types: cipher -- For both input data and output data
+ *                 buffer; ahash -- For output hash destination buf; shash --
+ *                 For output hash destination buf.
+ *                 This is needed on hardware which is flawed by design and
+ *                 cannot pick data from arbitrary addresses.
+ * @cra_priority: Priority of this transformation implementation. In case
+ *                multiple transformations with same @cra_name are available to
+ *                the Crypto API, the kernel will use the one with highest
+ *                @cra_priority.
+ * @cra_name: Generic name (usable by multiple implementations) of the
+ *            transformation algorithm. This is the name of the transformation
+ *            itself. This field is used by the kernel when looking up the
+ *            providers of particular transformation.
+ * @cra_driver_name: Unique name of the transformation provider. This is the
+ *                   name of the provider of the transformation. This can be any
+ *                   arbitrary value, but in the usual case, this contains the
+ *                   name of the chip or provider and the name of the
+ *                   transformation algorithm.
+ * @cra_type: Type of the cryptographic transformation. This is a pointer to
+ *            struct crypto_type, which implements callbacks common for all
+ *            trasnformation types. There are multiple options:
+ *            &crypto_blkcipher_type, &crypto_ablkcipher_type,
+ *            &crypto_ahash_type, &crypto_aead_type, &crypto_rng_type.
+ *            This field might be empty. In that case, there are no common
+ *            callbacks. This is the case for: cipher, compress, shash.
+ * @cra_u: Callbacks implementing the transformation. This is a union of
+ *         multiple structures. Depending on the type of transformation selected
+ *         by @cra_type and @cra_flags above, the associated structure must be
+ *         filled with callbacks. This field might be empty. This is the case
+ *         for ahash, shash.
+ * @cra_init: Initialize the cryptographic transformation object. This function
+ *            is used to initialize the cryptographic transformation object.
+ *            This function is called only once at the instantiation time, right
+ *            after the transformation context was allocated. In case the
+ *            cryptographic hardware has some special requirements which need to
+ *            be handled by software, this function shall check for the precise
+ *            requirement of the transformation and put any software fallbacks
+ *            in place.
+ * @cra_exit: Deinitialize the cryptographic transformation object. This is a
+ *            counterpart to @cra_init, used to remove various changes set in
+ *            @cra_init.
+ * @cra_module: Owner of this transformation implementation. Set to THIS_MODULE
+ * @cra_list: internally used
+ * @cra_users: internally used
+ * @cra_refcnt: internally used
+ * @cra_destroy: internally used
+ *
+ * The struct crypto_alg describes a generic Crypto API algorithm and is common
+ * for all of the transformations. Any variable not documented here shall not
+ * be used by a cipher implementation as it is internal to the Crypto API.
+ */
 struct crypto_alg {
         struct list_head cra_list;
         struct list_head cra_users;
@@ -581,6 +834,50 @@ static inline u32 crypto_skcipher_mask(u32 mask)
         return mask;
 }
 
+/**
+ * DOC: Asynchronous Block Cipher API
+ *
+ * Asynchronous block cipher API is used with the ciphers of type
+ * CRYPTO_ALG_TYPE_ABLKCIPHER (listed as type "ablkcipher" in /proc/crypto).
+ *
+ * Asynchronous cipher operations imply that the function invocation for a
+ * cipher request returns immediately before the completion of the operation.
+ * The cipher request is scheduled as a separate kernel thread and therefore
+ * load-balanced on the different CPUs via the process scheduler. To allow
+ * the kernel crypto API to inform the caller about the completion of a cipher
+ * request, the caller must provide a callback function. That function is
+ * invoked with the cipher handle when the request completes.
+ *
+ * To support the asynchronous operation, additional information than just the
+ * cipher handle must be supplied to the kernel crypto API. That additional
+ * information is given by filling in the ablkcipher_request data structure.
+ *
+ * For the asynchronous block cipher API, the state is maintained with the tfm
+ * cipher handle. A single tfm can be used across multiple calls and in
+ * parallel. For asynchronous block cipher calls, context data supplied and
+ * only used by the caller can be referenced the request data structure in
+ * addition to the IV used for the cipher request. The maintenance of such
+ * state information would be important for a crypto driver implementer to
+ * have, because when calling the callback function upon completion of the
+ * cipher operation, that callback function may need some information about
+ * which operation just finished if it invoked multiple in parallel. This
+ * state information is unused by the kernel crypto API.
+ */
+
+/**
+ * crypto_alloc_ablkcipher() - allocate asynchronous block cipher handle
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *            ablkcipher cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Allocate a cipher handle for an ablkcipher. The returned struct
+ * crypto_ablkcipher is the cipher handle that is required for any subsequent
+ * API invocation for that ablkcipher.
+ *
+ * Return: allocated cipher handle in case of success; IS_ERR() is true in case
+ *         of an error, PTR_ERR() returns the error code.
+ */
 struct crypto_ablkcipher *crypto_alloc_ablkcipher(const char *alg_name,
                                                   u32 type, u32 mask);
 
@@ -590,11 +887,25 @@ static inline struct crypto_tfm *crypto_ablkcipher_tfm(
         return &tfm->base;
 }
 
+/**
+ * crypto_free_ablkcipher() - zeroize and free cipher handle
+ * @tfm: cipher handle to be freed
+ */
 static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm)
 {
         crypto_free_tfm(crypto_ablkcipher_tfm(tfm));
 }
 
+/**
+ * crypto_has_ablkcipher() - Search for the availability of an ablkcipher.
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *            ablkcipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Return: true when the ablkcipher is known to the kernel crypto API; false
+ *         otherwise
+ */
 static inline int crypto_has_ablkcipher(const char *alg_name, u32 type,
                                         u32 mask)
 {
@@ -608,12 +919,31 @@ static inline struct ablkcipher_tfm *crypto_ablkcipher_crt(
         return &crypto_ablkcipher_tfm(tfm)->crt_ablkcipher;
 }
 
+/**
+ * crypto_ablkcipher_ivsize() - obtain IV size
+ * @tfm: cipher handle
+ *
+ * The size of the IV for the ablkcipher referenced by the cipher handle is
+ * returned. This IV size may be zero if the cipher does not need an IV.
+ *
+ * Return: IV size in bytes
+ */
 static inline unsigned int crypto_ablkcipher_ivsize(
         struct crypto_ablkcipher *tfm)
 {
         return crypto_ablkcipher_crt(tfm)->ivsize;
 }
 
+/**
+ * crypto_ablkcipher_blocksize() - obtain block size of cipher
+ * @tfm: cipher handle
+ *
+ * The block size for the ablkcipher referenced with the cipher handle is
+ * returned. The caller may use that information to allocate appropriate
+ * memory for the data returned by the encryption or decryption operation
+ *
+ * Return: block size of cipher
+ */
 static inline unsigned int crypto_ablkcipher_blocksize(
         struct crypto_ablkcipher *tfm)
 {
@@ -643,6 +973,22 @@ static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm,
         crypto_tfm_clear_flags(crypto_ablkcipher_tfm(tfm), flags);
 }
 
+/**
+ * crypto_ablkcipher_setkey() - set key for cipher
+ * @tfm: cipher handle
+ * @key: buffer holding the key
+ * @keylen: length of the key in bytes
+ *
+ * The caller provided key is set for the ablkcipher referenced by the cipher
+ * handle.
+ *
+ * Note, the key length determines the cipher type. Many block ciphers implement
+ * different cipher modes depending on the key size, such as AES-128 vs AES-192
+ * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
+ * is performed.
+ *
+ * Return: 0 if the setting of the key was successful; < 0 if an error occurred
+ */
 static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
                                            const u8 *key, unsigned int keylen)
 {
@@ -651,12 +997,32 @@ static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
         return crt->setkey(crt->base, key, keylen);
 }
 
+/**
+ * crypto_ablkcipher_reqtfm() - obtain cipher handle from request
+ * @req: ablkcipher_request out of which the cipher handle is to be obtained
+ *
+ * Return the crypto_ablkcipher handle when furnishing an ablkcipher_request
+ * data structure.
+ *
+ * Return: crypto_ablkcipher handle
+ */
 static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
         struct ablkcipher_request *req)
 {
         return __crypto_ablkcipher_cast(req->base.tfm);
 }
 
+/**
+ * crypto_ablkcipher_encrypt() - encrypt plaintext
+ * @req: reference to the ablkcipher_request handle that holds all information
+ *       needed to perform the cipher operation
+ *
+ * Encrypt plaintext data using the ablkcipher_request handle. That data
+ * structure and how it is filled with data is discussed with the
+ * ablkcipher_request_* functions.
+ *
+ * Return: 0 if the cipher operation was successful; < 0 if an error occurred
+ */
 static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
 {
         struct ablkcipher_tfm *crt =
@@ -664,6 +1030,17 @@ static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
         return crt->encrypt(req);
 }
 
+/**
+ * crypto_ablkcipher_decrypt() - decrypt ciphertext
+ * @req: reference to the ablkcipher_request handle that holds all information
+ *       needed to perform the cipher operation
+ *
+ * Decrypt ciphertext data using the ablkcipher_request handle. That data
+ * structure and how it is filled with data is discussed with the
+ * ablkcipher_request_* functions.
+ *
+ * Return: 0 if the cipher operation was successful; < 0 if an error occurred
+ */
 static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
 {
         struct ablkcipher_tfm *crt =
@@ -671,12 +1048,37 @@ static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
         return crt->decrypt(req);
 }
 
+/**
+ * DOC: Asynchronous Cipher Request Handle
+ *
+ * The ablkcipher_request data structure contains all pointers to data
+ * required for the asynchronous cipher operation. This includes the cipher
+ * handle (which can be used by multiple ablkcipher_request instances), pointer
+ * to plaintext and ciphertext, asynchronous callback function, etc. It acts
+ * as a handle to the ablkcipher_request_* API calls in a similar way as
+ * ablkcipher handle to the crypto_ablkcipher_* API calls.
+ */
+
+/**
+ * crypto_ablkcipher_reqsize() - obtain size of the request data structure
+ * @tfm: cipher handle
+ *
+ * Return: number of bytes
+ */
 static inline unsigned int crypto_ablkcipher_reqsize(
         struct crypto_ablkcipher *tfm)
 {
         return crypto_ablkcipher_crt(tfm)->reqsize;
 }
 
+/**
+ * ablkcipher_request_set_tfm() - update cipher handle reference in request
+ * @req: request handle to be modified
+ * @tfm: cipher handle that shall be added to the request handle
+ *
+ * Allow the caller to replace the existing ablkcipher handle in the request
+ * data structure with a different one.
+ */
 static inline void ablkcipher_request_set_tfm(
         struct ablkcipher_request *req, struct crypto_ablkcipher *tfm)
 {
@@ -689,6 +1091,18 @@ static inline struct ablkcipher_request *ablkcipher_request_cast(
         return container_of(req, struct ablkcipher_request, base);
 }
 
+/**
+ * ablkcipher_request_alloc() - allocate request data structure
+ * @tfm: cipher handle to be registered with the request
+ * @gfp: memory allocation flag that is handed to kmalloc by the API call.
+ *
+ * Allocate the request data structure that must be used with the ablkcipher
+ * encrypt and decrypt API calls. During the allocation, the provided ablkcipher
+ * handle is registered in the request data structure.
+ *
+ * Return: allocated request handle in case of success; IS_ERR() is true in case
+ *         of an error, PTR_ERR() returns the error code.
+ */
 static inline struct ablkcipher_request *ablkcipher_request_alloc(
         struct crypto_ablkcipher *tfm, gfp_t gfp)
 {
@@ -703,11 +1117,40 @@ static inline struct ablkcipher_request *ablkcipher_request_alloc(
         return req;
 }
 
+/**
+ * ablkcipher_request_free() - zeroize and free request data structure
+ * @req: request data structure cipher handle to be freed
+ */
 static inline void ablkcipher_request_free(struct ablkcipher_request *req)
 {
         kzfree(req);
 }
 
+/**
+ * ablkcipher_request_set_callback() - set asynchronous callback function
+ * @req: request handle
+ * @flags: specify zero or an ORing of the flags
+ *         CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and
+ *         increase the wait queue beyond the initial maximum size;
+ *         CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep
+ * @compl: callback function pointer to be registered with the request handle
+ * @data: The data pointer refers to memory that is not used by the kernel
+ *        crypto API, but provided to the callback function for it to use. Here,
+ *        the caller can provide a reference to memory the callback function can
+ *        operate on. As the callback function is invoked asynchronously to the
+ *        related functionality, it may need to access data structures of the
+ *        related functionality which can be referenced using this pointer. The
+ *        callback function can access the memory via the "data" field in the
+ *        crypto_async_request data structure provided to the callback function.
+ *
+ * This function allows setting the callback function that is triggered once the
+ * cipher operation completes.
+ *
+ * The callback function is registered with the ablkcipher_request handle and
+ * must comply with the following template:
+ *
+ *      void callback_function(struct crypto_async_request *req, int error)
+ */
 static inline void ablkcipher_request_set_callback(
         struct ablkcipher_request *req,
         u32 flags, crypto_completion_t compl, void *data)
@@ -717,6 +1160,22 @@ static inline void ablkcipher_request_set_callback(
         req->base.flags = flags;
 }
 
+/**
+ * ablkcipher_request_set_crypt() - set data buffers
+ * @req: request handle
+ * @src: source scatter / gather list
+ * @dst: destination scatter / gather list
+ * @nbytes: number of bytes to process from @src
+ * @iv: IV for the cipher operation which must comply with the IV size defined
+ *      by crypto_ablkcipher_ivsize
+ *
+ * This function allows setting of the source data and destination data
+ * scatter / gather lists.
+ *
+ * For encryption, the source is treated as the plaintext and the
+ * destination is the ciphertext. For a decryption operation, the use is
+ * reversed: the source is the ciphertext and the destination is the plaintext.
+ */
 static inline void ablkcipher_request_set_crypt(
         struct ablkcipher_request *req,
         struct scatterlist *src, struct scatterlist *dst,
@@ -728,11 +1187,55 @@ static inline void ablkcipher_request_set_crypt(
         req->info = iv;
 }
 
+/**
+ * DOC: Authenticated Encryption With Associated Data (AEAD) Cipher API
+ *
+ * The AEAD cipher API is used with the ciphers of type CRYPTO_ALG_TYPE_AEAD
+ * (listed as type "aead" in /proc/crypto)
+ *
+ * The most prominent examples for this type of encryption is GCM and CCM.
+ * However, the kernel supports other types of AEAD ciphers which are defined
+ * with the following cipher string:
+ *
+ *      authenc(keyed message digest, block cipher)
+ *
+ * For example: authenc(hmac(sha256), cbc(aes))
+ *
+ * The example code provided for the asynchronous block cipher operation
+ * applies here as well. Naturally all *ablkcipher* symbols must be exchanged
+ * the *aead* pendants discussed in the following. In addtion, for the AEAD
+ * operation, the aead_request_set_assoc function must be used to set the
+ * pointer to the associated data memory location before performing the
+ * encryption or decryption operation. In case of an encryption, the associated
+ * data memory is filled during the encryption operation. For decryption, the
+ * associated data memory must contain data that is used to verify the integrity
+ * of the decrypted data. Another deviation from the asynchronous block cipher
+ * operation is that the caller should explicitly check for -EBADMSG of the
+ * crypto_aead_decrypt. That error indicates an authentication error, i.e.
+ * a breach in the integrity of the message. In essence, that -EBADMSG error
+ * code is the key bonus an AEAD cipher has over "standard" block chaining
+ * modes.
+ */
+
 static inline struct crypto_aead *__crypto_aead_cast(struct crypto_tfm *tfm)
 {
         return (struct crypto_aead *)tfm;
 }
 
+/**
+ * crypto_alloc_aead() - allocate AEAD cipher handle
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *           AEAD cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Allocate a cipher handle for an AEAD. The returned struct
+ * crypto_aead is the cipher handle that is required for any subsequent
+ * API invocation for that AEAD.
+ *
+ * Return: allocated cipher handle in case of success; IS_ERR() is true in case
+ *         of an error, PTR_ERR() returns the error code.
+ */
 struct crypto_aead *crypto_alloc_aead(const char *alg_name, u32 type, u32 mask);
 
 static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm)
@@ -740,6 +1243,10 @@ static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm)
         return &tfm->base;
 }
 
+/**
+ * crypto_free_aead() - zeroize and free aead handle
+ * @tfm: cipher handle to be freed
+ */
 static inline void crypto_free_aead(struct crypto_aead *tfm)
 {
         crypto_free_tfm(crypto_aead_tfm(tfm));
@@ -750,16 +1257,47 @@ static inline struct aead_tfm *crypto_aead_crt(struct crypto_aead *tfm)
         return &crypto_aead_tfm(tfm)->crt_aead;
 }
 
+/**
+ * crypto_aead_ivsize() - obtain IV size
+ * @tfm: cipher handle
+ *
+ * The size of the IV for the aead referenced by the cipher handle is
+ * returned. This IV size may be zero if the cipher does not need an IV.
+ *
+ * Return: IV size in bytes
+ */
 static inline unsigned int crypto_aead_ivsize(struct crypto_aead *tfm)
 {
         return crypto_aead_crt(tfm)->ivsize;
 }
 
+/**
+ * crypto_aead_authsize() - obtain maximum authentication data size
+ * @tfm: cipher handle
+ *
+ * The maximum size of the authentication data for the AEAD cipher referenced
+ * by the AEAD cipher handle is returned. The authentication data size may be
+ * zero if the cipher implements a hard-coded maximum.
+ *
+ * The authentication data may also be known as "tag value".
+ *
+ * Return: authentication data size / tag size in bytes
+ */
 static inline unsigned int crypto_aead_authsize(struct crypto_aead *tfm)
 {
         return crypto_aead_crt(tfm)->authsize;
 }
 
+/**
+ * crypto_aead_blocksize() - obtain block size of cipher
+ * @tfm: cipher handle
+ *
+ * The block size for the AEAD referenced with the cipher handle is returned.
+ * The caller may use that information to allocate appropriate memory for the
+ * data returned by the encryption or decryption operation
+ *
+ * Return: block size of cipher
+ */
 static inline unsigned int crypto_aead_blocksize(struct crypto_aead *tfm)
 {
         return crypto_tfm_alg_blocksize(crypto_aead_tfm(tfm));
@@ -785,6 +1323,22 @@ static inline void crypto_aead_clear_flags(struct crypto_aead *tfm, u32 flags)
         crypto_tfm_clear_flags(crypto_aead_tfm(tfm), flags);
 }
 
+/**
+ * crypto_aead_setkey() - set key for cipher
+ * @tfm: cipher handle
+ * @key: buffer holding the key
+ * @keylen: length of the key in bytes
+ *
+ * The caller provided key is set for the AEAD referenced by the cipher
+ * handle.
+ *
+ * Note, the key length determines the cipher type. Many block ciphers implement
+ * different cipher modes depending on the key size, such as AES-128 vs AES-192
+ * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
+ * is performed.
+ *
+ * Return: 0 if the setting of the key was successful; < 0 if an error occurred
+ */
 static inline int crypto_aead_setkey(struct crypto_aead *tfm, const u8 *key,
                                      unsigned int keylen)
 {
@@ -793,6 +1347,16 @@ static inline int crypto_aead_setkey(struct crypto_aead *tfm, const u8 *key,
         return crt->setkey(crt->base, key, keylen);
 }
 
+/**
+ * crypto_aead_setauthsize() - set authentication data size
+ * @tfm: cipher handle
+ * @authsize: size of the authentication data / tag in bytes
+ *
+ * Set the authentication data size / tag size. AEAD requires an authentication
+ * tag (or MAC) in addition to the associated data.
+ *
+ * Return: 0 if the setting of the key was successful; < 0 if an error occurred
+ */
 int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize);
 
 static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
@@ -800,27 +1364,105 @@ static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
         return __crypto_aead_cast(req->base.tfm);
 }
 
+/**
+ * crypto_aead_encrypt() - encrypt plaintext
+ * @req: reference to the aead_request handle that holds all information
+ *       needed to perform the cipher operation
+ *
+ * Encrypt plaintext data using the aead_request handle. That data structure
+ * and how it is filled with data is discussed with the aead_request_*
+ * functions.
+ *
+ * IMPORTANT NOTE The encryption operation creates the authentication data /
+ *                tag. That data is concatenated with the created ciphertext.
+ *                The ciphertext memory size is therefore the given number of
+ *                block cipher blocks + the size defined by the
+ *                crypto_aead_setauthsize invocation. The caller must ensure
+ *                that sufficient memory is available for the ciphertext and
+ *                the authentication tag.
+ *
+ * Return: 0 if the cipher operation was successful; < 0 if an error occurred
+ */
 static inline int crypto_aead_encrypt(struct aead_request *req)
 {
         return crypto_aead_crt(crypto_aead_reqtfm(req))->encrypt(req);
 }
 
+/**
+ * crypto_aead_decrypt() - decrypt ciphertext
+ * @req: reference to the ablkcipher_request handle that holds all information
+ *       needed to perform the cipher operation
+ *
+ * Decrypt ciphertext data using the aead_request handle. That data structure
+ * and how it is filled with data is discussed with the aead_request_*
+ * functions.
+ *
+ * IMPORTANT NOTE The caller must concatenate the ciphertext followed by the
+ *                authentication data / tag. That authentication data / tag
+ *                must have the size defined by the crypto_aead_setauthsize
+ *                invocation.
+ *
+ *
+ * Return: 0 if the cipher operation was successful; -EBADMSG: The AEAD
+ *         cipher operation performs the authentication of the data during the
+ *         decryption operation. Therefore, the function returns this error if
+ *         the authentication of the ciphertext was unsuccessful (i.e. the
+ *         integrity of the ciphertext or the associated data was violated);
+ *         < 0 if an error occurred.
+ */
 static inline int crypto_aead_decrypt(struct aead_request *req)
 {
         return crypto_aead_crt(crypto_aead_reqtfm(req))->decrypt(req);
 }
 
+/**
+ * DOC: Asynchronous AEAD Request Handle
+ *
+ * The aead_request data structure contains all pointers to data required for
+ * the AEAD cipher operation. This includes the cipher handle (which can be
+ * used by multiple aead_request instances), pointer to plaintext and
+ * ciphertext, asynchronous callback function, etc. It acts as a handle to the
+ * aead_request_* API calls in a similar way as AEAD handle to the
+ * crypto_aead_* API calls.
+ */
+
+/**
+ * crypto_aead_reqsize() - obtain size of the request data structure
+ * @tfm: cipher handle
+ *
+ * Return: number of bytes
+ */
 static inline unsigned int crypto_aead_reqsize(struct crypto_aead *tfm)
 {
         return crypto_aead_crt(tfm)->reqsize;
 }
 
+/**
+ * aead_request_set_tfm() - update cipher handle reference in request
+ * @req: request handle to be modified
+ * @tfm: cipher handle that shall be added to the request handle
+ *
+ * Allow the caller to replace the existing aead handle in the request
+ * data structure with a different one.
+ */
 static inline void aead_request_set_tfm(struct aead_request *req,
                                         struct crypto_aead *tfm)
 {
         req->base.tfm = crypto_aead_tfm(crypto_aead_crt(tfm)->base);
 }
 
+/**
+ * aead_request_alloc() - allocate request data structure
+ * @tfm: cipher handle to be registered with the request
+ * @gfp: memory allocation flag that is handed to kmalloc by the API call.
+ *
+ * Allocate the request data structure that must be used with the AEAD
+ * encrypt and decrypt API calls. During the allocation, the provided aead
+ * handle is registered in the request data structure.
+ *
+ * Return: allocated request handle in case of success; IS_ERR() is true in case
+ *         of an error, PTR_ERR() returns the error code.
+ */
 static inline struct aead_request *aead_request_alloc(struct crypto_aead *tfm,
                                                       gfp_t gfp)
 {
@@ -834,11 +1476,40 @@ static inline struct aead_request *aead_request_alloc(struct crypto_aead *tfm,
         return req;
 }
 
+/**
+ * aead_request_free() - zeroize and free request data structure
+ * @req: request data structure cipher handle to be freed
+ */
 static inline void aead_request_free(struct aead_request *req)
 {
         kzfree(req);
 }
 
+/**
+ * aead_request_set_callback() - set asynchronous callback function
+ * @req: request handle
+ * @flags: specify zero or an ORing of the flags
+ *         CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and
+ *         increase the wait queue beyond the initial maximum size;
+ *         CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep
+ * @compl: callback function pointer to be registered with the request handle
+ * @data: The data pointer refers to memory that is not used by the kernel
+ *        crypto API, but provided to the callback function for it to use. Here,
+ *        the caller can provide a reference to memory the callback function can
+ *        operate on. As the callback function is invoked asynchronously to the
+ *        related functionality, it may need to access data structures of the
+ *        related functionality which can be referenced using this pointer. The
+ *        callback function can access the memory via the "data" field in the
+ *        crypto_async_request data structure provided to the callback function.
+ *
+ * Setting the callback function that is triggered once the cipher operation
+ * completes
+ *
+ * The callback function is registered with the aead_request handle and
+ * must comply with the following template:
+ *
+ *      void callback_function(struct crypto_async_request *req, int error)
+ */
 static inline void aead_request_set_callback(struct aead_request *req,
                                              u32 flags,
                                              crypto_completion_t compl,
@@ -849,6 +1520,36 @@ static inline void aead_request_set_callback(struct aead_request *req,
         req->base.flags = flags;
 }
 
+/**
+ * aead_request_set_crypt - set data buffers
+ * @req: request handle
+ * @src: source scatter / gather list
+ * @dst: destination scatter / gather list
+ * @cryptlen: number of bytes to process from @src
+ * @iv: IV for the cipher operation which must comply with the IV size defined
+ *      by crypto_aead_ivsize()
+ *
+ * Setting the source data and destination data scatter / gather lists.
+ *
+ * For encryption, the source is treated as the plaintext and the
+ * destination is the ciphertext. For a decryption operation, the use is
+ * reversed: the source is the ciphertext and the destination is the plaintext.
+ *
+ * IMPORTANT NOTE AEAD requires an authentication tag (MAC). For decryption,
+ *                the caller must concatenate the ciphertext followed by the
+ *                authentication tag and provide the entire data stream to the
+ *                decryption operation (i.e. the data length used for the
+ *                initialization of the scatterlist and the data length for the
+ *                decryption operation is identical). For encryption, however,
+ *                the authentication tag is created while encrypting the data.
+ *                The destination buffer must hold sufficient space for the
+ *                ciphertext and the authentication tag while the encryption
+ *                invocation must only point to the plaintext data size. The
+ *                following code snippet illustrates the memory usage
+ *                buffer = kmalloc(ptbuflen + (enc ? authsize : 0));
+ *                sg_init_one(&sg, buffer, ptbuflen + (enc ? authsize : 0));
+ *                aead_request_set_crypt(req, &sg, &sg, ptbuflen, iv);
+ */
 static inline void aead_request_set_crypt(struct aead_request *req,
                                           struct scatterlist *src,
                                           struct scatterlist *dst,
@@ -860,6 +1561,15 @@ static inline void aead_request_set_crypt(struct aead_request *req,
         req->iv = iv;
 }
 
+/**
+ * aead_request_set_assoc() - set the associated data scatter / gather list
+ * @req: request handle
+ * @assoc: associated data scatter / gather list
+ * @assoclen: number of bytes to process from @assoc
+ *
+ * For encryption, the memory is filled with the associated data. For
+ * decryption, the memory must point to the associated data.
+ */
 static inline void aead_request_set_assoc(struct aead_request *req,
                                           struct scatterlist *assoc,
                                           unsigned int assoclen)
@@ -868,6 +1578,36 @@ static inline void aead_request_set_assoc(struct aead_request *req,
         req->assoclen = assoclen;
 }
 
+/**
+ * DOC: Synchronous Block Cipher API
+ *
+ * The synchronous block cipher API is used with the ciphers of type
+ * CRYPTO_ALG_TYPE_BLKCIPHER (listed as type "blkcipher" in /proc/crypto)
+ *
+ * Synchronous calls, have a context in the tfm. But since a single tfm can be
+ * used in multiple calls and in parallel, this info should not be changeable
+ * (unless a lock is used). This applies, for example, to the symmetric key.
+ * However, the IV is changeable, so there is an iv field in blkcipher_tfm
+ * structure for synchronous blkcipher api. So, its the only state info that can
+ * be kept for synchronous calls without using a big lock across a tfm.
+ *
+ * The block cipher API allows the use of a complete cipher, i.e. a cipher
+ * consisting of a template (a block chaining mode) and a single block cipher
+ * primitive (e.g. AES).
+ *
+ * The plaintext data buffer and the ciphertext data buffer are pointed to
+ * by using scatter/gather lists. The cipher operation is performed
+ * on all segments of the provided scatter/gather lists.
+ *
+ * The kernel crypto API supports a cipher operation "in-place" which means that
+ * the caller may provide the same scatter/gather list for the plaintext and
+ * cipher text. After the completion of the cipher operation, the plaintext
+ * data is replaced with the ciphertext data in case of an encryption and vice
+ * versa for a decryption. The caller must ensure that the scatter/gather lists
+ * for the output data point to sufficiently large buffers, i.e. multiples of
+ * the block size of the cipher.
+ */
+
 static inline struct crypto_blkcipher *__crypto_blkcipher_cast(
         struct crypto_tfm *tfm)
 {
@@ -881,6 +1621,20 @@ static inline struct crypto_blkcipher *crypto_blkcipher_cast(
         return __crypto_blkcipher_cast(tfm);
 }
 
+/**
+ * crypto_alloc_blkcipher() - allocate synchronous block cipher handle
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *            blkcipher cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Allocate a cipher handle for a block cipher. The returned struct
+ * crypto_blkcipher is the cipher handle that is required for any subsequent
+ * API invocation for that block cipher.
+ *
+ * Return: allocated cipher handle in case of success; IS_ERR() is true in case
+ *         of an error, PTR_ERR() returns the error code.
+ */
 static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
         const char *alg_name, u32 type, u32 mask)
 {
@@ -897,11 +1651,25 @@ static inline struct crypto_tfm *crypto_blkcipher_tfm(
         return &tfm->base;
 }
 
+/**
+ * crypto_free_blkcipher() - zeroize and free the block cipher handle
+ * @tfm: cipher handle to be freed
+ */
 static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
 {
         crypto_free_tfm(crypto_blkcipher_tfm(tfm));
 }
 
+/**
+ * crypto_has_blkcipher() - Search for the availability of a block cipher
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *            block cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Return: true when the block cipher is known to the kernel crypto API; false
+ *         otherwise
+ */
 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
 {
         type &= ~CRYPTO_ALG_TYPE_MASK;
@@ -911,6 +1679,12 @@ static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
         return crypto_has_alg(alg_name, type, mask);
 }
 
+/**
+ * crypto_blkcipher_name() - return the name / cra_name from the cipher handle
+ * @tfm: cipher handle
+ *
+ * Return: The character string holding the name of the cipher
+ */
 static inline const char *crypto_blkcipher_name(struct crypto_blkcipher *tfm)
 {
         return crypto_tfm_alg_name(crypto_blkcipher_tfm(tfm));
@@ -928,11 +1702,30 @@ static inline struct blkcipher_alg *crypto_blkcipher_alg(
         return &crypto_blkcipher_tfm(tfm)->__crt_alg->cra_blkcipher;
 }
 
+/**
+ * crypto_blkcipher_ivsize() - obtain IV size
+ * @tfm: cipher handle
+ *
+ * The size of the IV for the block cipher referenced by the cipher handle is
+ * returned. This IV size may be zero if the cipher does not need an IV.
+ *
+ * Return: IV size in bytes
+ */
 static inline unsigned int crypto_blkcipher_ivsize(struct crypto_blkcipher *tfm)
 {
         return crypto_blkcipher_alg(tfm)->ivsize;
 }
 
+/**
+ * crypto_blkcipher_blocksize() - obtain block size of cipher
+ * @tfm: cipher handle
+ *
+ * The block size for the block cipher referenced with the cipher handle is
+ * returned. The caller may use that information to allocate appropriate
+ * memory for the data returned by the encryption or decryption operation.
+ *
+ * Return: block size of cipher
+ */
 static inline unsigned int crypto_blkcipher_blocksize(
         struct crypto_blkcipher *tfm)
 {
@@ -962,6 +1755,22 @@ static inline void crypto_blkcipher_clear_flags(struct crypto_blkcipher *tfm,
         crypto_tfm_clear_flags(crypto_blkcipher_tfm(tfm), flags);
 }
 
+/**
+ * crypto_blkcipher_setkey() - set key for cipher
+ * @tfm: cipher handle
+ * @key: buffer holding the key
+ * @keylen: length of the key in bytes
+ *
+ * The caller provided key is set for the block cipher referenced by the cipher
+ * handle.
+ *
+ * Note, the key length determines the cipher type. Many block ciphers implement
+ * different cipher modes depending on the key size, such as AES-128 vs AES-192
+ * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
+ * is performed.
+ *
+ * Return: 0 if the setting of the key was successful; < 0 if an error occurred
+ */
 static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
                                           const u8 *key, unsigned int keylen)
 {
@@ -969,6 +1778,24 @@ static inline int crypto_blkcipher_setkey(struct crypto_blkcipher *tfm,
                                                  key, keylen);
 }
 
+/**
+ * crypto_blkcipher_encrypt() - encrypt plaintext
+ * @desc: reference to the block cipher handle with meta data
+ * @dst: scatter/gather list that is filled by the cipher operation with the
+ *      ciphertext
+ * @src: scatter/gather list that holds the plaintext
+ * @nbytes: number of bytes of the plaintext to encrypt.
+ *
+ * Encrypt plaintext data using the IV set by the caller with a preceding
+ * call of crypto_blkcipher_set_iv.
+ *
+ * The blkcipher_desc data structure must be filled by the caller and can
+ * reside on the stack. The caller must fill desc as follows: desc.tfm is filled
+ * with the block cipher handle; desc.flags is filled with either
+ * CRYPTO_TFM_REQ_MAY_SLEEP or 0.
+ *
+ * Return: 0 if the cipher operation was successful; < 0 if an error occurred
+ */
 static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
                                            struct scatterlist *dst,
                                            struct scatterlist *src,
@@ -978,6 +1805,25 @@ static inline int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
         return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
 }
 
+/**
+ * crypto_blkcipher_encrypt_iv() - encrypt plaintext with dedicated IV
+ * @desc: reference to the block cipher handle with meta data
+ * @dst: scatter/gather list that is filled by the cipher operation with the
+ *      ciphertext
+ * @src: scatter/gather list that holds the plaintext
+ * @nbytes: number of bytes of the plaintext to encrypt.
+ *
+ * Encrypt plaintext data with the use of an IV that is solely used for this
+ * cipher operation. Any previously set IV is not used.
+ *
+ * The blkcipher_desc data structure must be filled by the caller and can
+ * reside on the stack. The caller must fill desc as follows: desc.tfm is filled
+ * with the block cipher handle; desc.info is filled with the IV to be used for
+ * the current operation; desc.flags is filled with either
+ * CRYPTO_TFM_REQ_MAY_SLEEP or 0.
+ *
+ * Return: 0 if the cipher operation was successful; < 0 if an error occurred
+ */
 static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
                                               struct scatterlist *dst,
                                               struct scatterlist *src,
@@ -986,6 +1832,23 @@ static inline int crypto_blkcipher_encrypt_iv(struct blkcipher_desc *desc,
         return crypto_blkcipher_crt(desc->tfm)->encrypt(desc, dst, src, nbytes);
 }
 
+/**
+ * crypto_blkcipher_decrypt() - decrypt ciphertext
+ * @desc: reference to the block cipher handle with meta data
+ * @dst: scatter/gather list that is filled by the cipher operation with the
+ *      plaintext
+ * @src: scatter/gather list that holds the ciphertext
+ * @nbytes: number of bytes of the ciphertext to decrypt.
+ *
+ * Decrypt ciphertext data using the IV set by the caller with a preceding
+ * call of crypto_blkcipher_set_iv.
+ *
+ * The blkcipher_desc data structure must be filled by the caller as documented
+ * for the crypto_blkcipher_encrypt call above.
+ *
+ * Return: 0 if the cipher operation was successful; < 0 if an error occurred
+ *
+ */
 static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
                                            struct scatterlist *dst,
                                            struct scatterlist *src,
@@ -995,6 +1858,22 @@ static inline int crypto_blkcipher_decrypt(struct blkcipher_desc *desc,
         return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
 }
 
+/**
+ * crypto_blkcipher_decrypt_iv() - decrypt ciphertext with dedicated IV
+ * @desc: reference to the block cipher handle with meta data
+ * @dst: scatter/gather list that is filled by the cipher operation with the
+ *      plaintext
+ * @src: scatter/gather list that holds the ciphertext
+ * @nbytes: number of bytes of the ciphertext to decrypt.
+ *
+ * Decrypt ciphertext data with the use of an IV that is solely used for this
+ * cipher operation. Any previously set IV is not used.
+ *
+ * The blkcipher_desc data structure must be filled by the caller as documented
+ * for the crypto_blkcipher_encrypt_iv call above.
+ *
+ * Return: 0 if the cipher operation was successful; < 0 if an error occurred
+ */
 static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
                                               struct scatterlist *dst,
                                               struct scatterlist *src,
@@ -1003,18 +1882,54 @@ static inline int crypto_blkcipher_decrypt_iv(struct blkcipher_desc *desc,
         return crypto_blkcipher_crt(desc->tfm)->decrypt(desc, dst, src, nbytes);
 }
 
+/**
+ * crypto_blkcipher_set_iv() - set IV for cipher
+ * @tfm: cipher handle
+ * @src: buffer holding the IV
+ * @len: length of the IV in bytes
+ *
+ * The caller provided IV is set for the block cipher referenced by the cipher
+ * handle.
+ */
 static inline void crypto_blkcipher_set_iv(struct crypto_blkcipher *tfm,
                                            const u8 *src, unsigned int len)
 {
         memcpy(crypto_blkcipher_crt(tfm)->iv, src, len);
 }
 
+/**
+ * crypto_blkcipher_get_iv() - obtain IV from cipher
+ * @tfm: cipher handle
+ * @dst: buffer filled with the IV
+ * @len: length of the buffer dst
+ *
+ * The caller can obtain the IV set for the block cipher referenced by the
+ * cipher handle and store it into the user-provided buffer. If the buffer
+ * has an insufficient space, the IV is truncated to fit the buffer.
+ */
 static inline void crypto_blkcipher_get_iv(struct crypto_blkcipher *tfm,
                                            u8 *dst, unsigned int len)
 {
         memcpy(dst, crypto_blkcipher_crt(tfm)->iv, len);
 }
 
+/**
+ * DOC: Single Block Cipher API
+ *
+ * The single block cipher API is used with the ciphers of type
+ * CRYPTO_ALG_TYPE_CIPHER (listed as type "cipher" in /proc/crypto).
+ *
+ * Using the single block cipher API calls, operations with the basic cipher
+ * primitive can be implemented. These cipher primitives exclude any block
+ * chaining operations including IV handling.
+ *
+ * The purpose of this single block cipher API is to support the implementation
+ * of templates or other concepts that only need to perform the cipher operation
+ * on one block at a time. Templates invoke the underlying cipher primitive
+ * block-wise and process either the input or the output data of these cipher
+ * operations.
+ */
+
 static inline struct crypto_cipher *__crypto_cipher_cast(struct crypto_tfm *tfm)
 {
         return (struct crypto_cipher *)tfm;
@@ -1026,6 +1941,20 @@ static inline struct crypto_cipher *crypto_cipher_cast(struct crypto_tfm *tfm)
         return __crypto_cipher_cast(tfm);
 }
 
+/**
+ * crypto_alloc_cipher() - allocate single block cipher handle
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *           single block cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Allocate a cipher handle for a single block cipher. The returned struct
+ * crypto_cipher is the cipher handle that is required for any subsequent API
+ * invocation for that single block cipher.
+ *
+ * Return: allocated cipher handle in case of success; IS_ERR() is true in case
+ *         of an error, PTR_ERR() returns the error code.
+ */
 static inline struct crypto_cipher *crypto_alloc_cipher(const char *alg_name,
                                                         u32 type, u32 mask)
 {
@@ -1041,11 +1970,25 @@ static inline struct crypto_tfm *crypto_cipher_tfm(struct crypto_cipher *tfm)
         return &tfm->base;
 }
 
+/**
+ * crypto_free_cipher() - zeroize and free the single block cipher handle
+ * @tfm: cipher handle to be freed
+ */
 static inline void crypto_free_cipher(struct crypto_cipher *tfm)
 {
         crypto_free_tfm(crypto_cipher_tfm(tfm));
 }
 
+/**
+ * crypto_has_cipher() - Search for the availability of a single block cipher
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *           single block cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Return: true when the single block cipher is known to the kernel crypto API;
+ *         false otherwise
+ */
 static inline int crypto_has_cipher(const char *alg_name, u32 type, u32 mask)
 {
         type &= ~CRYPTO_ALG_TYPE_MASK;
@@ -1060,6 +2003,16 @@ static inline struct cipher_tfm *crypto_cipher_crt(struct crypto_cipher *tfm)
         return &crypto_cipher_tfm(tfm)->crt_cipher;
 }
 
+/**
+ * crypto_cipher_blocksize() - obtain block size for cipher
+ * @tfm: cipher handle
+ *
+ * The block size for the single block cipher referenced with the cipher handle
+ * tfm is returned. The caller may use that information to allocate appropriate
+ * memory for the data returned by the encryption or decryption operation
+ *
+ * Return: block size of cipher
+ */
 static inline unsigned int crypto_cipher_blocksize(struct crypto_cipher *tfm)
 {
         return crypto_tfm_alg_blocksize(crypto_cipher_tfm(tfm));
@@ -1087,6 +2040,22 @@ static inline void crypto_cipher_clear_flags(struct crypto_cipher *tfm,
         crypto_tfm_clear_flags(crypto_cipher_tfm(tfm), flags);
 }
 
+/**
+ * crypto_cipher_setkey() - set key for cipher
+ * @tfm: cipher handle
+ * @key: buffer holding the key
+ * @keylen: length of the key in bytes
+ *
+ * The caller provided key is set for the single block cipher referenced by the
+ * cipher handle.
+ *
+ * Note, the key length determines the cipher type. Many block ciphers implement
+ * different cipher modes depending on the key size, such as AES-128 vs AES-192
+ * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
+ * is performed.
+ *
+ * Return: 0 if the setting of the key was successful; < 0 if an error occurred
+ */
 static inline int crypto_cipher_setkey(struct crypto_cipher *tfm,
                                        const u8 *key, unsigned int keylen)
 {
@@ -1094,6 +2063,15 @@ static inline int crypto_cipher_setkey(struct crypto_cipher *tfm,
                                                   key, keylen);
 }
 
+/**
+ * crypto_cipher_encrypt_one() - encrypt one block of plaintext
+ * @tfm: cipher handle
+ * @dst: points to the buffer that will be filled with the ciphertext
+ * @src: buffer holding the plaintext to be encrypted
+ *
+ * Invoke the encryption operation of one block. The caller must ensure that
+ * the plaintext and ciphertext buffers are at least one block in size.
+ */
 static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
                                              u8 *dst, const u8 *src)
 {
@@ -1101,6 +2079,15 @@ static inline void crypto_cipher_encrypt_one(struct crypto_cipher *tfm,
                                                 dst, src);
 }
 
+/**
+ * crypto_cipher_decrypt_one() - decrypt one block of ciphertext
+ * @tfm: cipher handle
+ * @dst: points to the buffer that will be filled with the plaintext
+ * @src: buffer holding the ciphertext to be decrypted
+ *
+ * Invoke the decryption operation of one block. The caller must ensure that
+ * the plaintext and ciphertext buffers are at least one block in size.
+ */
 static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
                                              u8 *dst, const u8 *src)
 {
@@ -1108,6 +2095,13 @@ static inline void crypto_cipher_decrypt_one(struct crypto_cipher *tfm,
                                                 dst, src);
 }
 
+/**
+ * DOC: Synchronous Message Digest API
+ *
+ * The synchronous message digest API is used with the ciphers of type
+ * CRYPTO_ALG_TYPE_HASH (listed as type "hash" in /proc/crypto)
+ */
+
 static inline struct crypto_hash *__crypto_hash_cast(struct crypto_tfm *tfm)
 {
         return (struct crypto_hash *)tfm;
@@ -1120,6 +2114,20 @@ static inline struct crypto_hash *crypto_hash_cast(struct crypto_tfm *tfm)
         return __crypto_hash_cast(tfm);
 }
 
+/**
+ * crypto_alloc_hash() - allocate synchronous message digest handle
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *            message digest cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Allocate a cipher handle for a message digest. The returned struct
+ * crypto_hash is the cipher handle that is required for any subsequent
+ * API invocation for that message digest.
+ *
+ * Return: allocated cipher handle in case of success; IS_ERR() is true in case
+ * of an error, PTR_ERR() returns the error code.
+ */
 static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name,
                                                     u32 type, u32 mask)
 {
@@ -1136,11 +2144,25 @@ static inline struct crypto_tfm *crypto_hash_tfm(struct crypto_hash *tfm)
         return &tfm->base;
 }
 
+/**
+ * crypto_free_hash() - zeroize and free message digest handle
+ * @tfm: cipher handle to be freed
+ */
 static inline void crypto_free_hash(struct crypto_hash *tfm)
 {
         crypto_free_tfm(crypto_hash_tfm(tfm));
 }
 
+/**
+ * crypto_has_hash() - Search for the availability of a message digest
+ * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
+ *            message digest cipher
+ * @type: specifies the type of the cipher
+ * @mask: specifies the mask for the cipher
+ *
+ * Return: true when the message digest cipher is known to the kernel crypto
+ *         API; false otherwise
+ */
 static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask)
 {
         type &= ~CRYPTO_ALG_TYPE_MASK;
@@ -1156,6 +2178,15 @@ static inline struct hash_tfm *crypto_hash_crt(struct crypto_hash *tfm)
         return &crypto_hash_tfm(tfm)->crt_hash;
 }
 
+/**
+ * crypto_hash_blocksize() - obtain block size for message digest
+ * @tfm: cipher handle
+ *
+ * The block size for the message digest cipher referenced with the cipher
+ * handle is returned.
+ *
+ * Return: block size of cipher
+ */
 static inline unsigned int crypto_hash_blocksize(struct crypto_hash *tfm)
 {
         return crypto_tfm_alg_blocksize(crypto_hash_tfm(tfm));
@@ -1166,6 +2197,15 @@ static inline unsigned int crypto_hash_alignmask(struct crypto_hash *tfm)
         return crypto_tfm_alg_alignmask(crypto_hash_tfm(tfm));
 }
 
+/**
+ * crypto_hash_digestsize() - obtain message digest size
+ * @tfm: cipher handle
+ *
+ * The size for the message digest created by the message digest cipher
+ * referenced with the cipher handle is returned.
+ *
+ * Return: message digest size
+ */
 static inline unsigned int crypto_hash_digestsize(struct crypto_hash *tfm)
 {
         return crypto_hash_crt(tfm)->digestsize;
@@ -1186,11 +2226,38 @@ static inline void crypto_hash_clear_flags(struct crypto_hash *tfm, u32 flags)
         crypto_tfm_clear_flags(crypto_hash_tfm(tfm), flags);
 }
 
+/**
+ * crypto_hash_init() - (re)initialize message digest handle
+ * @desc: cipher request handle that to be filled by caller --
+ *        desc.tfm is filled with the hash cipher handle;
+ *        desc.flags is filled with either CRYPTO_TFM_REQ_MAY_SLEEP or 0.
+ *
+ * The call (re-)initializes the message digest referenced by the hash cipher
+ * request handle. Any potentially existing state created by previous
+ * operations is discarded.
+ *
+ * Return: 0 if the message digest initialization was successful; < 0 if an
+ *         error occurred
+ */
 static inline int crypto_hash_init(struct hash_desc *desc)
 {
         return crypto_hash_crt(desc->tfm)->init(desc);
 }
 
+/**
+ * crypto_hash_update() - add data to message digest for processing
+ * @desc: cipher request handle
+ * @sg: scatter / gather list pointing to the data to be added to the message
+ *      digest
+ * @nbytes: number of bytes to be processed from @sg
+ *
+ * Updates the message digest state of the cipher handle pointed to by the
+ * hash cipher request handle with the input data pointed to by the
+ * scatter/gather list.
+ *
+ * Return: 0 if the message digest update was successful; < 0 if an error
+ *         occurred
+ */
 static inline int crypto_hash_update(struct hash_desc *desc,
                                      struct scatterlist *sg,
                                      unsigned int nbytes)
@@ -1198,11 +2265,39 @@ static inline int crypto_hash_update(struct hash_desc *desc,
         return crypto_hash_crt(desc->tfm)->update(desc, sg, nbytes);
 }
 
+/**
+ * crypto_hash_final() - calculate message digest
+ * @desc: cipher request handle
+ * @out: message digest output buffer -- The caller must ensure that the out
+ *       buffer has a sufficient size (e.g. by using the crypto_hash_digestsize
+ *       function).
+ *
+ * Finalize the message digest operation and create the message digest
+ * based on all data added to the cipher handle. The message digest is placed
+ * into the output buffer.
+ *
+ * Return: 0 if the message digest creation was successful; < 0 if an error
+ *         occurred
+ */
 static inline int crypto_hash_final(struct hash_desc *desc, u8 *out)
 {
         return crypto_hash_crt(desc->tfm)->final(desc, out);
 }
 
+/**
+ * crypto_hash_digest() - calculate message digest for a buffer
+ * @desc: see crypto_hash_final()
+ * @sg: see crypto_hash_update()
+ * @nbytes:  see crypto_hash_update()
+ * @out: see crypto_hash_final()
+ *
+ * This function is a "short-hand" for the function calls of crypto_hash_init,
+ * crypto_hash_update and crypto_hash_final. The parameters have the same
+ * meaning as discussed for those separate three functions.
+ *
+ * Return: 0 if the message digest creation was successful; < 0 if an error
+ *         occurred
+ */
 static inline int crypto_hash_digest(struct hash_desc *desc,
                                      struct scatterlist *sg,
                                      unsigned int nbytes, u8 *out)
@@ -1210,6 +2305,17 @@ static inline int crypto_hash_digest(struct hash_desc *desc,
         return crypto_hash_crt(desc->tfm)->digest(desc, sg, nbytes, out);
 }
 
+/**
+ * crypto_hash_setkey() - set key for message digest
+ * @hash: cipher handle
+ * @key: buffer holding the key
+ * @keylen: length of the key in bytes
+ *
+ * The caller provided key is set for the message digest cipher. The cipher
+ * handle must point to a keyed hash in order for this function to succeed.
+ *
+ * Return: 0 if the setting of the key was successful; < 0 if an error occurred
+ */
 static inline int crypto_hash_setkey(struct crypto_hash *hash,
                                      const u8 *key, unsigned int keylen)
 {
diff --git a/include/linux/cycx_x25.h b/include/linux/cycx_x25.h
deleted file mode 100644
index 362bf19d6cf1..000000000000
--- a/include/linux/cycx_x25.h
+++ /dev/null
@@ -1,125 +0,0 @@
-#ifndef _CYCX_X25_H
-#define _CYCX_X25_H
-/*
-* cycx_x25.h    Cyclom X.25 firmware API definitions.
-*
-* Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
-*
-* Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
-*
-* Based on sdla_x25.h by Gene Kozin <74604.152@compuserve.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.
-* ============================================================================
-* 2000/04/02    acme            dprintk and cycx_debug
-* 1999/01/03    acme            judicious use of data types
-* 1999/01/02    acme            #define X25_ACK_N3      0x4411
-* 1998/12/28    acme            cleanup: lot'o'things removed
-*                                        commands listed,
-*                                        TX25Cmd & TX25Config structs
-*                                        typedef'ed
-*/
-#ifndef PACKED
-#define PACKED __attribute__((packed))
-#endif 
-
-/* X.25 shared memory layout. */
-#define X25_MBOX_OFFS   0x300   /* general mailbox block */
-#define X25_RXMBOX_OFFS 0x340   /* receive mailbox */
-
-/* Debug */
-#define dprintk(level, format, a...) if (cycx_debug >= level) printk(format, ##a)
-
-extern unsigned int cycx_debug;
-
-/* Data Structures */
-/* X.25 Command Block. */
-struct cycx_x25_cmd {
-        u16 command;
-        u16 link;       /* values: 0 or 1 */
-        u16 len;        /* values: 0 thru 0x205 (517) */
-        u32 buf;
-} PACKED;
-
-/* Defines for the 'command' field. */
-#define X25_CONNECT_REQUEST             0x4401
-#define X25_CONNECT_RESPONSE            0x4402
-#define X25_DISCONNECT_REQUEST          0x4403
-#define X25_DISCONNECT_RESPONSE         0x4404
-#define X25_DATA_REQUEST                0x4405
-#define X25_ACK_TO_VC                   0x4406
-#define X25_INTERRUPT_RESPONSE          0x4407
-#define X25_CONFIG                      0x4408
-#define X25_CONNECT_INDICATION          0x4409
-#define X25_CONNECT_CONFIRM             0x440A
-#define X25_DISCONNECT_INDICATION       0x440B
-#define X25_DISCONNECT_CONFIRM          0x440C
-#define X25_DATA_INDICATION             0x440E
-#define X25_INTERRUPT_INDICATION        0x440F
-#define X25_ACK_FROM_VC                 0x4410
-#define X25_ACK_N3                      0x4411
-#define X25_CONNECT_COLLISION           0x4413
-#define X25_N3WIN                       0x4414
-#define X25_LINE_ON                     0x4415
-#define X25_LINE_OFF                    0x4416
-#define X25_RESET_REQUEST               0x4417
-#define X25_LOG                         0x4500
-#define X25_STATISTIC                   0x4600
-#define X25_TRACE                       0x4700
-#define X25_N2TRACEXC                   0x4702
-#define X25_N3TRACEXC                   0x4703
-
-/**
- *      struct cycx_x25_config - cyclom2x x25 firmware configuration
- *      @link - link number
- *      @speed - line speed
- *      @clock - internal/external
- *      @n2 - # of level 2 retransm.(values: 1 thru FF)
- *      @n2win - level 2 window (values: 1 thru 7)
- *      @n3win - level 3 window (values: 1 thru 7)
- *      @nvc - # of logical channels (values: 1 thru 64)
- *      @pktlen - level 3 packet length - log base 2 of size
- *      @locaddr - my address
- *      @remaddr - remote address
- *      @t1 - time, in seconds
- *      @t2 - time, in seconds
- *      @t21 - time, in seconds
- *      @npvc - # of permanent virt. circuits (1 thru nvc)
- *      @t23 - time, in seconds
- *      @flags - see dosx25.doc, in portuguese, for details
- */
-struct cycx_x25_config {
-        u8  link;
-        u8  speed;
-        u8  clock;
-        u8  n2;
-        u8  n2win;
-        u8  n3win;
-        u8  nvc;
-        u8  pktlen;
-        u8  locaddr;
-        u8  remaddr;
-        u16 t1;
-        u16 t2;
-        u8  t21;
-        u8  npvc;
-        u8  t23;
-        u8  flags;
-} PACKED;
-
-struct cycx_x25_stats {
-        u16 rx_crc_errors;
-        u16 rx_over_errors;
-        u16 n2_tx_frames;
-        u16 n2_rx_frames;
-        u16 tx_timeouts;
-        u16 rx_timeouts;
-        u16 n3_tx_packets;
-        u16 n3_rx_packets;
-        u16 tx_aborts;
-        u16 rx_aborts;
-} PACKED;
-#endif  /* _CYCX_X25_H */
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 75a227cc7ce2..5a813988e6d4 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -11,7 +11,6 @@
 #include <linux/rcupdate.h>
 #include <linux/lockref.h>
 
-struct nameidata;
 struct path;
 struct vfsmount;
 
@@ -125,15 +124,15 @@ struct dentry {
         void *d_fsdata;                 /* fs-specific data */
 
         struct list_head d_lru;         /* LRU list */
+        struct list_head d_child;       /* child of parent list */
+        struct list_head d_subdirs;     /* our children */
         /*
-         * d_child and d_rcu can share memory
+         * d_alias and d_rcu can share memory
          */
         union {
-                struct list_head d_child;       /* child of parent list */
+                struct hlist_node d_alias;      /* inode alias list */
                 struct rcu_head d_rcu;
         } d_u;
-        struct list_head d_subdirs;     /* our children */
-        struct hlist_node d_alias;      /* inode alias list */
 };
 
 /*
@@ -226,17 +225,11 @@ struct dentry_operations {
 
 extern seqlock_t rename_lock;
 
-static inline int dname_external(const struct dentry *dentry)
-{
-        return dentry->d_name.name != dentry->d_iname;
-}
-
 /*
  * These are the low-level FS interfaces to the dcache..
  */
 extern void d_instantiate(struct dentry *, struct inode *);
 extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
-extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
 extern int d_instantiate_no_diralias(struct dentry *, struct inode *);
 extern void __d_drop(struct dentry *dentry);
 extern void d_drop(struct dentry *dentry);
@@ -254,7 +247,7 @@ extern struct dentry * d_obtain_root(struct inode *);
 extern void shrink_dcache_sb(struct super_block *);
 extern void shrink_dcache_parent(struct dentry *);
 extern void shrink_dcache_for_umount(struct super_block *);
-extern int d_invalidate(struct dentry *);
+extern void d_invalidate(struct dentry *);
 
 /* only used at mount-time */
 extern struct dentry * d_make_root(struct inode *);
@@ -269,7 +262,6 @@ extern void d_prune_aliases(struct inode *);
 
 /* test whether we have any submounts in a subdir tree */
 extern int have_submounts(struct dentry *);
-extern int check_submounts_and_drop(struct dentry *);
 
 /*
  * This adds the entry to the hash queues.
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 4d0b4d1aa132..da4c4983adbe 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -20,6 +20,7 @@
 
 #include <linux/types.h>
 
+struct device;
 struct file_operations;
 
 struct debugfs_blob_wrapper {
@@ -92,20 +93,25 @@ struct dentry *debugfs_create_regset32(const char *name, umode_t mode,
                                      struct dentry *parent,
                                      struct debugfs_regset32 *regset);
 
-int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
-                         int nregs, void __iomem *base, char *prefix);
+void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
+                          int nregs, void __iomem *base, char *prefix);
 
 struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
                                         struct dentry *parent,
                                         u32 *array, u32 elements);
 
+struct dentry *debugfs_create_devm_seqfile(struct device *dev, const char *name,
+                                           struct dentry *parent,
+                                           int (*read_fn)(struct seq_file *s,
+                                                          void *data));
+
 bool debugfs_initialized(void);
 
 #else
 
 #include <linux/err.h>
 
-/* 
+/*
  * We do not return NULL from these functions if CONFIG_DEBUG_FS is not enabled
  * so users have a chance to detect if there was a real error or not.  We don't
  * want to duplicate the design decision mistakes of procfs and devfs again.
@@ -233,10 +239,9 @@ static inline struct dentry *debugfs_create_regset32(const char *name,
         return ERR_PTR(-ENODEV);
 }
 
-static inline int debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
+static inline void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs,
                          int nregs, void __iomem *base, char *prefix)
 {
-        return 0;
 }
 
 static inline bool debugfs_initialized(void)
@@ -251,6 +256,15 @@ static inline struct dentry *debugfs_create_u32_array(const char *name, umode_t
         return ERR_PTR(-ENODEV);
 }
 
+static inline struct dentry *debugfs_create_devm_seqfile(struct device *dev,
+                                                         const char *name,
+                                                         struct dentry *parent,
+                                           int (*read_fn)(struct seq_file *s,
+                                                          void *data))
+{
+        return ERR_PTR(-ENODEV);
+}
+
 #endif
 
 #endif
diff --git a/include/linux/devcoredump.h b/include/linux/devcoredump.h
new file mode 100644
index 000000000000..c0a360e99f64
--- /dev/null
+++ b/include/linux/devcoredump.h
@@ -0,0 +1,35 @@
+#ifndef __DEVCOREDUMP_H
+#define __DEVCOREDUMP_H
+
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/vmalloc.h>
+
+#ifdef CONFIG_DEV_COREDUMP
+void dev_coredumpv(struct device *dev, const void *data, size_t datalen,
+                   gfp_t gfp);
+
+void dev_coredumpm(struct device *dev, struct module *owner,
+                   const void *data, size_t datalen, gfp_t gfp,
+                   ssize_t (*read)(char *buffer, loff_t offset, size_t count,
+                                   const void *data, size_t datalen),
+                   void (*free)(const void *data));
+#else
+static inline void dev_coredumpv(struct device *dev, const void *data,
+                                 size_t datalen, gfp_t gfp)
+{
+        vfree(data);
+}
+
+static inline void
+dev_coredumpm(struct device *dev, struct module *owner,
+              const void *data, size_t datalen, gfp_t gfp,
+              ssize_t (*read)(char *buffer, loff_t offset, size_t count,
+                              const void *data, size_t datalen),
+              void (*free)(const void *data))
+{
+        free(data);
+}
+#endif /* CONFIG_DEV_COREDUMP */
+
+#endif /* __DEVCOREDUMP_H */
diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h
index f1863dcd83ea..ce447f0f1bad 100644
--- a/include/linux/devfreq.h
+++ b/include/linux/devfreq.h
@@ -188,7 +188,7 @@ extern struct devfreq *devm_devfreq_add_device(struct device *dev,
 extern void devm_devfreq_remove_device(struct device *dev,
                                   struct devfreq *devfreq);
 
-/* Supposed to be called by PM_SLEEP/PM_RUNTIME callbacks */
+/* Supposed to be called by PM callbacks */
 extern int devfreq_suspend_device(struct devfreq *devfreq);
 extern int devfreq_resume_device(struct devfreq *devfreq);
 
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index e1707de043ae..ca6d2acc5eb7 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -64,6 +64,7 @@ typedef int (*dm_request_endio_fn) (struct dm_target *ti,
                                     union map_info *map_context);
 
 typedef void (*dm_presuspend_fn) (struct dm_target *ti);
+typedef void (*dm_presuspend_undo_fn) (struct dm_target *ti);
 typedef void (*dm_postsuspend_fn) (struct dm_target *ti);
 typedef int (*dm_preresume_fn) (struct dm_target *ti);
 typedef void (*dm_resume_fn) (struct dm_target *ti);
@@ -145,6 +146,7 @@ struct target_type {
         dm_endio_fn end_io;
         dm_request_endio_fn rq_end_io;
         dm_presuspend_fn presuspend;
+        dm_presuspend_undo_fn presuspend_undo;
         dm_postsuspend_fn postsuspend;
         dm_preresume_fn preresume;
         dm_resume_fn resume;
diff --git a/include/linux/device.h b/include/linux/device.h
index 43d183aeb25b..fb506738f7b7 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -181,13 +181,14 @@ extern int bus_unregister_notifier(struct bus_type *bus,
  * with the device lock held in the core, so be careful.
  */
 #define BUS_NOTIFY_ADD_DEVICE           0x00000001 /* device added */
-#define BUS_NOTIFY_DEL_DEVICE           0x00000002 /* device removed */
-#define BUS_NOTIFY_BIND_DRIVER          0x00000003 /* driver about to be
+#define BUS_NOTIFY_DEL_DEVICE           0x00000002 /* device to be removed */
+#define BUS_NOTIFY_REMOVED_DEVICE       0x00000003 /* device removed */
+#define BUS_NOTIFY_BIND_DRIVER          0x00000004 /* driver about to be
                                                       bound */
-#define BUS_NOTIFY_BOUND_DRIVER         0x00000004 /* driver bound to device */
-#define BUS_NOTIFY_UNBIND_DRIVER        0x00000005 /* driver about to be
+#define BUS_NOTIFY_BOUND_DRIVER         0x00000005 /* driver bound to device */
+#define BUS_NOTIFY_UNBIND_DRIVER        0x00000006 /* driver about to be
                                                       unbound */
-#define BUS_NOTIFY_UNBOUND_DRIVER       0x00000006 /* driver is unbound
+#define BUS_NOTIFY_UNBOUND_DRIVER       0x00000007 /* driver is unbound
                                                       from the device */
 
 extern struct kset *bus_get_kset(struct bus_type *bus);
@@ -607,8 +608,8 @@ extern int devres_release_group(struct device *dev, void *id);
 extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp);
 extern char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
                              va_list ap);
-extern char *devm_kasprintf(struct device *dev, gfp_t gfp,
-                            const char *fmt, ...);
+extern __printf(3, 4)
+char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...);
 static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
 {
         return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
@@ -910,6 +911,11 @@ static inline void device_unlock(struct device *dev)
         mutex_unlock(&dev->mutex);
 }
 
+static inline void device_lock_assert(struct device *dev)
+{
+        lockdep_assert_held(&dev->mutex);
+}
+
 void driver_init(void);
 
 /*
@@ -1117,6 +1123,41 @@ do {						     \
 })
 #endif
 
+#ifdef CONFIG_PRINTK
+#define dev_level_once(dev_level, dev, fmt, ...)                        \
+do {                                                                    \
+        static bool __print_once __read_mostly;                         \
+                                                                        \
+        if (!__print_once) {                                            \
+                __print_once = true;                                    \
+                dev_level(dev, fmt, ##__VA_ARGS__);                     \
+        }                                                               \
+} while (0)
+#else
+#define dev_level_once(dev_level, dev, fmt, ...)                        \
+do {                                                                    \
+        if (0)                                                          \
+                dev_level(dev, fmt, ##__VA_ARGS__);                     \
+} while (0)
+#endif
+
+#define dev_emerg_once(dev, fmt, ...)                                   \
+        dev_level_once(dev_emerg, dev, fmt, ##__VA_ARGS__)
+#define dev_alert_once(dev, fmt, ...)                                   \
+        dev_level_once(dev_alert, dev, fmt, ##__VA_ARGS__)
+#define dev_crit_once(dev, fmt, ...)                                    \
+        dev_level_once(dev_crit, dev, fmt, ##__VA_ARGS__)
+#define dev_err_once(dev, fmt, ...)                                     \
+        dev_level_once(dev_err, dev, fmt, ##__VA_ARGS__)
+#define dev_warn_once(dev, fmt, ...)                                    \
+        dev_level_once(dev_warn, dev, fmt, ##__VA_ARGS__)
+#define dev_notice_once(dev, fmt, ...)                                  \
+        dev_level_once(dev_notice, dev, fmt, ##__VA_ARGS__)
+#define dev_info_once(dev, fmt, ...)                                    \
+        dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
+#define dev_dbg_once(dev, fmt, ...)                                     \
+        dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
+
 #define dev_level_ratelimited(dev_level, dev, fmt, ...)                 \
 do {                                                                    \
         static DEFINE_RATELIMIT_STATE(_rs,                              \
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 931b70986272..c3007cb4bfa6 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -129,11 +129,14 @@ static inline int dma_coerce_mask_and_coherent(struct device *dev, u64 mask)
 
 extern u64 dma_get_required_mask(struct device *dev);
 
-#ifndef set_arch_dma_coherent_ops
-static inline int set_arch_dma_coherent_ops(struct device *dev)
-{
-        return 0;
-}
+#ifndef arch_setup_dma_ops
+static inline void arch_setup_dma_ops(struct device *dev, u64 dma_base,
+                                      u64 size, struct iommu_ops *iommu,
+                                      bool coherent) { }
+#endif
+
+#ifndef arch_teardown_dma_ops
+static inline void arch_teardown_dma_ops(struct device *dev) { }
 #endif
 
 static inline unsigned int dma_get_max_seg_size(struct device *dev)
@@ -263,6 +266,32 @@ struct dma_attrs;
 #define dma_unmap_sg_attrs(dev, sgl, nents, dir, attrs) \
         dma_unmap_sg(dev, sgl, nents, dir)
 
+#else
+static inline void *dma_alloc_writecombine(struct device *dev, size_t size,
+                                           dma_addr_t *dma_addr, gfp_t gfp)
+{
+        DEFINE_DMA_ATTRS(attrs);
+        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
+        return dma_alloc_attrs(dev, size, dma_addr, gfp, &attrs);
+}
+
+static inline void dma_free_writecombine(struct device *dev, size_t size,
+                                         void *cpu_addr, dma_addr_t dma_addr)
+{
+        DEFINE_DMA_ATTRS(attrs);
+        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
+        return dma_free_attrs(dev, size, cpu_addr, dma_addr, &attrs);
+}
+
+static inline int dma_mmap_writecombine(struct device *dev,
+                                        struct vm_area_struct *vma,
+                                        void *cpu_addr, dma_addr_t dma_addr,
+                                        size_t size)
+{
+        DEFINE_DMA_ATTRS(attrs);
+        dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
+        return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs);
+}
 #endif /* CONFIG_HAVE_DMA_ATTRS */
 
 #ifdef CONFIG_NEED_DMA_MAP_STATE
diff --git a/include/linux/dma/dw.h b/include/linux/dma/dw.h
new file mode 100644
index 000000000000..71456442ebe3
--- /dev/null
+++ b/include/linux/dma/dw.h
@@ -0,0 +1,64 @@
+/*
+ * Driver for the Synopsys DesignWare DMA Controller
+ *
+ * Copyright (C) 2007 Atmel Corporation
+ * Copyright (C) 2010-2011 ST Microelectronics
+ * Copyright (C) 2014 Intel 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.
+ */
+#ifndef _DMA_DW_H
+#define _DMA_DW_H
+
+#include <linux/clk.h>
+#include <linux/device.h>
+#include <linux/dmaengine.h>
+
+#include <linux/platform_data/dma-dw.h>
+
+struct dw_dma;
+
+/**
+ * struct dw_dma_chip - representation of DesignWare DMA controller hardware
+ * @dev:                struct device of the DMA controller
+ * @irq:                irq line
+ * @regs:               memory mapped I/O space
+ * @clk:                hclk clock
+ * @dw:                 struct dw_dma that is filed by dw_dma_probe()
+ */
+struct dw_dma_chip {
+        struct device   *dev;
+        int             irq;
+        void __iomem    *regs;
+        struct clk      *clk;
+        struct dw_dma   *dw;
+};
+
+/* Export to the platform drivers */
+int dw_dma_probe(struct dw_dma_chip *chip, struct dw_dma_platform_data *pdata);
+int dw_dma_remove(struct dw_dma_chip *chip);
+
+/* DMA API extensions */
+struct dw_desc;
+
+struct dw_cyclic_desc {
+        struct dw_desc  **desc;
+        unsigned long   periods;
+        void            (*period_callback)(void *param);
+        void            *period_callback_param;
+};
+
+struct dw_cyclic_desc *dw_dma_cyclic_prep(struct dma_chan *chan,
+                dma_addr_t buf_addr, size_t buf_len, size_t period_len,
+                enum dma_transfer_direction direction);
+void dw_dma_cyclic_free(struct dma_chan *chan);
+int dw_dma_cyclic_start(struct dma_chan *chan);
+void dw_dma_cyclic_stop(struct dma_chan *chan);
+
+dma_addr_t dw_dma_get_src_addr(struct dma_chan *chan);
+
+dma_addr_t dw_dma_get_dst_addr(struct dma_chan *chan);
+
+#endif /* _DMA_DW_H */
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 1f9e642c66ad..40cd75e21ea2 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -199,15 +199,12 @@ enum dma_ctrl_flags {
  * configuration data in statically from the platform). An additional
  * argument of struct dma_slave_config must be passed in with this
  * command.
- * @FSLDMA_EXTERNAL_START: this command will put the Freescale DMA controller
- * into external start mode.
  */
 enum dma_ctrl_cmd {
         DMA_TERMINATE_ALL,
         DMA_PAUSE,
         DMA_RESUME,
         DMA_SLAVE_CONFIG,
-        FSLDMA_EXTERNAL_START,
 };
 
 /**
@@ -307,7 +304,9 @@ enum dma_slave_buswidth {
  * struct dma_slave_config - dma slave channel runtime config
  * @direction: whether the data shall go in or out on this slave
  * channel, right now. DMA_MEM_TO_DEV and DMA_DEV_TO_MEM are
- * legal values.
+ * legal values. DEPRECATED, drivers should use the direction argument
+ * to the device_prep_slave_sg and device_prep_dma_cyclic functions or
+ * the dir field in the dma_interleaved_template structure.
  * @src_addr: this is the physical address where DMA slave data
  * should be read (RX), if the source is memory this argument is
  * ignored.
@@ -448,7 +447,8 @@ struct dmaengine_unmap_data {
  *      communicate status
  * @phys: physical address of the descriptor
  * @chan: target channel for this operation
- * @tx_submit: set the prepared descriptor(s) to be executed by the engine
+ * @tx_submit: accept the descriptor, assign ordered cookie and mark the
+ * descriptor pending. To be pushed on .issue_pending() call
  * @callback: routine to call after this operation is complete
  * @callback_param: general parameter to pass to the callback routine
  * ---async_tx api specific fields---
@@ -755,6 +755,16 @@ static inline struct dma_async_tx_descriptor *dmaengine_prep_interleaved_dma(
         return chan->device->device_prep_interleaved_dma(chan, xt, flags);
 }
 
+static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_sg(
+                struct dma_chan *chan,
+                struct scatterlist *dst_sg, unsigned int dst_nents,
+                struct scatterlist *src_sg, unsigned int src_nents,
+                unsigned long flags)
+{
+        return chan->device->device_prep_dma_sg(chan, dst_sg, dst_nents,
+                        src_sg, src_nents, flags);
+}
+
 static inline int dma_get_slave_caps(struct dma_chan *chan, struct dma_slave_caps *caps)
 {
         if (!chan || !caps)
@@ -900,18 +910,6 @@ static inline void dmaengine_put(void)
 }
 #endif
 
-#ifdef CONFIG_NET_DMA
-#define net_dmaengine_get()     dmaengine_get()
-#define net_dmaengine_put()     dmaengine_put()
-#else
-static inline void net_dmaengine_get(void)
-{
-}
-static inline void net_dmaengine_put(void)
-{
-}
-#endif
-
 #ifdef CONFIG_ASYNC_TX_DMA
 #define async_dmaengine_get()   dmaengine_get()
 #define async_dmaengine_put()   dmaengine_put()
@@ -933,16 +931,8 @@ async_dma_find_channel(enum dma_transaction_type type)
         return NULL;
 }
 #endif /* CONFIG_ASYNC_TX_DMA */
-
-dma_cookie_t dma_async_memcpy_buf_to_buf(struct dma_chan *chan,
-        void *dest, void *src, size_t len);
-dma_cookie_t dma_async_memcpy_buf_to_pg(struct dma_chan *chan,
-        struct page *page, unsigned int offset, void *kdata, size_t len);
-dma_cookie_t dma_async_memcpy_pg_to_pg(struct dma_chan *chan,
-        struct page *dest_pg, unsigned int dest_off, struct page *src_pg,
-        unsigned int src_off, size_t len);
 void dma_async_tx_descriptor_init(struct dma_async_tx_descriptor *tx,
-        struct dma_chan *chan);
+                                  struct dma_chan *chan);
 
 static inline void async_tx_ack(struct dma_async_tx_descriptor *tx)
 {
diff --git a/include/linux/dmar.h b/include/linux/dmar.h
index 1deece46a0ca..30624954dec5 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -30,6 +30,12 @@
 
 struct acpi_dmar_header;
 
+#ifdef  CONFIG_X86
+# define        DMAR_UNITS_SUPPORTED    MAX_IO_APICS
+#else
+# define        DMAR_UNITS_SUPPORTED    64
+#endif
+
 /* DMAR Flags */
 #define DMAR_INTR_REMAP         0x1
 #define DMAR_X2APIC_OPT_OUT     0x2
@@ -56,13 +62,19 @@ struct dmar_drhd_unit {
         struct intel_iommu *iommu;
 };
 
+struct dmar_pci_path {
+        u8 bus;
+        u8 device;
+        u8 function;
+};
+
 struct dmar_pci_notify_info {
         struct pci_dev                  *dev;
         unsigned long                   event;
         int                             bus;
         u16                             seg;
         u16                             level;
-        struct acpi_dmar_pci_path       path[];
+        struct dmar_pci_path            path[];
 }  __attribute__((packed));
 
 extern struct rw_semaphore dmar_global_lock;
@@ -114,28 +126,60 @@ extern int dmar_remove_dev_scope(struct dmar_pci_notify_info *info,
 /* Intel IOMMU detection */
 extern int detect_intel_iommu(void);
 extern int enable_drhd_fault_handling(void);
+extern int dmar_device_add(acpi_handle handle);
+extern int dmar_device_remove(acpi_handle handle);
+
+static inline int dmar_res_noop(struct acpi_dmar_header *hdr, void *arg)
+{
+        return 0;
+}
 
 #ifdef CONFIG_INTEL_IOMMU
 extern int iommu_detected, no_iommu;
 extern int intel_iommu_init(void);
-extern int dmar_parse_one_rmrr(struct acpi_dmar_header *header);
-extern int dmar_parse_one_atsr(struct acpi_dmar_header *header);
+extern int dmar_parse_one_rmrr(struct acpi_dmar_header *header, void *arg);
+extern int dmar_parse_one_atsr(struct acpi_dmar_header *header, void *arg);
+extern int dmar_check_one_atsr(struct acpi_dmar_header *hdr, void *arg);
+extern int dmar_release_one_atsr(struct acpi_dmar_header *hdr, void *arg);
+extern int dmar_iommu_hotplug(struct dmar_drhd_unit *dmaru, bool insert);
 extern int dmar_iommu_notify_scope_dev(struct dmar_pci_notify_info *info);
 #else /* !CONFIG_INTEL_IOMMU: */
 static inline int intel_iommu_init(void) { return -ENODEV; }
-static inline int dmar_parse_one_rmrr(struct acpi_dmar_header *header)
+
+#define dmar_parse_one_rmrr             dmar_res_noop
+#define dmar_parse_one_atsr             dmar_res_noop
+#define dmar_check_one_atsr             dmar_res_noop
+#define dmar_release_one_atsr           dmar_res_noop
+
+static inline int dmar_iommu_notify_scope_dev(struct dmar_pci_notify_info *info)
 {
         return 0;
 }
-static inline int dmar_parse_one_atsr(struct acpi_dmar_header *header)
+
+static inline int dmar_iommu_hotplug(struct dmar_drhd_unit *dmaru, bool insert)
 {
         return 0;
 }
-static inline int dmar_iommu_notify_scope_dev(struct dmar_pci_notify_info *info)
+#endif /* CONFIG_INTEL_IOMMU */
+
+#ifdef CONFIG_IRQ_REMAP
+extern int dmar_ir_hotplug(struct dmar_drhd_unit *dmaru, bool insert);
+#else  /* CONFIG_IRQ_REMAP */
+static inline int dmar_ir_hotplug(struct dmar_drhd_unit *dmaru, bool insert)
+{ return 0; }
+#endif /* CONFIG_IRQ_REMAP */
+
+#else /* CONFIG_DMAR_TABLE */
+
+static inline int dmar_device_add(void *handle)
+{
+        return 0;
+}
+
+static inline int dmar_device_remove(void *handle)
 {
         return 0;
 }
-#endif /* CONFIG_INTEL_IOMMU */
 
 #endif /* CONFIG_DMAR_TABLE */
 
diff --git a/include/linux/drbd.h b/include/linux/drbd.h
index debb70d40547..8723f2a99e15 100644
--- a/include/linux/drbd.h
+++ b/include/linux/drbd.h
@@ -172,7 +172,7 @@ enum drbd_ret_code {
         ERR_RES_NOT_KNOWN       = 158,
         ERR_RES_IN_USE          = 159,
         ERR_MINOR_CONFIGURED    = 160,
-        ERR_MINOR_EXISTS        = 161,
+        ERR_MINOR_OR_VOLUME_EXISTS = 161,
         ERR_INVALID_REQUEST     = 162,
         ERR_NEED_APV_100        = 163,
         ERR_NEED_ALLOW_TWO_PRI  = 164,
diff --git a/include/linux/dw_dmac.h b/include/linux/dw_dmac.h
deleted file mode 100644
index 68b4024184de..000000000000
--- a/include/linux/dw_dmac.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Driver for the Synopsys DesignWare DMA Controller
- *
- * Copyright (C) 2007 Atmel Corporation
- * Copyright (C) 2010-2011 ST Microelectronics
- *
- * 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 DW_DMAC_H
-#define DW_DMAC_H
-
-#include <linux/dmaengine.h>
-
-/**
- * struct dw_dma_slave - Controller-specific information about a slave
- *
- * @dma_dev: required DMA master device. Depricated.
- * @bus_id: name of this device channel, not just a device name since
- *          devices may have more than one channel e.g. "foo_tx"
- * @cfg_hi: Platform-specific initializer for the CFG_HI register
- * @cfg_lo: Platform-specific initializer for the CFG_LO register
- * @src_master: src master for transfers on allocated channel.
- * @dst_master: dest master for transfers on allocated channel.
- */
-struct dw_dma_slave {
-        struct device           *dma_dev;
-        u32                     cfg_hi;
-        u32                     cfg_lo;
-        u8                      src_master;
-        u8                      dst_master;
-};
-
-/**
- * struct dw_dma_platform_data - Controller configuration parameters
- * @nr_channels: Number of channels supported by hardware (max 8)
- * @is_private: The device channels should be marked as private and not for
- *      by the general purpose DMA channel allocator.
- * @chan_allocation_order: Allocate channels starting from 0 or 7
- * @chan_priority: Set channel priority increasing from 0 to 7 or 7 to 0.
- * @block_size: Maximum block size supported by the controller
- * @nr_masters: Number of AHB masters supported by the controller
- * @data_width: Maximum data width supported by hardware per AHB master
- *              (0 - 8bits, 1 - 16bits, ..., 5 - 256bits)
- */
-struct dw_dma_platform_data {
-        unsigned int    nr_channels;
-        bool            is_private;
-#define CHAN_ALLOCATION_ASCENDING       0       /* zero to seven */
-#define CHAN_ALLOCATION_DESCENDING      1       /* seven to zero */
-        unsigned char   chan_allocation_order;
-#define CHAN_PRIORITY_ASCENDING         0       /* chan0 highest */
-#define CHAN_PRIORITY_DESCENDING        1       /* chan7 highest */
-        unsigned char   chan_priority;
-        unsigned short  block_size;
-        unsigned char   nr_masters;
-        unsigned char   data_width[4];
-};
-
-/* bursts size */
-enum dw_dma_msize {
-        DW_DMA_MSIZE_1,
-        DW_DMA_MSIZE_4,
-        DW_DMA_MSIZE_8,
-        DW_DMA_MSIZE_16,
-        DW_DMA_MSIZE_32,
-        DW_DMA_MSIZE_64,
-        DW_DMA_MSIZE_128,
-        DW_DMA_MSIZE_256,
-};
-
-/* Platform-configurable bits in CFG_HI */
-#define DWC_CFGH_FCMODE         (1 << 0)
-#define DWC_CFGH_FIFO_MODE      (1 << 1)
-#define DWC_CFGH_PROTCTL(x)     ((x) << 2)
-#define DWC_CFGH_SRC_PER(x)     ((x) << 7)
-#define DWC_CFGH_DST_PER(x)     ((x) << 11)
-
-/* Platform-configurable bits in CFG_LO */
-#define DWC_CFGL_LOCK_CH_XFER   (0 << 12)       /* scope of LOCK_CH */
-#define DWC_CFGL_LOCK_CH_BLOCK  (1 << 12)
-#define DWC_CFGL_LOCK_CH_XACT   (2 << 12)
-#define DWC_CFGL_LOCK_BUS_XFER  (0 << 14)       /* scope of LOCK_BUS */
-#define DWC_CFGL_LOCK_BUS_BLOCK (1 << 14)
-#define DWC_CFGL_LOCK_BUS_XACT  (2 << 14)
-#define DWC_CFGL_LOCK_CH        (1 << 15)       /* channel lockout */
-#define DWC_CFGL_LOCK_BUS       (1 << 16)       /* busmaster lockout */
-#define DWC_CFGL_HS_DST_POL     (1 << 18)       /* dst handshake active low */
-#define DWC_CFGL_HS_SRC_POL     (1 << 19)       /* src handshake active low */
-
-/* DMA API extensions */
-struct dw_cyclic_desc {
-        struct dw_desc  **desc;
-        unsigned long   periods;
-        void            (*period_callback)(void *param);
-        void            *period_callback_param;
-};
-
-struct dw_cyclic_desc *dw_dma_cyclic_prep(struct dma_chan *chan,
-                dma_addr_t buf_addr, size_t buf_len, size_t period_len,
-                enum dma_transfer_direction direction);
-void dw_dma_cyclic_free(struct dma_chan *chan);
-int dw_dma_cyclic_start(struct dma_chan *chan);
-void dw_dma_cyclic_stop(struct dma_chan *chan);
-
-dma_addr_t dw_dma_get_src_addr(struct dma_chan *chan);
-
-dma_addr_t dw_dma_get_dst_addr(struct dma_chan *chan);
-
-#endif /* DW_DMAC_H */
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index 2fe93b26b42f..4f1bbc68cd1b 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -42,7 +42,7 @@ int ddebug_add_module(struct _ddebug *tab, unsigned int n,
 #if defined(CONFIG_DYNAMIC_DEBUG)
 extern int ddebug_remove_module(const char *mod_name);
 extern __printf(2, 3)
-int __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
+void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
 
 extern int ddebug_dyndbg_module_param_cb(char *param, char *val,
                                         const char *modname);
@@ -50,15 +50,15 @@ extern int ddebug_dyndbg_module_param_cb(char *param, char *val,
 struct device;
 
 extern __printf(3, 4)
-int __dynamic_dev_dbg(struct _ddebug *descriptor, const struct device *dev,
-                      const char *fmt, ...);
+void __dynamic_dev_dbg(struct _ddebug *descriptor, const struct device *dev,
+                       const char *fmt, ...);
 
 struct net_device;
 
 extern __printf(3, 4)
-int __dynamic_netdev_dbg(struct _ddebug *descriptor,
-                         const struct net_device *dev,
-                         const char *fmt, ...);
+void __dynamic_netdev_dbg(struct _ddebug *descriptor,
+                          const struct net_device *dev,
+                          const char *fmt, ...);
 
 #define DEFINE_DYNAMIC_DEBUG_METADATA(name, fmt)                \
         static struct _ddebug  __aligned(8)                     \
diff --git a/include/linux/dynamic_queue_limits.h b/include/linux/dynamic_queue_limits.h
index 5621547d631b..a4be70398ce1 100644
--- a/include/linux/dynamic_queue_limits.h
+++ b/include/linux/dynamic_queue_limits.h
@@ -73,14 +73,22 @@ static inline void dql_queued(struct dql *dql, unsigned int count)
 {
         BUG_ON(count > DQL_MAX_OBJECT);
 
-        dql->num_queued += count;
         dql->last_obj_cnt = count;
+
+        /* We want to force a write first, so that cpu do not attempt
+         * to get cache line containing last_obj_cnt, num_queued, adj_limit
+         * in Shared state, but directly does a Request For Ownership
+         * It is only a hint, we use barrier() only.
+         */
+        barrier();
+
+        dql->num_queued += count;
 }
 
 /* Returns how many objects can be queued, < 0 indicates over limit. */
 static inline int dql_avail(const struct dql *dql)
 {
-        return dql->adj_limit - dql->num_queued;
+        return ACCESS_ONCE(dql->adj_limit) - ACCESS_ONCE(dql->num_queued);
 }
 
 /* Record number of completed objects and recalculate the limit. */
diff --git a/include/linux/edac.h b/include/linux/edac.h
index e1e68da6f35c..da3b72e95db3 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -194,7 +194,8 @@ static inline char *mc_event_error_type(const unsigned int err_type)
  * @MEM_DDR3:           DDR3 RAM
  * @MEM_RDDR3:          Registered DDR3 RAM
  *                      This is a variant of the DDR3 memories.
- * @MEM_DDR4:           DDR4 RAM
+ * @MEM_LRDDR3          Load-Reduced DDR3 memory.
+ * @MEM_DDR4:           Unbuffered DDR4 RAM
  * @MEM_RDDR4:          Registered DDR4 RAM
  *                      This is a variant of the DDR4 memories.
  */
@@ -216,6 +217,7 @@ enum mem_type {
         MEM_XDR,
         MEM_DDR3,
         MEM_RDDR3,
+        MEM_LRDDR3,
         MEM_DDR4,
         MEM_RDDR4,
 };
diff --git a/include/linux/eeprom_93cx6.h b/include/linux/eeprom_93cx6.h
index e50f98b0297a..eb0b1988050a 100644
--- a/include/linux/eeprom_93cx6.h
+++ b/include/linux/eeprom_93cx6.h
@@ -75,6 +75,10 @@ extern void eeprom_93cx6_read(struct eeprom_93cx6 *eeprom,
         const u8 word, u16 *data);
 extern void eeprom_93cx6_multiread(struct eeprom_93cx6 *eeprom,
         const u8 word, __le16 *data, const u16 words);
+extern void eeprom_93cx6_readb(struct eeprom_93cx6 *eeprom,
+        const u8 byte, u8 *data);
+extern void eeprom_93cx6_multireadb(struct eeprom_93cx6 *eeprom,
+        const u8 byte, u8 *data, const u16 bytes);
 
 extern void eeprom_93cx6_wren(struct eeprom_93cx6 *eeprom, bool enable);
 
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 45cb4ffdea62..0238d612750e 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -92,6 +92,7 @@ typedef	struct {
 #define EFI_MEMORY_WC           ((u64)0x0000000000000002ULL)    /* write-coalescing */
 #define EFI_MEMORY_WT           ((u64)0x0000000000000004ULL)    /* write-through */
 #define EFI_MEMORY_WB           ((u64)0x0000000000000008ULL)    /* write-back */
+#define EFI_MEMORY_UCE          ((u64)0x0000000000000010ULL)    /* uncached, exported */
 #define EFI_MEMORY_WP           ((u64)0x0000000000001000ULL)    /* write-protect */
 #define EFI_MEMORY_RP           ((u64)0x0000000000002000ULL)    /* read-protect */
 #define EFI_MEMORY_XP           ((u64)0x0000000000004000ULL)    /* execute-protect */
@@ -502,6 +503,10 @@ typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char
 typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor, 
                                          u32 attr, unsigned long data_size,
                                          void *data);
+typedef efi_status_t
+efi_set_variable_nonblocking_t(efi_char16_t *name, efi_guid_t *vendor,
+                               u32 attr, unsigned long data_size, void *data);
+
 typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
 typedef void efi_reset_system_t (int reset_type, efi_status_t status,
                                  unsigned long data_size, efi_char16_t *data);
@@ -542,6 +547,9 @@ void efi_native_runtime_setup(void);
 #define SMBIOS_TABLE_GUID    \
     EFI_GUID(  0xeb9d2d31, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
 
+#define SMBIOS3_TABLE_GUID    \
+    EFI_GUID(  0xf2fd1544, 0x9794, 0x4a2c, 0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94 )
+
 #define SAL_SYSTEM_TABLE_GUID    \
     EFI_GUID(  0xeb9d2d32, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
 
@@ -805,7 +813,8 @@ extern struct efi {
         unsigned long mps;              /* MPS table */
         unsigned long acpi;             /* ACPI table  (IA64 ext 0.71) */
         unsigned long acpi20;           /* ACPI table  (ACPI 2.0) */
-        unsigned long smbios;           /* SM BIOS table */
+        unsigned long smbios;           /* SMBIOS table (32 bit entry point) */
+        unsigned long smbios3;          /* SMBIOS table (64 bit entry point) */
         unsigned long sal_systab;       /* SAL system table */
         unsigned long boot_info;        /* boot info table */
         unsigned long hcdp;             /* HCDP table */
@@ -821,6 +830,7 @@ extern struct efi {
         efi_get_variable_t *get_variable;
         efi_get_next_variable_t *get_next_variable;
         efi_set_variable_t *set_variable;
+        efi_set_variable_nonblocking_t *set_variable_nonblocking;
         efi_query_variable_info_t *query_variable_info;
         efi_update_capsule_t *update_capsule;
         efi_query_capsule_caps_t *query_capsule_caps;
@@ -886,6 +896,13 @@ extern bool efi_poweroff_required(void);
              (md) <= (efi_memory_desc_t *)((m)->map_end - (m)->desc_size); \
              (md) = (void *)(md) + (m)->desc_size)
 
+/*
+ * Format an EFI memory descriptor's type and attributes to a user-provided
+ * character buffer, as per snprintf(), and return the buffer.
+ */
+char * __init efi_md_typeattr_format(char *buf, size_t size,
+                                     const efi_memory_desc_t *md);
+
 /**
  * efi_range_is_wc - check the WC bit on an address range
  * @start: starting kvirt address
@@ -1034,6 +1051,7 @@ struct efivar_operations {
         efi_get_variable_t *get_variable;
         efi_get_next_variable_t *get_next_variable;
         efi_set_variable_t *set_variable;
+        efi_set_variable_nonblocking_t *set_variable_nonblocking;
         efi_query_variable_store_t *query_variable_store;
 };
 
@@ -1227,4 +1245,7 @@ efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
                                   unsigned long *load_addr,
                                   unsigned long *load_size);
 
+efi_status_t efi_parse_options(char *cmdline);
+
+bool efi_runtime_disabled(void);
 #endif /* _LINUX_EFI_H */
diff --git a/include/linux/elf.h b/include/linux/elf.h
index 67a5fa7830c4..20fa8d8ae313 100644
--- a/include/linux/elf.h
+++ b/include/linux/elf.h
@@ -15,6 +15,11 @@
         set_personality(PER_LINUX | (current->personality & (~PER_MASK)))
 #endif
 
+#ifndef SET_PERSONALITY2
+#define SET_PERSONALITY2(ex, state) \
+        SET_PERSONALITY(ex)
+#endif
+
 #if ELF_CLASS == ELFCLASS32
 
 extern Elf32_Dyn _DYNAMIC [];
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 9c5529dc6d07..41c891d05f04 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -29,6 +29,7 @@
 #include <asm/bitsperlong.h>
 
 #ifdef __KERNEL__
+u32 eth_get_headlen(void *data, unsigned int max_len);
 __be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev);
 extern const struct header_ops eth_header_ops;
 
@@ -391,4 +392,16 @@ static inline unsigned long compare_ether_header(const void *a, const void *b)
 #endif
 }
 
+/**
+ * eth_skb_pad - Pad buffer to mininum number of octets for Ethernet frame
+ * @skb: Buffer to pad
+ *
+ * An Ethernet frame should have a minimum size of 60 bytes.  This function
+ * takes short frames and pads them with zeros up to the 60 byte limit.
+ */
+static inline int eth_skb_pad(struct sk_buff *skb)
+{
+        return skb_put_padto(skb, ETH_ZLEN);
+}
+
 #endif  /* _LINUX_ETHERDEVICE_H */
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index e658229fee39..653dc9c4ebac 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -59,6 +59,26 @@ enum ethtool_phys_id_state {
         ETHTOOL_ID_OFF
 };
 
+enum {
+        ETH_RSS_HASH_TOP_BIT, /* Configurable RSS hash function - Toeplitz */
+        ETH_RSS_HASH_XOR_BIT, /* Configurable RSS hash function - Xor */
+
+        /*
+         * Add your fresh new hash function bits above and remember to update
+         * rss_hash_func_strings[] in ethtool.c
+         */
+        ETH_RSS_HASH_FUNCS_COUNT
+};
+
+#define __ETH_RSS_HASH_BIT(bit) ((u32)1 << (bit))
+#define __ETH_RSS_HASH(name)    __ETH_RSS_HASH_BIT(ETH_RSS_HASH_##name##_BIT)
+
+#define ETH_RSS_HASH_TOP        __ETH_RSS_HASH(TOP)
+#define ETH_RSS_HASH_XOR        __ETH_RSS_HASH(XOR)
+
+#define ETH_RSS_HASH_UNKNOWN    0
+#define ETH_RSS_HASH_NO_CHANGE  0
+
 struct net_device;
 
 /* Some generic methods drivers may use in their ethtool_ops */
@@ -158,17 +178,14 @@ static inline u32 ethtool_rxfh_indir_default(u32 index, u32 n_rx_rings)
  *      Returns zero if not supported for this specific device.
  * @get_rxfh_indir_size: Get the size of the RX flow hash indirection table.
  *      Returns zero if not supported for this specific device.
- * @get_rxfh: Get the contents of the RX flow hash indirection table and hash
- *      key.
- *      Will only be called if one or both of @get_rxfh_indir_size and
- *      @get_rxfh_key_size are implemented and return non-zero.
- *      Returns a negative error code or zero.
- * @set_rxfh: Set the contents of the RX flow hash indirection table and/or
- *      hash key.  In case only the indirection table or hash key is to be
- *      changed, the other argument will be %NULL.
- *      Will only be called if one or both of @get_rxfh_indir_size and
- *      @get_rxfh_key_size are implemented and return non-zero.
+ * @get_rxfh: Get the contents of the RX flow hash indirection table, hash key
+ *      and/or hash function.
  *      Returns a negative error code or zero.
+ * @set_rxfh: Set the contents of the RX flow hash indirection table, hash
+ *      key, and/or hash function.  Arguments which are set to %NULL or zero
+ *      will remain unchanged.
+ *      Returns a negative error code or zero. An error code must be returned
+ *      if at least one unsupported change was requested.
  * @get_channels: Get number of channels.
  * @set_channels: Set number of channels.  Returns a negative error code or
  *      zero.
@@ -241,9 +258,10 @@ struct ethtool_ops {
         int     (*reset)(struct net_device *, u32 *);
         u32     (*get_rxfh_key_size)(struct net_device *);
         u32     (*get_rxfh_indir_size)(struct net_device *);
-        int     (*get_rxfh)(struct net_device *, u32 *indir, u8 *key);
+        int     (*get_rxfh)(struct net_device *, u32 *indir, u8 *key,
+                            u8 *hfunc);
         int     (*set_rxfh)(struct net_device *, const u32 *indir,
-                            const u8 *key);
+                            const u8 *key, const u8 hfunc);
         void    (*get_channels)(struct net_device *, struct ethtool_channels *);
         int     (*set_channels)(struct net_device *, struct ethtool_channels *);
         int     (*get_dump_flag)(struct net_device *, struct ethtool_dump *);
@@ -257,6 +275,10 @@ struct ethtool_ops {
                                      struct ethtool_eeprom *, u8 *);
         int     (*get_eee)(struct net_device *, struct ethtool_eee *);
         int     (*set_eee)(struct net_device *, struct ethtool_eee *);
+        int     (*get_tunable)(struct net_device *,
+                               const struct ethtool_tunable *, void *);
+        int     (*set_tunable)(struct net_device *,
+                               const struct ethtool_tunable *, const void *);
 
 
 };
diff --git a/include/linux/extcon/extcon-gpio.h b/include/linux/extcon/extcon-gpio.h
index 8900fdf511c6..0b17ad43fbfc 100644
--- a/include/linux/extcon/extcon-gpio.h
+++ b/include/linux/extcon/extcon-gpio.h
@@ -34,8 +34,10 @@
  * @irq_flags:          IRQ Flags (e.g., IRQF_TRIGGER_LOW).
  * @state_on:           print_state is overriden with state_on if attached.
  *                      If NULL, default method of extcon class is used.
- * @state_off:          print_state is overriden with state_on if detached.
+ * @state_off:          print_state is overriden with state_off if detached.
  *                      If NUll, default method of extcon class is used.
+ * @check_on_resume:    Boolean describing whether to check the state of gpio
+ *                      while resuming from sleep.
  *
  * Note that in order for state_on or state_off to be valid, both state_on
  * and state_off should be not NULL. If at least one of them is NULL,
diff --git a/include/linux/extcon/sm5502.h b/include/linux/extcon/sm5502.h
deleted file mode 100644
index 030526bf8d79..000000000000
--- a/include/linux/extcon/sm5502.h
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- * sm5502.h
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- * 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_EXTCON_SM5502_H
-#define __LINUX_EXTCON_SM5502_H
-
-enum sm5502_types {
-        TYPE_SM5502,
-};
-
-/* SM5502 registers */
-enum sm5502_reg {
-        SM5502_REG_DEVICE_ID = 0x01,
-        SM5502_REG_CONTROL,
-        SM5502_REG_INT1,
-        SM5502_REG_INT2,
-        SM5502_REG_INTMASK1,
-        SM5502_REG_INTMASK2,
-        SM5502_REG_ADC,
-        SM5502_REG_TIMING_SET1,
-        SM5502_REG_TIMING_SET2,
-        SM5502_REG_DEV_TYPE1,
-        SM5502_REG_DEV_TYPE2,
-        SM5502_REG_BUTTON1,
-        SM5502_REG_BUTTON2,
-        SM5502_REG_CAR_KIT_STATUS,
-        SM5502_REG_RSVD1,
-        SM5502_REG_RSVD2,
-        SM5502_REG_RSVD3,
-        SM5502_REG_RSVD4,
-        SM5502_REG_MANUAL_SW1,
-        SM5502_REG_MANUAL_SW2,
-        SM5502_REG_DEV_TYPE3,
-        SM5502_REG_RSVD5,
-        SM5502_REG_RSVD6,
-        SM5502_REG_RSVD7,
-        SM5502_REG_RSVD8,
-        SM5502_REG_RSVD9,
-        SM5502_REG_RESET,
-        SM5502_REG_RSVD10,
-        SM5502_REG_RESERVED_ID1,
-        SM5502_REG_RSVD11,
-        SM5502_REG_RSVD12,
-        SM5502_REG_RESERVED_ID2,
-        SM5502_REG_RSVD13,
-        SM5502_REG_OCP,
-        SM5502_REG_RSVD14,
-        SM5502_REG_RSVD15,
-        SM5502_REG_RSVD16,
-        SM5502_REG_RSVD17,
-        SM5502_REG_RSVD18,
-        SM5502_REG_RSVD19,
-        SM5502_REG_RSVD20,
-        SM5502_REG_RSVD21,
-        SM5502_REG_RSVD22,
-        SM5502_REG_RSVD23,
-        SM5502_REG_RSVD24,
-        SM5502_REG_RSVD25,
-        SM5502_REG_RSVD26,
-        SM5502_REG_RSVD27,
-        SM5502_REG_RSVD28,
-        SM5502_REG_RSVD29,
-        SM5502_REG_RSVD30,
-        SM5502_REG_RSVD31,
-        SM5502_REG_RSVD32,
-        SM5502_REG_RSVD33,
-        SM5502_REG_RSVD34,
-        SM5502_REG_RSVD35,
-        SM5502_REG_RSVD36,
-        SM5502_REG_RESERVED_ID3,
-
-        SM5502_REG_END,
-};
-
-/* Define SM5502 MASK/SHIFT constant */
-#define SM5502_REG_DEVICE_ID_VENDOR_SHIFT       0
-#define SM5502_REG_DEVICE_ID_VERSION_SHIFT      3
-#define SM5502_REG_DEVICE_ID_VENDOR_MASK        (0x3 << SM5502_REG_DEVICE_ID_VENDOR_SHIFT)
-#define SM5502_REG_DEVICE_ID_VERSION_MASK       (0x1f << SM5502_REG_DEVICE_ID_VERSION_SHIFT)
-
-#define SM5502_REG_CONTROL_MASK_INT_SHIFT       0
-#define SM5502_REG_CONTROL_WAIT_SHIFT           1
-#define SM5502_REG_CONTROL_MANUAL_SW_SHIFT      2
-#define SM5502_REG_CONTROL_RAW_DATA_SHIFT       3
-#define SM5502_REG_CONTROL_SW_OPEN_SHIFT        4
-#define SM5502_REG_CONTROL_MASK_INT_MASK        (0x1 << SM5502_REG_CONTROL_MASK_INT_SHIFT)
-#define SM5502_REG_CONTROL_WAIT_MASK            (0x1 << SM5502_REG_CONTROL_WAIT_SHIFT)
-#define SM5502_REG_CONTROL_MANUAL_SW_MASK       (0x1 << SM5502_REG_CONTROL_MANUAL_SW_SHIFT)
-#define SM5502_REG_CONTROL_RAW_DATA_MASK        (0x1 << SM5502_REG_CONTROL_RAW_DATA_SHIFT)
-#define SM5502_REG_CONTROL_SW_OPEN_MASK         (0x1 << SM5502_REG_CONTROL_SW_OPEN_SHIFT)
-
-#define SM5502_REG_INTM1_ATTACH_SHIFT           0
-#define SM5502_REG_INTM1_DETACH_SHIFT           1
-#define SM5502_REG_INTM1_KP_SHIFT               2
-#define SM5502_REG_INTM1_LKP_SHIFT              3
-#define SM5502_REG_INTM1_LKR_SHIFT              4
-#define SM5502_REG_INTM1_OVP_EVENT_SHIFT        5
-#define SM5502_REG_INTM1_OCP_EVENT_SHIFT        6
-#define SM5502_REG_INTM1_OVP_OCP_DIS_SHIFT      7
-#define SM5502_REG_INTM1_ATTACH_MASK            (0x1 << SM5502_REG_INTM1_ATTACH_SHIFT)
-#define SM5502_REG_INTM1_DETACH_MASK            (0x1 << SM5502_REG_INTM1_DETACH_SHIFT)
-#define SM5502_REG_INTM1_KP_MASK                (0x1 << SM5502_REG_INTM1_KP_SHIFT)
-#define SM5502_REG_INTM1_LKP_MASK               (0x1 << SM5502_REG_INTM1_LKP_SHIFT)
-#define SM5502_REG_INTM1_LKR_MASK               (0x1 << SM5502_REG_INTM1_LKR_SHIFT)
-#define SM5502_REG_INTM1_OVP_EVENT_MASK         (0x1 << SM5502_REG_INTM1_OVP_EVENT_SHIFT)
-#define SM5502_REG_INTM1_OCP_EVENT_MASK         (0x1 << SM5502_REG_INTM1_OCP_EVENT_SHIFT)
-#define SM5502_REG_INTM1_OVP_OCP_DIS_MASK       (0x1 << SM5502_REG_INTM1_OVP_OCP_DIS_SHIFT)
-
-#define SM5502_REG_INTM2_VBUS_DET_SHIFT         0
-#define SM5502_REG_INTM2_REV_ACCE_SHIFT         1
-#define SM5502_REG_INTM2_ADC_CHG_SHIFT          2
-#define SM5502_REG_INTM2_STUCK_KEY_SHIFT        3
-#define SM5502_REG_INTM2_STUCK_KEY_RCV_SHIFT    4
-#define SM5502_REG_INTM2_MHL_SHIFT              5
-#define SM5502_REG_INTM2_VBUS_DET_MASK          (0x1 << SM5502_REG_INTM2_VBUS_DET_SHIFT)
-#define SM5502_REG_INTM2_REV_ACCE_MASK          (0x1 << SM5502_REG_INTM2_REV_ACCE_SHIFT)
-#define SM5502_REG_INTM2_ADC_CHG_MASK           (0x1 << SM5502_REG_INTM2_ADC_CHG_SHIFT)
-#define SM5502_REG_INTM2_STUCK_KEY_MASK         (0x1 << SM5502_REG_INTM2_STUCK_KEY_SHIFT)
-#define SM5502_REG_INTM2_STUCK_KEY_RCV_MASK     (0x1 << SM5502_REG_INTM2_STUCK_KEY_RCV_SHIFT)
-#define SM5502_REG_INTM2_MHL_MASK               (0x1 << SM5502_REG_INTM2_MHL_SHIFT)
-
-#define SM5502_REG_ADC_SHIFT                    0
-#define SM5502_REG_ADC_MASK                     (0x1f << SM5502_REG_ADC_SHIFT)
-
-#define SM5502_REG_TIMING_SET1_KEY_PRESS_SHIFT  4
-#define SM5502_REG_TIMING_SET1_KEY_PRESS_MASK   (0xf << SM5502_REG_TIMING_SET1_KEY_PRESS_SHIFT)
-#define TIMING_KEY_PRESS_100MS                  0x0
-#define TIMING_KEY_PRESS_200MS                  0x1
-#define TIMING_KEY_PRESS_300MS                  0x2
-#define TIMING_KEY_PRESS_400MS                  0x3
-#define TIMING_KEY_PRESS_500MS                  0x4
-#define TIMING_KEY_PRESS_600MS                  0x5
-#define TIMING_KEY_PRESS_700MS                  0x6
-#define TIMING_KEY_PRESS_800MS                  0x7
-#define TIMING_KEY_PRESS_900MS                  0x8
-#define TIMING_KEY_PRESS_1000MS                 0x9
-#define SM5502_REG_TIMING_SET1_ADC_DET_SHIFT    0
-#define SM5502_REG_TIMING_SET1_ADC_DET_MASK     (0xf << SM5502_REG_TIMING_SET1_ADC_DET_SHIFT)
-#define TIMING_ADC_DET_50MS                     0x0
-#define TIMING_ADC_DET_100MS                    0x1
-#define TIMING_ADC_DET_150MS                    0x2
-#define TIMING_ADC_DET_200MS                    0x3
-#define TIMING_ADC_DET_300MS                    0x4
-#define TIMING_ADC_DET_400MS                    0x5
-#define TIMING_ADC_DET_500MS                    0x6
-#define TIMING_ADC_DET_600MS                    0x7
-#define TIMING_ADC_DET_700MS                    0x8
-#define TIMING_ADC_DET_800MS                    0x9
-#define TIMING_ADC_DET_900MS                    0xA
-#define TIMING_ADC_DET_1000MS                   0xB
-
-#define SM5502_REG_TIMING_SET2_SW_WAIT_SHIFT    4
-#define SM5502_REG_TIMING_SET2_SW_WAIT_MASK     (0xf << SM5502_REG_TIMING_SET2_SW_WAIT_SHIFT)
-#define TIMING_SW_WAIT_10MS                     0x0
-#define TIMING_SW_WAIT_30MS                     0x1
-#define TIMING_SW_WAIT_50MS                     0x2
-#define TIMING_SW_WAIT_70MS                     0x3
-#define TIMING_SW_WAIT_90MS                     0x4
-#define TIMING_SW_WAIT_110MS                    0x5
-#define TIMING_SW_WAIT_130MS                    0x6
-#define TIMING_SW_WAIT_150MS                    0x7
-#define TIMING_SW_WAIT_170MS                    0x8
-#define TIMING_SW_WAIT_190MS                    0x9
-#define TIMING_SW_WAIT_210MS                    0xA
-#define SM5502_REG_TIMING_SET2_LONG_KEY_SHIFT   0
-#define SM5502_REG_TIMING_SET2_LONG_KEY_MASK    (0xf << SM5502_REG_TIMING_SET2_LONG_KEY_SHIFT)
-#define TIMING_LONG_KEY_300MS                   0x0
-#define TIMING_LONG_KEY_400MS                   0x1
-#define TIMING_LONG_KEY_500MS                   0x2
-#define TIMING_LONG_KEY_600MS                   0x3
-#define TIMING_LONG_KEY_700MS                   0x4
-#define TIMING_LONG_KEY_800MS                   0x5
-#define TIMING_LONG_KEY_900MS                   0x6
-#define TIMING_LONG_KEY_1000MS                  0x7
-#define TIMING_LONG_KEY_1100MS                  0x8
-#define TIMING_LONG_KEY_1200MS                  0x9
-#define TIMING_LONG_KEY_1300MS                  0xA
-#define TIMING_LONG_KEY_1400MS                  0xB
-#define TIMING_LONG_KEY_1500MS                  0xC
-
-#define SM5502_REG_DEV_TYPE1_AUDIO_TYPE1_SHIFT          0
-#define SM5502_REG_DEV_TYPE1_AUDIO_TYPE2_SHIFT          1
-#define SM5502_REG_DEV_TYPE1_USB_SDP_SHIFT              2
-#define SM5502_REG_DEV_TYPE1_UART_SHIFT                 3
-#define SM5502_REG_DEV_TYPE1_CAR_KIT_CHARGER_SHIFT      4
-#define SM5502_REG_DEV_TYPE1_USB_CHG_SHIFT              5
-#define SM5502_REG_DEV_TYPE1_DEDICATED_CHG_SHIFT        6
-#define SM5502_REG_DEV_TYPE1_USB_OTG_SHIFT              7
-#define SM5502_REG_DEV_TYPE1_AUDIO_TYPE1_MASK           (0x1 << SM5502_REG_DEV_TYPE1_AUDIO_TYPE1_SHIFT)
-#define SM5502_REG_DEV_TYPE1_AUDIO_TYPE1__MASK          (0x1 << SM5502_REG_DEV_TYPE1_AUDIO_TYPE2_SHIFT)
-#define SM5502_REG_DEV_TYPE1_USB_SDP_MASK               (0x1 << SM5502_REG_DEV_TYPE1_USB_SDP_SHIFT)
-#define SM5502_REG_DEV_TYPE1_UART_MASK                  (0x1 << SM5502_REG_DEV_TYPE1_UART_SHIFT)
-#define SM5502_REG_DEV_TYPE1_CAR_KIT_CHARGER_MASK       (0x1 << SM5502_REG_DEV_TYPE1_CAR_KIT_CHARGER_SHIFT)
-#define SM5502_REG_DEV_TYPE1_USB_CHG_MASK               (0x1 << SM5502_REG_DEV_TYPE1_USB_CHG_SHIFT)
-#define SM5502_REG_DEV_TYPE1_DEDICATED_CHG_MASK         (0x1 << SM5502_REG_DEV_TYPE1_DEDICATED_CHG_SHIFT)
-#define SM5502_REG_DEV_TYPE1_USB_OTG_MASK               (0x1 << SM5502_REG_DEV_TYPE1_USB_OTG_SHIFT)
-
-#define SM5502_REG_DEV_TYPE2_JIG_USB_ON_SHIFT           0
-#define SM5502_REG_DEV_TYPE2_JIG_USB_OFF_SHIFT          1
-#define SM5502_REG_DEV_TYPE2_JIG_UART_ON_SHIFT          2
-#define SM5502_REG_DEV_TYPE2_JIG_UART_OFF_SHIFT         3
-#define SM5502_REG_DEV_TYPE2_PPD_SHIFT                  4
-#define SM5502_REG_DEV_TYPE2_TTY_SHIFT                  5
-#define SM5502_REG_DEV_TYPE2_AV_CABLE_SHIFT             6
-#define SM5502_REG_DEV_TYPE2_JIG_USB_ON_MASK            (0x1 << SM5502_REG_DEV_TYPE2_JIG_USB_ON_SHIFT)
-#define SM5502_REG_DEV_TYPE2_JIG_USB_OFF_MASK           (0x1 << SM5502_REG_DEV_TYPE2_JIG_USB_OFF_SHIFT)
-#define SM5502_REG_DEV_TYPE2_JIG_UART_ON_MASK           (0x1 << SM5502_REG_DEV_TYPE2_JIG_UART_ON_SHIFT)
-#define SM5502_REG_DEV_TYPE2_JIG_UART_OFF_MASK          (0x1 << SM5502_REG_DEV_TYPE2_JIG_UART_OFF_SHIFT)
-#define SM5502_REG_DEV_TYPE2_PPD_MASK                   (0x1 << SM5502_REG_DEV_TYPE2_PPD_SHIFT)
-#define SM5502_REG_DEV_TYPE2_TTY_MASK                   (0x1 << SM5502_REG_DEV_TYPE2_TTY_SHIFT)
-#define SM5502_REG_DEV_TYPE2_AV_CABLE_MASK              (0x1 << SM5502_REG_DEV_TYPE2_AV_CABLE_SHIFT)
-
-#define SM5502_REG_MANUAL_SW1_VBUSIN_SHIFT      0
-#define SM5502_REG_MANUAL_SW1_DP_SHIFT          2
-#define SM5502_REG_MANUAL_SW1_DM_SHIFT          5
-#define SM5502_REG_MANUAL_SW1_VBUSIN_MASK       (0x3 << SM5502_REG_MANUAL_SW1_VBUSIN_SHIFT)
-#define SM5502_REG_MANUAL_SW1_DP_MASK           (0x7 << SM5502_REG_MANUAL_SW1_DP_SHIFT)
-#define SM5502_REG_MANUAL_SW1_DM_MASK           (0x7 << SM5502_REG_MANUAL_SW1_DM_SHIFT)
-#define VBUSIN_SWITCH_OPEN                      0x0
-#define VBUSIN_SWITCH_VBUSOUT                   0x1
-#define VBUSIN_SWITCH_MIC                       0x2
-#define VBUSIN_SWITCH_VBUSOUT_WITH_USB          0x3
-#define DM_DP_CON_SWITCH_OPEN                   0x0
-#define DM_DP_CON_SWITCH_USB                    0x1
-#define DM_DP_CON_SWITCH_AUDIO                  0x2
-#define DM_DP_CON_SWITCH_UART                   0x3
-#define DM_DP_SWITCH_OPEN                       ((DM_DP_CON_SWITCH_OPEN <<SM5502_REG_MANUAL_SW1_DP_SHIFT) \
-                                                | (DM_DP_CON_SWITCH_OPEN <<SM5502_REG_MANUAL_SW1_DM_SHIFT))
-#define DM_DP_SWITCH_USB                        ((DM_DP_CON_SWITCH_USB <<SM5502_REG_MANUAL_SW1_DP_SHIFT) \
-                                                | (DM_DP_CON_SWITCH_USB <<SM5502_REG_MANUAL_SW1_DM_SHIFT))
-#define DM_DP_SWITCH_AUDIO                      ((DM_DP_CON_SWITCH_AUDIO <<SM5502_REG_MANUAL_SW1_DP_SHIFT) \
-                                                | (DM_DP_CON_SWITCH_AUDIO <<SM5502_REG_MANUAL_SW1_DM_SHIFT))
-#define DM_DP_SWITCH_UART                       ((DM_DP_CON_SWITCH_UART <<SM5502_REG_MANUAL_SW1_DP_SHIFT) \
-                                                | (DM_DP_CON_SWITCH_UART <<SM5502_REG_MANUAL_SW1_DM_SHIFT))
-
-/* SM5502 Interrupts */
-enum sm5502_irq {
-        /* INT1 */
-        SM5502_IRQ_INT1_ATTACH,
-        SM5502_IRQ_INT1_DETACH,
-        SM5502_IRQ_INT1_KP,
-        SM5502_IRQ_INT1_LKP,
-        SM5502_IRQ_INT1_LKR,
-        SM5502_IRQ_INT1_OVP_EVENT,
-        SM5502_IRQ_INT1_OCP_EVENT,
-        SM5502_IRQ_INT1_OVP_OCP_DIS,
-
-        /* INT2 */
-        SM5502_IRQ_INT2_VBUS_DET,
-        SM5502_IRQ_INT2_REV_ACCE,
-        SM5502_IRQ_INT2_ADC_CHG,
-        SM5502_IRQ_INT2_STUCK_KEY,
-        SM5502_IRQ_INT2_STUCK_KEY_RCV,
-        SM5502_IRQ_INT2_MHL,
-
-        SM5502_IRQ_NUM,
-};
-
-#define SM5502_IRQ_INT1_ATTACH_MASK             BIT(0)
-#define SM5502_IRQ_INT1_DETACH_MASK             BIT(1)
-#define SM5502_IRQ_INT1_KP_MASK                 BIT(2)
-#define SM5502_IRQ_INT1_LKP_MASK                BIT(3)
-#define SM5502_IRQ_INT1_LKR_MASK                BIT(4)
-#define SM5502_IRQ_INT1_OVP_EVENT_MASK          BIT(5)
-#define SM5502_IRQ_INT1_OCP_EVENT_MASK          BIT(6)
-#define SM5502_IRQ_INT1_OVP_OCP_DIS_MASK        BIT(7)
-#define SM5502_IRQ_INT2_VBUS_DET_MASK           BIT(0)
-#define SM5502_IRQ_INT2_REV_ACCE_MASK           BIT(1)
-#define SM5502_IRQ_INT2_ADC_CHG_MASK            BIT(2)
-#define SM5502_IRQ_INT2_STUCK_KEY_MASK          BIT(3)
-#define SM5502_IRQ_INT2_STUCK_KEY_RCV_MASK      BIT(4)
-#define SM5502_IRQ_INT2_MHL_MASK                BIT(5)
-
-#endif /*  __LINUX_EXTCON_SM5502_H */
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 08ed2b0a96e6..87f14e90e984 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -15,8 +15,9 @@
 #include <linux/types.h>
 
 #define F2FS_SUPER_OFFSET               1024    /* byte-size offset */
-#define F2FS_LOG_SECTOR_SIZE            9       /* 9 bits for 512 byte */
-#define F2FS_LOG_SECTORS_PER_BLOCK      3       /* 4KB: F2FS_BLKSIZE */
+#define F2FS_MIN_LOG_SECTOR_SIZE        9       /* 9 bits for 512 bytes */
+#define F2FS_MAX_LOG_SECTOR_SIZE        12      /* 12 bits for 4096 bytes */
+#define F2FS_LOG_SECTORS_PER_BLOCK      3       /* log number for sector/blk */
 #define F2FS_BLKSIZE                    4096    /* support only 4KB block */
 #define F2FS_MAX_EXTENSION              64      /* # of extension entries */
 #define F2FS_BLK_ALIGN(x)       (((x) + F2FS_BLKSIZE - 1) / F2FS_BLKSIZE)
@@ -32,7 +33,8 @@
 #define F2FS_META_INO(sbi)      (sbi->meta_ino_num)
 
 /* This flag is used by node and meta inodes, and by recovery */
-#define GFP_F2FS_ZERO   (GFP_NOFS | __GFP_ZERO)
+#define GFP_F2FS_ZERO           (GFP_NOFS | __GFP_ZERO)
+#define GFP_F2FS_HIGH_ZERO      (GFP_NOFS | __GFP_ZERO | __GFP_HIGHMEM)
 
 /*
  * For further optimization on multi-head logs, on-disk layout supports maximum
@@ -85,6 +87,7 @@ struct f2fs_super_block {
 /*
  * For checkpoint
  */
+#define CP_FSCK_FLAG            0x00000010
 #define CP_ERROR_FLAG           0x00000008
 #define CP_COMPACT_SUM_FLAG     0x00000004
 #define CP_ORPHAN_PRESENT_FLAG  0x00000002
@@ -168,14 +171,12 @@ struct f2fs_extent {
 
 #define F2FS_INLINE_XATTR       0x01    /* file inline xattr flag */
 #define F2FS_INLINE_DATA        0x02    /* file inline data flag */
+#define F2FS_INLINE_DENTRY      0x04    /* file inline dentry flag */
+#define F2FS_DATA_EXIST         0x08    /* file inline data exist flag */
 
 #define MAX_INLINE_DATA         (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \
                                                 F2FS_INLINE_XATTR_ADDRS - 1))
 
-#define INLINE_DATA_OFFSET      (PAGE_CACHE_SIZE - sizeof(struct node_footer) -\
-                                sizeof(__le32) * (DEF_ADDRS_PER_INODE + \
-                                DEF_NIDS_PER_INODE - 1))
-
 struct f2fs_inode {
         __le16 i_mode;                  /* file mode */
         __u8 i_advise;                  /* file hints */
@@ -433,6 +434,24 @@ struct f2fs_dentry_block {
         __u8 filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
 } __packed;
 
+/* for inline dir */
+#define NR_INLINE_DENTRY        (MAX_INLINE_DATA * BITS_PER_BYTE / \
+                                ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
+                                BITS_PER_BYTE + 1))
+#define INLINE_DENTRY_BITMAP_SIZE       ((NR_INLINE_DENTRY + \
+                                        BITS_PER_BYTE - 1) / BITS_PER_BYTE)
+#define INLINE_RESERVED_SIZE    (MAX_INLINE_DATA - \
+                                ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
+                                NR_INLINE_DENTRY + INLINE_DENTRY_BITMAP_SIZE))
+
+/* inline directory entry structure */
+struct f2fs_inline_dentry {
+        __u8 dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
+        __u8 reserved[INLINE_RESERVED_SIZE];
+        struct f2fs_dir_entry dentry[NR_INLINE_DENTRY];
+        __u8 filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
+} __packed;
+
 /* file types used in inode_info->flags */
 enum {
         F2FS_FT_UNKNOWN,
diff --git a/include/linux/fault-inject.h b/include/linux/fault-inject.h
index c6f996f2abb6..798fad9e420d 100644
--- a/include/linux/fault-inject.h
+++ b/include/linux/fault-inject.h
@@ -5,6 +5,7 @@
 
 #include <linux/types.h>
 #include <linux/debugfs.h>
+#include <linux/ratelimit.h>
 #include <linux/atomic.h>
 
 /*
@@ -25,14 +26,18 @@ struct fault_attr {
         unsigned long reject_end;
 
         unsigned long count;
+        struct ratelimit_state ratelimit_state;
+        struct dentry *dname;
 };
 
-#define FAULT_ATTR_INITIALIZER {                                \
-                .interval = 1,                                  \
-                .times = ATOMIC_INIT(1),                        \
-                .require_end = ULONG_MAX,                       \
-                .stacktrace_depth = 32,                         \
-                .verbose = 2,                                   \
+#define FAULT_ATTR_INITIALIZER {                                        \
+                .interval = 1,                                          \
+                .times = ATOMIC_INIT(1),                                \
+                .require_end = ULONG_MAX,                               \
+                .stacktrace_depth = 32,                                 \
+                .ratelimit_state = RATELIMIT_STATE_INIT_DISABLED,       \
+                .verbose = 2,                                           \
+                .dname = NULL,                                          \
         }
 
 #define DECLARE_FAULT_ATTR(name) struct fault_attr name = FAULT_ATTR_INITIALIZER
diff --git a/include/linux/fence.h b/include/linux/fence.h
index d174585b874b..39efee130d2b 100644
--- a/include/linux/fence.h
+++ b/include/linux/fence.h
@@ -128,8 +128,8 @@ struct fence_cb {
  * from irq context, so normal spinlocks can be used.
  *
  * A return value of false indicates the fence already passed,
- * or some failure occured that made it impossible to enable
- * signaling. True indicates succesful enabling.
+ * or some failure occurred that made it impossible to enable
+ * signaling. True indicates successful enabling.
  *
  * fence->status may be set in enable_signaling, but only when false is
  * returned.
diff --git a/include/linux/file.h b/include/linux/file.h
index 4d69123377a2..f87d30882a24 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -66,7 +66,6 @@ extern void set_close_on_exec(unsigned int fd, int flag);
 extern bool get_close_on_exec(unsigned int fd);
 extern void put_filp(struct file *);
 extern int get_unused_fd_flags(unsigned flags);
-#define get_unused_fd() get_unused_fd_flags(0)
 extern void put_unused_fd(unsigned int fd);
 
 extern void fd_install(unsigned int fd, struct file *file);
diff --git a/include/linux/filter.h b/include/linux/filter.h
index a5227ab8ccb1..caac2087a4d5 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -4,58 +4,24 @@
 #ifndef __LINUX_FILTER_H__
 #define __LINUX_FILTER_H__
 
+#include <stdarg.h>
+
 #include <linux/atomic.h>
 #include <linux/compat.h>
 #include <linux/skbuff.h>
+#include <linux/linkage.h>
+#include <linux/printk.h>
 #include <linux/workqueue.h>
-#include <uapi/linux/filter.h>
 
-/* Internally used and optimized filter representation with extended
- * instruction set based on top of classic BPF.
- */
+#include <asm/cacheflush.h>
 
-/* instruction classes */
-#define BPF_ALU64       0x07    /* alu mode in double word width */
-
-/* ld/ldx fields */
-#define BPF_DW          0x18    /* double word */
-#define BPF_XADD        0xc0    /* exclusive add */
-
-/* alu/jmp fields */
-#define BPF_MOV         0xb0    /* mov reg to reg */
-#define BPF_ARSH        0xc0    /* sign extending arithmetic shift right */
-
-/* change endianness of a register */
-#define BPF_END         0xd0    /* flags for endianness conversion: */
-#define BPF_TO_LE       0x00    /* convert to little-endian */
-#define BPF_TO_BE       0x08    /* convert to big-endian */
-#define BPF_FROM_LE     BPF_TO_LE
-#define BPF_FROM_BE     BPF_TO_BE
-
-#define BPF_JNE         0x50    /* jump != */
-#define BPF_JSGT        0x60    /* SGT is signed '>', GT in x86 */
-#define BPF_JSGE        0x70    /* SGE is signed '>=', GE in x86 */
-#define BPF_CALL        0x80    /* function call */
-#define BPF_EXIT        0x90    /* function return */
-
-/* Register numbers */
-enum {
-        BPF_REG_0 = 0,
-        BPF_REG_1,
-        BPF_REG_2,
-        BPF_REG_3,
-        BPF_REG_4,
-        BPF_REG_5,
-        BPF_REG_6,
-        BPF_REG_7,
-        BPF_REG_8,
-        BPF_REG_9,
-        BPF_REG_10,
-        __MAX_BPF_REG,
-};
+#include <uapi/linux/filter.h>
+#include <uapi/linux/bpf.h>
 
-/* BPF has 10 general purpose 64-bit registers and stack frame. */
-#define MAX_BPF_REG     __MAX_BPF_REG
+struct sk_buff;
+struct sock;
+struct seccomp_data;
+struct bpf_prog_aux;
 
 /* ArgX, context and stack frame pointer register positions. Note,
  * Arg1, Arg2, Arg3, etc are used as argument mappings of function
@@ -161,6 +127,30 @@ enum {
                 .off   = 0,                                     \
                 .imm   = IMM })
 
+/* BPF_LD_IMM64 macro encodes single 'load 64-bit immediate' insn */
+#define BPF_LD_IMM64(DST, IMM)                                  \
+        BPF_LD_IMM64_RAW(DST, 0, IMM)
+
+#define BPF_LD_IMM64_RAW(DST, SRC, IMM)                         \
+        ((struct bpf_insn) {                                    \
+                .code  = BPF_LD | BPF_DW | BPF_IMM,             \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = (__u32) (IMM) }),                      \
+        ((struct bpf_insn) {                                    \
+                .code  = 0, /* zero is reserved opcode */       \
+                .dst_reg = 0,                                   \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = ((__u64) (IMM)) >> 32 })
+
+#define BPF_PSEUDO_MAP_FD       1
+
+/* pseudo BPF_LD_IMM64 insn used to refer to process-local map_fd */
+#define BPF_LD_MAP_FD(DST, MAP_FD)                              \
+        BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)
+
 /* Short form of mov based on type, BPF_X: dst_reg = src_reg, BPF_K: dst_reg = imm32 */
 
 #define BPF_MOV64_RAW(TYPE, DST, SRC, IMM)                      \
@@ -299,14 +289,6 @@ enum {
 #define SK_RUN_FILTER(filter, ctx) \
         (*filter->prog->bpf_func)(ctx, filter->prog->insnsi)
 
-struct bpf_insn {
-        __u8    code;           /* opcode */
-        __u8    dst_reg:4;      /* dest register */
-        __u8    src_reg:4;      /* source register */
-        __s16   off;            /* signed offset */
-        __s32   imm;            /* signed immediate constant */
-};
-
 #ifdef CONFIG_COMPAT
 /* A struct sock_filter is architecture independent. */
 struct compat_sock_fprog {
@@ -320,20 +302,23 @@ struct sock_fprog_kern {
         struct sock_filter      *filter;
 };
 
-struct sk_buff;
-struct sock;
-struct seccomp_data;
+struct bpf_binary_header {
+        unsigned int pages;
+        u8 image[];
+};
 
 struct bpf_prog {
-        u32                     jited:1,        /* Is our filter JIT'ed? */
-                                len:31;         /* Number of filter blocks */
+        u16                     pages;          /* Number of allocated pages */
+        bool                    jited;          /* Is our filter JIT'ed? */
+        u32                     len;            /* Number of filter blocks */
         struct sock_fprog_kern  *orig_prog;     /* Original BPF program */
+        struct bpf_prog_aux     *aux;           /* Auxiliary fields */
         unsigned int            (*bpf_func)(const struct sk_buff *skb,
                                             const struct bpf_insn *filter);
+        /* Instructions for interpreter */
         union {
                 struct sock_filter      insns[0];
                 struct bpf_insn         insnsi[0];
-                struct work_struct      work;
         };
 };
 
@@ -353,6 +338,26 @@ static inline unsigned int bpf_prog_size(unsigned int proglen)
 
 #define bpf_classic_proglen(fprog) (fprog->len * sizeof(fprog->filter[0]))
 
+#ifdef CONFIG_DEBUG_SET_MODULE_RONX
+static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
+{
+        set_memory_ro((unsigned long)fp, fp->pages);
+}
+
+static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
+{
+        set_memory_rw((unsigned long)fp, fp->pages);
+}
+#else
+static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
+{
+}
+
+static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
+{
+}
+#endif /* CONFIG_DEBUG_SET_MODULE_RONX */
+
 int sk_filter(struct sock *sk, struct sk_buff *skb);
 
 void bpf_prog_select_runtime(struct bpf_prog *fp);
@@ -361,10 +366,22 @@ void bpf_prog_free(struct bpf_prog *fp);
 int bpf_convert_filter(struct sock_filter *prog, int len,
                        struct bpf_insn *new_prog, int *new_len);
 
+struct bpf_prog *bpf_prog_alloc(unsigned int size, gfp_t gfp_extra_flags);
+struct bpf_prog *bpf_prog_realloc(struct bpf_prog *fp_old, unsigned int size,
+                                  gfp_t gfp_extra_flags);
+void __bpf_prog_free(struct bpf_prog *fp);
+
+static inline void bpf_prog_unlock_free(struct bpf_prog *fp)
+{
+        bpf_prog_unlock_ro(fp);
+        __bpf_prog_free(fp);
+}
+
 int bpf_prog_create(struct bpf_prog **pfp, struct sock_fprog_kern *fprog);
 void bpf_prog_destroy(struct bpf_prog *fp);
 
 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
+int sk_attach_bpf(u32 ufd, struct sock *sk);
 int sk_detach_filter(struct sock *sk);
 
 int bpf_check_classic(const struct sock_filter *filter, unsigned int flen);
@@ -377,6 +394,38 @@ void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp);
 u64 __bpf_call_base(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
 void bpf_int_jit_compile(struct bpf_prog *fp);
 
+#ifdef CONFIG_BPF_JIT
+typedef void (*bpf_jit_fill_hole_t)(void *area, unsigned int size);
+
+struct bpf_binary_header *
+bpf_jit_binary_alloc(unsigned int proglen, u8 **image_ptr,
+                     unsigned int alignment,
+                     bpf_jit_fill_hole_t bpf_fill_ill_insns);
+void bpf_jit_binary_free(struct bpf_binary_header *hdr);
+
+void bpf_jit_compile(struct bpf_prog *fp);
+void bpf_jit_free(struct bpf_prog *fp);
+
+static inline void bpf_jit_dump(unsigned int flen, unsigned int proglen,
+                                u32 pass, void *image)
+{
+        pr_err("flen=%u proglen=%u pass=%u image=%pK\n",
+               flen, proglen, pass, image);
+        if (image)
+                print_hex_dump(KERN_ERR, "JIT code: ", DUMP_PREFIX_OFFSET,
+                               16, 1, image, proglen, false);
+}
+#else
+static inline void bpf_jit_compile(struct bpf_prog *fp)
+{
+}
+
+static inline void bpf_jit_free(struct bpf_prog *fp)
+{
+        bpf_prog_unlock_free(fp);
+}
+#endif /* CONFIG_BPF_JIT */
+
 #define BPF_ANC         BIT(15)
 
 static inline u16 bpf_anc_helper(const struct sock_filter *ftest)
@@ -424,36 +473,6 @@ static inline void *bpf_load_pointer(const struct sk_buff *skb, int k,
         return bpf_internal_load_pointer_neg_helper(skb, k, size);
 }
 
-#ifdef CONFIG_BPF_JIT
-#include <stdarg.h>
-#include <linux/linkage.h>
-#include <linux/printk.h>
-
-void bpf_jit_compile(struct bpf_prog *fp);
-void bpf_jit_free(struct bpf_prog *fp);
-
-static inline void bpf_jit_dump(unsigned int flen, unsigned int proglen,
-                                u32 pass, void *image)
-{
-        pr_err("flen=%u proglen=%u pass=%u image=%pK\n",
-               flen, proglen, pass, image);
-        if (image)
-                print_hex_dump(KERN_ERR, "JIT code: ", DUMP_PREFIX_OFFSET,
-                               16, 1, image, proglen, false);
-}
-#else
-#include <linux/slab.h>
-
-static inline void bpf_jit_compile(struct bpf_prog *fp)
-{
-}
-
-static inline void bpf_jit_free(struct bpf_prog *fp)
-{
-        kfree(fp);
-}
-#endif /* CONFIG_BPF_JIT */
-
 static inline int bpf_tell_extensions(void)
 {
         return SKF_AD_MAX;
diff --git a/include/linux/flex_proportions.h b/include/linux/flex_proportions.h
index 4ebc49fae391..0d348e011a6e 100644
--- a/include/linux/flex_proportions.h
+++ b/include/linux/flex_proportions.h
@@ -10,6 +10,7 @@
 #include <linux/percpu_counter.h>
 #include <linux/spinlock.h>
 #include <linux/seqlock.h>
+#include <linux/gfp.h>
 
 /*
  * When maximum proportion of some event type is specified, this is the
@@ -32,7 +33,7 @@ struct fprop_global {
         seqcount_t sequence;
 };
 
-int fprop_global_init(struct fprop_global *p);
+int fprop_global_init(struct fprop_global *p, gfp_t gfp);
 void fprop_global_destroy(struct fprop_global *p);
 bool fprop_new_period(struct fprop_global *p, int periods);
 
@@ -79,7 +80,7 @@ struct fprop_local_percpu {
         raw_spinlock_t lock;    /* Protect period and numerator */
 };
 
-int fprop_local_init_percpu(struct fprop_local_percpu *pl);
+int fprop_local_init_percpu(struct fprop_local_percpu *pl, gfp_t gfp);
 void fprop_local_destroy_percpu(struct fprop_local_percpu *pl);
 void __fprop_inc_percpu(struct fprop_global *p, struct fprop_local_percpu *pl);
 void __fprop_inc_percpu_max(struct fprop_global *p, struct fprop_local_percpu *pl,
diff --git a/include/linux/font.h b/include/linux/font.h
index 40a24ab41b36..d6821769dd1e 100644
--- a/include/linux/font.h
+++ b/include/linux/font.h
@@ -31,6 +31,7 @@ struct font_desc {
 #define SUN12x22_IDX    7
 #define ACORN8x8_IDX    8
 #define MINI4x6_IDX     9
+#define FONT6x10_IDX    10
 
 extern const struct font_desc   font_vga_8x8,
                         font_vga_8x16,
@@ -41,7 +42,8 @@ extern const struct font_desc	font_vga_8x8,
                         font_sun_8x16,
                         font_sun_12x22,
                         font_acorn_8x8,
-                        font_mini_4x6;
+                        font_mini_4x6,
+                        font_6x10;
 
 /* Find a font with a specific name */
 
diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index 7fd81b8c4897..6b7fd9cf5ea2 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -246,15 +246,6 @@ static inline int freezable_schedule_hrtimeout_range(ktime_t *expires,
  * defined in <linux/wait.h>
  */
 
-#define wait_event_freezekillable(wq, condition)                        \
-({                                                                      \
-        int __retval;                                                   \
-        freezer_do_not_count();                                         \
-        __retval = wait_event_killable(wq, (condition));                \
-        freezer_count();                                                \
-        __retval;                                                       \
-})
-
 /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */
 #define wait_event_freezekillable_unsafe(wq, condition)                 \
 ({                                                                      \
@@ -265,35 +256,6 @@ static inline int freezable_schedule_hrtimeout_range(ktime_t *expires,
         __retval;                                                       \
 })
 
-#define wait_event_freezable(wq, condition)                             \
-({                                                                      \
-        int __retval;                                                   \
-        freezer_do_not_count();                                         \
-        __retval = wait_event_interruptible(wq, (condition));           \
-        freezer_count();                                                \
-        __retval;                                                       \
-})
-
-#define wait_event_freezable_timeout(wq, condition, timeout)            \
-({                                                                      \
-        long __retval = timeout;                                        \
-        freezer_do_not_count();                                         \
-        __retval = wait_event_interruptible_timeout(wq, (condition),    \
-                                __retval);                              \
-        freezer_count();                                                \
-        __retval;                                                       \
-})
-
-#define wait_event_freezable_exclusive(wq, condition)                   \
-({                                                                      \
-        int __retval;                                                   \
-        freezer_do_not_count();                                         \
-        __retval = wait_event_interruptible_exclusive(wq, condition);   \
-        freezer_count();                                                \
-        __retval;                                                       \
-})
-
-
 #else /* !CONFIG_FREEZER */
 static inline bool frozen(struct task_struct *p) { return false; }
 static inline bool freezing(struct task_struct *p) { return false; }
@@ -331,18 +293,6 @@ static inline void set_freezable(void) {}
 #define freezable_schedule_hrtimeout_range(expires, delta, mode)        \
         schedule_hrtimeout_range(expires, delta, mode)
 
-#define wait_event_freezable(wq, condition)                             \
-                wait_event_interruptible(wq, condition)
-
-#define wait_event_freezable_timeout(wq, condition, timeout)            \
-                wait_event_interruptible_timeout(wq, condition, timeout)
-
-#define wait_event_freezable_exclusive(wq, condition)                   \
-                wait_event_interruptible_exclusive(wq, condition)
-
-#define wait_event_freezekillable(wq, condition)                \
-                wait_event_killable(wq, condition)
-
 #define wait_event_freezekillable_unsafe(wq, condition)                 \
                 wait_event_killable(wq, condition)
 
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 94187721ad41..42efe13077b6 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -18,6 +18,7 @@
 #include <linux/pid.h>
 #include <linux/bug.h>
 #include <linux/mutex.h>
+#include <linux/rwsem.h>
 #include <linux/capability.h>
 #include <linux/semaphore.h>
 #include <linux/fiemap.h>
@@ -134,7 +135,7 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define FMODE_CAN_WRITE         ((__force fmode_t)0x40000)
 
 /* File was opened by fanotify and shouldn't generate fanotify events */
-#define FMODE_NONOTIFY          ((__force fmode_t)0x1000000)
+#define FMODE_NONOTIFY          ((__force fmode_t)0x4000000)
 
 /*
  * Flag for rw_copy_check_uvector and compat_rw_copy_check_uvector
@@ -192,8 +193,6 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define READ                    0
 #define WRITE                   RW_MASK
 #define READA                   RWA_MASK
-#define KERNEL_READ             (READ|REQ_KERNEL)
-#define KERNEL_WRITE            (WRITE|REQ_KERNEL)
 
 #define READ_SYNC               (READ | REQ_SYNC)
 #define WRITE_SYNC              (WRITE | REQ_SYNC | REQ_NOIDLE)
@@ -225,6 +224,13 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define ATTR_TIMES_SET  (1 << 16)
 
 /*
+ * Whiteout is represented by a char device.  The following constants define the
+ * mode and device number to use.
+ */
+#define WHITEOUT_MODE 0
+#define WHITEOUT_DEV 0
+
+/*
  * This is the Inode Attributes structure, used for notify_change().  It
  * uses the above definitions as flags, to know which values have changed.
  * Also, in this manner, a Filesystem can look at only the values it cares
@@ -256,6 +262,12 @@ struct iattr {
  */
 #include <linux/quota.h>
 
+/*
+ * Maximum number of layers of fs stack.  Needs to be limited to
+ * prevent kernel stack overflow
+ */
+#define FILESYSTEM_MAX_STACK_DEPTH 2
+
 /** 
  * enum positive_aop_returns - aop return codes with specific semantics
  *
@@ -390,7 +402,7 @@ struct address_space {
         atomic_t                i_mmap_writable;/* count VM_SHARED mappings */
         struct rb_root          i_mmap;         /* tree of private and shared mappings */
         struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
-        struct mutex            i_mmap_mutex;   /* protect tree, count, list */
+        struct rw_semaphore     i_mmap_rwsem;   /* protect tree, count, list */
         /* Protected by tree_lock together with the radix tree */
         unsigned long           nrpages;        /* number of total pages */
         unsigned long           nrshadows;      /* number of shadow entries */
@@ -456,6 +468,26 @@ struct block_device {
 
 int mapping_tagged(struct address_space *mapping, int tag);
 
+static inline void i_mmap_lock_write(struct address_space *mapping)
+{
+        down_write(&mapping->i_mmap_rwsem);
+}
+
+static inline void i_mmap_unlock_write(struct address_space *mapping)
+{
+        up_write(&mapping->i_mmap_rwsem);
+}
+
+static inline void i_mmap_lock_read(struct address_space *mapping)
+{
+        down_read(&mapping->i_mmap_rwsem);
+}
+
+static inline void i_mmap_unlock_read(struct address_space *mapping)
+{
+        up_read(&mapping->i_mmap_rwsem);
+}
+
 /*
  * Might pages of this file be mapped into userspace?
  */
@@ -595,9 +627,6 @@ struct inode {
         const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
         struct file_lock        *i_flock;
         struct address_space    i_data;
-#ifdef CONFIG_QUOTA
-        struct dquot            *i_dquot[MAXQUOTAS];
-#endif
         struct list_head        i_devices;
         union {
                 struct pipe_inode_info  *i_pipe;
@@ -628,11 +657,13 @@ static inline int inode_unhashed(struct inode *inode)
  * 2: child/target
  * 3: xattr
  * 4: second non-directory
- * The last is for certain operations (such as rename) which lock two
+ * 5: second parent (when locking independent directories in rename)
+ *
+ * I_MUTEX_NONDIR2 is for certain operations (such as rename) which lock two
  * non-directories at once.
  *
  * The locking order between these classes is
- * parent -> child -> normal -> xattr -> second non-directory
+ * parent[2] -> child -> grandchild -> normal -> xattr -> second non-directory
  */
 enum inode_i_mutex_lock_class
 {
@@ -640,7 +671,8 @@ enum inode_i_mutex_lock_class
         I_MUTEX_PARENT,
         I_MUTEX_CHILD,
         I_MUTEX_XATTR,
-        I_MUTEX_NONDIR2
+        I_MUTEX_NONDIR2,
+        I_MUTEX_PARENT2,
 };
 
 void lock_two_nondirectories(struct inode *, struct inode*);
@@ -775,7 +807,6 @@ struct file {
                 struct rcu_head         fu_rcuhead;
         } f_u;
         struct path             f_path;
-#define f_dentry        f_path.dentry
         struct inode            *f_inode;       /* cached value */
         const struct file_operations    *f_op;
 
@@ -851,13 +882,7 @@ static inline struct file *get_file(struct file *f)
  */
 #define FILE_LOCK_DEFERRED 1
 
-/*
- * The POSIX file lock owner is determined by
- * the "struct files_struct" in the thread group
- * (or NULL for no owner - BSD locks).
- *
- * Lockd stuffs a "host" pointer into this.
- */
+/* legacy typedef, should eventually be removed */
 typedef void *fl_owner_t;
 
 struct file_lock_operations {
@@ -868,10 +893,13 @@ struct file_lock_operations {
 struct lock_manager_operations {
         int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
         unsigned long (*lm_owner_key)(struct file_lock *);
+        void (*lm_get_owner)(struct file_lock *, struct file_lock *);
+        void (*lm_put_owner)(struct file_lock *);
         void (*lm_notify)(struct file_lock *);  /* unblock callback */
-        int (*lm_grant)(struct file_lock *, struct file_lock *, int);
-        void (*lm_break)(struct file_lock *);
-        int (*lm_change)(struct file_lock **, int);
+        int (*lm_grant)(struct file_lock *, int);
+        bool (*lm_break)(struct file_lock *);
+        int (*lm_change)(struct file_lock **, int, struct list_head *);
+        void (*lm_setup)(struct file_lock *, void **);
 };
 
 struct lock_manager {
@@ -966,7 +994,7 @@ void locks_free_lock(struct file_lock *fl);
 extern void locks_init_lock(struct file_lock *);
 extern struct file_lock * locks_alloc_lock(void);
 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
-extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
+extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_file(struct file *);
 extern void locks_release_private(struct file_lock *);
@@ -980,11 +1008,9 @@ extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
 extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
 extern void lease_get_mtime(struct inode *, struct timespec *time);
-extern int generic_setlease(struct file *, long, struct file_lock **);
-extern int vfs_setlease(struct file *, long, struct file_lock **);
-extern int lease_modify(struct file_lock **, int);
-extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
-extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
+extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
+extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
+extern int lease_modify(struct file_lock **, int, struct list_head *);
 #else /* !CONFIG_FILE_LOCKING */
 static inline int fcntl_getlk(struct file *file, unsigned int cmd,
                               struct flock __user *user)
@@ -1013,12 +1039,12 @@ static inline int fcntl_setlk64(unsigned int fd, struct file *file,
 #endif
 static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
 {
-        return 0;
+        return -EINVAL;
 }
 
 static inline int fcntl_getlease(struct file *filp)
 {
-        return 0;
+        return F_UNLCK;
 }
 
 static inline void locks_init_lock(struct file_lock *fl)
@@ -1026,7 +1052,7 @@ static inline void locks_init_lock(struct file_lock *fl)
         return;
 }
 
-static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
+static inline void locks_copy_conflock(struct file_lock *new, struct file_lock *fl)
 {
         return;
 }
@@ -1100,33 +1126,22 @@ static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
 }
 
 static inline int generic_setlease(struct file *filp, long arg,
-                                    struct file_lock **flp)
+                                    struct file_lock **flp, void **priv)
 {
         return -EINVAL;
 }
 
 static inline int vfs_setlease(struct file *filp, long arg,
-                               struct file_lock **lease)
+                               struct file_lock **lease, void **priv)
 {
         return -EINVAL;
 }
 
-static inline int lease_modify(struct file_lock **before, int arg)
+static inline int lease_modify(struct file_lock **before, int arg,
+                               struct list_head *dispose)
 {
         return -EINVAL;
 }
-
-static inline int lock_may_read(struct inode *inode, loff_t start,
-                                unsigned long len)
-{
-        return 1;
-}
-
-static inline int lock_may_write(struct inode *inode, loff_t start,
-                                 unsigned long len)
-{
-        return 1;
-}
 #endif /* !CONFIG_FILE_LOCKING */
 
 
@@ -1151,8 +1166,8 @@ extern void fasync_free(struct fasync_struct *);
 /* can be called from interrupts */
 extern void kill_fasync(struct fasync_struct **, int, int);
 
-extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
-extern int f_setown(struct file *filp, unsigned long arg, int force);
+extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
+extern void f_setown(struct file *filp, unsigned long arg, int force);
 extern void f_delown(struct file *filp);
 extern pid_t f_getown(struct file *filp);
 extern int send_sigurg(struct fown_struct *fown);
@@ -1226,6 +1241,7 @@ struct super_block {
         struct backing_dev_info *s_bdi;
         struct mtd_info         *s_mtd;
         struct hlist_node       s_instances;
+        unsigned int            s_quota_types;  /* Bitmask of supported quota types */
         struct quota_info       s_dquot;        /* Diskquota specific options */
 
         struct sb_writers       s_writers;
@@ -1284,6 +1300,11 @@ struct super_block {
         struct list_lru         s_dentry_lru ____cacheline_aligned_in_smp;
         struct list_lru         s_inode_lru ____cacheline_aligned_in_smp;
         struct rcu_head         rcu;
+
+        /*
+         * Indicates how deep in a filesystem stack this SB is
+         */
+        int s_stack_depth;
 };
 
 extern struct timespec current_fs_time(struct super_block *sb);
@@ -1416,6 +1437,7 @@ extern int vfs_link(struct dentry *, struct inode *, struct dentry *, struct ino
 extern int vfs_rmdir(struct inode *, struct dentry *);
 extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
+extern int vfs_whiteout(struct inode *, struct dentry *);
 
 /*
  * VFS dentry helper functions.
@@ -1463,7 +1485,10 @@ int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
  * This allows the kernel to read directories into kernel space or
  * to have different dirent layouts depending on the binary type.
  */
-typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
+struct dir_context;
+typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
+                         unsigned);
+
 struct dir_context {
         const filldir_t actor;
         loff_t pos;
@@ -1493,6 +1518,7 @@ struct file_operations {
         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
         int (*mmap) (struct file *, struct vm_area_struct *);
+        void (*mremap)(struct file *, struct vm_area_struct *);
         int (*open) (struct inode *, struct file *);
         int (*flush) (struct file *, fl_owner_t id);
         int (*release) (struct inode *, struct file *);
@@ -1506,10 +1532,10 @@ struct file_operations {
         int (*flock) (struct file *, int, struct file_lock *);
         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
         ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
-        int (*setlease)(struct file *, long, struct file_lock **);
+        int (*setlease)(struct file *, long, struct file_lock **, void **);
         long (*fallocate)(struct file *file, int mode, loff_t offset,
                           loff_t len);
-        int (*show_fdinfo)(struct seq_file *m, struct file *f);
+        void (*show_fdinfo)(struct seq_file *m, struct file *f);
 };
 
 struct inode_operations {
@@ -1546,6 +1572,9 @@ struct inode_operations {
                            umode_t create_mode, int *opened);
         int (*tmpfile) (struct inode *, struct dentry *, umode_t);
         int (*set_acl)(struct inode *, struct posix_acl *, int);
+
+        /* WARNING: probably going away soon, do not use! */
+        int (*dentry_open)(struct dentry *, struct file *, const struct cred *);
 } ____cacheline_aligned;
 
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
@@ -1553,6 +1582,7 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
                               struct iovec *fast_pointer,
                               struct iovec **ret_pointer);
 
+extern ssize_t __vfs_read(struct file *, char __user *, size_t, loff_t *);
 extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
 extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
 extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
@@ -1570,7 +1600,9 @@ struct super_operations {
         void (*evict_inode) (struct inode *);
         void (*put_super) (struct super_block *);
         int (*sync_fs)(struct super_block *sb, int wait);
+        int (*freeze_super) (struct super_block *);
         int (*freeze_fs) (struct super_block *);
+        int (*thaw_super) (struct super_block *);
         int (*unfreeze_fs) (struct super_block *);
         int (*statfs) (struct dentry *, struct kstatfs *);
         int (*remount_fs) (struct super_block *, int *, char *);
@@ -1583,6 +1615,7 @@ struct super_operations {
 #ifdef CONFIG_QUOTA
         ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
         ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
+        struct dquot **(*get_dquots)(struct inode *);
 #endif
         int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
         long (*nr_cached_objects)(struct super_block *, int);
@@ -1643,6 +1676,9 @@ struct super_operations {
 #define IS_AUTOMOUNT(inode)     ((inode)->i_flags & S_AUTOMOUNT)
 #define IS_NOSEC(inode)         ((inode)->i_flags & S_NOSEC)
 
+#define IS_WHITEOUT(inode)      (S_ISCHR(inode->i_mode) && \
+                                 (inode)->i_rdev == WHITEOUT_DEV)
+
 /*
  * Inode state bits.  Protected by inode->i_lock
  *
@@ -1855,7 +1891,8 @@ extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
 extern void kern_unmount(struct vfsmount *mnt);
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
-extern long do_mount(const char *, const char *, const char *, unsigned long, void *);
+extern long do_mount(const char *, const char __user *,
+                     const char *, unsigned long, void *);
 extern struct vfsmount *collect_mounts(struct path *);
 extern void drop_collected_mounts(struct vfsmount *);
 extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
@@ -1874,7 +1911,7 @@ extern int current_umask(void);
 extern void ihold(struct inode * inode);
 extern void iput(struct inode *);
 
-static inline struct inode *file_inode(struct file *f)
+static inline struct inode *file_inode(const struct file *f)
 {
         return f->f_inode;
 }
@@ -2049,7 +2086,7 @@ struct filename {
 extern long vfs_truncate(struct path *, loff_t);
 extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
                        struct file *filp);
-extern int do_fallocate(struct file *file, int mode, loff_t offset,
+extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
                         loff_t len);
 extern long do_sys_open(int dfd, const char __user *filename, int flags,
                         umode_t mode);
@@ -2057,9 +2094,11 @@ extern struct file *file_open_name(struct filename *, int, umode_t);
 extern struct file *filp_open(const char *, int, umode_t);
 extern struct file *file_open_root(struct dentry *, struct vfsmount *,
                                    const char *, int);
+extern int vfs_open(const struct path *, struct file *, const struct cred *);
 extern struct file * dentry_open(const struct path *, int, const struct cred *);
 extern int filp_close(struct file *, fl_owner_t id);
 
+extern struct filename *getname_flags(const char __user *, int, int *);
 extern struct filename *getname(const char __user *);
 extern struct filename *getname_kernel(const char *);
 
@@ -2137,7 +2176,6 @@ static inline int sb_is_blkdev_sb(struct super_block *sb)
 extern int sync_filesystem(struct super_block *);
 extern const struct file_operations def_blk_fops;
 extern const struct file_operations def_chr_fops;
-extern const struct file_operations bad_sock_fops;
 #ifdef CONFIG_BLOCK
 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
 extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
@@ -2270,7 +2308,9 @@ extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *, struct inode **);
 extern int inode_permission(struct inode *, int);
+extern int __inode_permission(struct inode *, int);
 extern int generic_permission(struct inode *, int);
+extern int __check_sticky(struct inode *dir, struct inode *inode);
 
 static inline bool execute_ok(struct inode *inode)
 {
@@ -2455,6 +2495,7 @@ extern ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, lo
 extern ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
 
 /* fs/block_dev.c */
+extern ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to);
 extern ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from);
 extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
                         int datasync);
@@ -2469,6 +2510,9 @@ extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
                 struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
                 struct file *out, loff_t *, size_t len, unsigned int flags);
+extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
+                loff_t *opos, size_t len, unsigned int flags);
+
 
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
@@ -2611,6 +2655,7 @@ extern int simple_write_end(struct file *file, struct address_space *mapping,
                         struct page *page, void *fsdata);
 extern int always_delete_dentry(const struct dentry *);
 extern struct inode *alloc_anon_inode(struct super_block *);
+extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
 extern const struct dentry_operations simple_dentry_operations;
 
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
@@ -2753,12 +2798,25 @@ static inline int is_sxid(umode_t mode)
         return (mode & S_ISUID) || ((mode & S_ISGID) && (mode & S_IXGRP));
 }
 
+static inline int check_sticky(struct inode *dir, struct inode *inode)
+{
+        if (!(dir->i_mode & S_ISVTX))
+                return 0;
+
+        return __check_sticky(dir, inode);
+}
+
 static inline void inode_has_no_xattr(struct inode *inode)
 {
         if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & MS_NOSEC))
                 inode->i_flags |= S_NOSEC;
 }
 
+static inline bool is_root_inode(struct inode *inode)
+{
+        return inode == inode->i_sb->s_root->d_inode;
+}
+
 static inline bool dir_emit(struct dir_context *ctx,
                             const char *name, int namelen,
                             u64 ino, unsigned type)
diff --git a/include/linux/fs_enet_pd.h b/include/linux/fs_enet_pd.h
index efb05961bdd8..77d783f71527 100644
--- a/include/linux/fs_enet_pd.h
+++ b/include/linux/fs_enet_pd.h
@@ -139,7 +139,6 @@ struct fs_platform_info {
         int rx_ring, tx_ring;   /* number of buffers on rx     */
         __u8 macaddr[ETH_ALEN]; /* mac address                 */
         int rx_copybreak;       /* limit we copy small frames  */
-        int use_napi;           /* use NAPI                    */
         int napi_weight;        /* NAPI weight                 */
 
         int use_rmii;           /* use RMII mode               */
diff --git a/include/linux/fsl_ifc.h b/include/linux/fsl_ifc.h
index f49ddb1b2273..bf0321eabbda 100644
--- a/include/linux/fsl_ifc.h
+++ b/include/linux/fsl_ifc.h
@@ -29,7 +29,16 @@
 #include <linux/of_platform.h>
 #include <linux/interrupt.h>
 
-#define FSL_IFC_BANK_COUNT 4
+/*
+ * The actual number of banks implemented depends on the IFC version
+ *    - IFC version 1.0 implements 4 banks.
+ *    - IFC version 1.1 onward implements 8 banks.
+ */
+#define FSL_IFC_BANK_COUNT 8
+
+#define FSL_IFC_VERSION_MASK    0x0F0F0000
+#define FSL_IFC_VERSION_1_0_0   0x01000000
+#define FSL_IFC_VERSION_1_1_0   0x01010000
 
 /*
  * CSPR - Chip Select Property Register
@@ -776,23 +785,23 @@ struct fsl_ifc_regs {
                 __be32 cspr;
                 u32 res2;
         } cspr_cs[FSL_IFC_BANK_COUNT];
-        u32 res3[0x19];
+        u32 res3[0xd];
         struct {
                 __be32 amask;
                 u32 res4[0x2];
         } amask_cs[FSL_IFC_BANK_COUNT];
-        u32 res5[0x17];
+        u32 res5[0xc];
         struct {
-                __be32 csor_ext;
                 __be32 csor;
+                __be32 csor_ext;
                 u32 res6;
         } csor_cs[FSL_IFC_BANK_COUNT];
-        u32 res7[0x19];
+        u32 res7[0xc];
         struct {
                 __be32 ftim[4];
                 u32 res8[0x8];
         } ftim_cs[FSL_IFC_BANK_COUNT];
-        u32 res9[0x60];
+        u32 res9[0x30];
         __be32 rb_stat;
         u32 res10[0x2];
         __be32 ifc_gcr;
@@ -827,6 +836,8 @@ struct fsl_ifc_ctrl {
         int                             nand_irq;
         spinlock_t                      lock;
         void                            *nand;
+        int                             version;
+        int                             banks;
 
         u32 nand_stat;
         wait_queue_head_t nand_wait;
diff --git a/include/linux/fsldma.h b/include/linux/fsldma.h
new file mode 100644
index 000000000000..b213c02963c9
--- /dev/null
+++ b/include/linux/fsldma.h
@@ -0,0 +1,13 @@
+/*
+ * This 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 FSL_DMA_H
+#define FSL_DMA_H
+/* fsl dma API for enxternal start */
+int fsl_dma_external_start(struct dma_chan *dchan, int enable);
+
+#endif
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index ca060d7c4fa6..0f313f93c586 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -197,24 +197,6 @@ struct fsnotify_group {
 #define FSNOTIFY_EVENT_INODE    2
 
 /*
- * Inode specific fields in an fsnotify_mark
- */
-struct fsnotify_inode_mark {
-        struct inode *inode;            /* inode this mark is associated with */
-        struct hlist_node i_list;       /* list of marks by inode->i_fsnotify_marks */
-        struct list_head free_i_list;   /* tmp list used when freeing this mark */
-};
-
-/*
- * Mount point specific fields in an fsnotify_mark
- */
-struct fsnotify_vfsmount_mark {
-        struct vfsmount *mnt;           /* vfsmount this mark is associated with */
-        struct hlist_node m_list;       /* list of marks by inode->i_fsnotify_marks */
-        struct list_head free_m_list;   /* tmp list used when freeing this mark */
-};
-
-/*
  * a mark is simply an object attached to an in core inode which allows an
  * fsnotify listener to indicate they are either no longer interested in events
  * of a type matching mask or only interested in those events.
@@ -230,11 +212,17 @@ struct fsnotify_mark {
          * in kernel that found and may be using this mark. */
         atomic_t refcnt;                /* active things looking at this mark */
         struct fsnotify_group *group;   /* group this mark is for */
-        struct list_head g_list;        /* list of marks by group->i_fsnotify_marks */
+        struct list_head g_list;        /* list of marks by group->i_fsnotify_marks
+                                         * Also reused for queueing mark into
+                                         * destroy_list when it's waiting for
+                                         * the end of SRCU period before it can
+                                         * be freed */
         spinlock_t lock;                /* protect group and inode */
+        struct hlist_node obj_list;     /* list of marks for inode / vfsmount */
+        struct list_head free_list;     /* tmp list used when freeing this mark */
         union {
-                struct fsnotify_inode_mark i;
-                struct fsnotify_vfsmount_mark m;
+                struct inode *inode;    /* inode this mark is associated with */
+                struct vfsmount *mnt;   /* vfsmount this mark is associated with */
         };
         __u32 ignored_mask;             /* events types to ignore */
 #define FSNOTIFY_MARK_FLAG_INODE                0x01
@@ -243,7 +231,6 @@ struct fsnotify_mark {
 #define FSNOTIFY_MARK_FLAG_IGNORED_SURV_MODIFY  0x08
 #define FSNOTIFY_MARK_FLAG_ALIVE                0x10
         unsigned int flags;             /* vfsmount or inode mark? */
-        struct list_head destroy_list;
         void (*free_mark)(struct fsnotify_mark *mark); /* called on final put+free */
 };
 
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index f0b0edbf55a9..1da602982cf9 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -39,6 +39,12 @@
 # define FTRACE_FORCE_LIST_FUNC 0
 #endif
 
+/* Main tracing buffer and events set up */
+#ifdef CONFIG_TRACING
+void trace_init(void);
+#else
+static inline void trace_init(void) { }
+#endif
 
 struct module;
 struct ftrace_hash;
@@ -56,9 +62,16 @@ struct ftrace_ops;
 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
                               struct ftrace_ops *op, struct pt_regs *regs);
 
+ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
+
 /*
  * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are
  * set in the flags member.
+ * CONTROL, SAVE_REGS, SAVE_REGS_IF_SUPPORTED, RECURSION_SAFE, STUB and
+ * IPMODIFY are a kind of attribute flags which can be set only before
+ * registering the ftrace_ops, and can not be modified while registered.
+ * Changing those attribute flags after regsitering ftrace_ops will
+ * cause unexpected results.
  *
  * ENABLED - set/unset when ftrace_ops is registered/unregistered
  * DYNAMIC - set when ftrace_ops is registered to denote dynamically
@@ -89,6 +102,20 @@ typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
  * INITIALIZED - The ftrace_ops has already been initialized (first use time
  *            register_ftrace_function() is called, it will initialized the ops)
  * DELETED - The ops are being deleted, do not let them be registered again.
+ * ADDING  - The ops is in the process of being added.
+ * REMOVING - The ops is in the process of being removed.
+ * MODIFYING - The ops is in the process of changing its filter functions.
+ * ALLOC_TRAMP - A dynamic trampoline was allocated by the core code.
+ *            The arch specific code sets this flag when it allocated a
+ *            trampoline. This lets the arch know that it can update the
+ *            trampoline in case the callback function changes.
+ *            The ftrace_ops trampoline can be set by the ftrace users, and
+ *            in such cases the arch must not modify it. Only the arch ftrace
+ *            core code should set this flag.
+ * IPMODIFY - The ops can modify the IP register. This can only be set with
+ *            SAVE_REGS. If another ops with this flag set is already registered
+ *            for any of the functions that this ops will be registered for, then
+ *            this ops will fail to register or set_filter_ip.
  */
 enum {
         FTRACE_OPS_FL_ENABLED                   = 1 << 0,
@@ -100,6 +127,11 @@ enum {
         FTRACE_OPS_FL_STUB                      = 1 << 6,
         FTRACE_OPS_FL_INITIALIZED               = 1 << 7,
         FTRACE_OPS_FL_DELETED                   = 1 << 8,
+        FTRACE_OPS_FL_ADDING                    = 1 << 9,
+        FTRACE_OPS_FL_REMOVING                  = 1 << 10,
+        FTRACE_OPS_FL_MODIFYING                 = 1 << 11,
+        FTRACE_OPS_FL_ALLOC_TRAMP               = 1 << 12,
+        FTRACE_OPS_FL_IPMODIFY                  = 1 << 13,
 };
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -132,8 +164,9 @@ struct ftrace_ops {
         int                             nr_trampolines;
         struct ftrace_ops_hash          local_hash;
         struct ftrace_ops_hash          *func_hash;
-        struct ftrace_hash              *tramp_hash;
+        struct ftrace_ops_hash          old_hash;
         unsigned long                   trampoline;
+        unsigned long                   trampoline_size;
 #endif
 };
 
@@ -247,7 +280,9 @@ struct ftrace_func_command {
 int ftrace_arch_code_modify_prepare(void);
 int ftrace_arch_code_modify_post_process(void);
 
-void ftrace_bug(int err, unsigned long ip);
+struct dyn_ftrace;
+
+void ftrace_bug(int err, struct dyn_ftrace *rec);
 
 struct seq_file;
 
@@ -279,6 +314,8 @@ extern int ftrace_text_reserved(const void *start, const void *end);
 
 extern int ftrace_nr_registered_ops(void);
 
+bool is_ftrace_trampoline(unsigned long addr);
+
 /*
  * The dyn_ftrace record's flags field is split into two parts.
  * the first part which is '0-FTRACE_REF_MAX' is a counter of
@@ -289,6 +326,7 @@ extern int ftrace_nr_registered_ops(void);
  *  ENABLED - the function is being traced
  *  REGS    - the record wants the function to save regs
  *  REGS_EN - the function is set up to save regs.
+ *  IPMODIFY - the record allows for the IP address to be changed.
  *
  * When a new ftrace_ops is registered and wants a function to save
  * pt_regs, the rec->flag REGS is set. When the function has been
@@ -302,10 +340,11 @@ enum {
         FTRACE_FL_REGS_EN       = (1UL << 29),
         FTRACE_FL_TRAMP         = (1UL << 28),
         FTRACE_FL_TRAMP_EN      = (1UL << 27),
+        FTRACE_FL_IPMODIFY      = (1UL << 26),
 };
 
-#define FTRACE_REF_MAX_SHIFT    27
-#define FTRACE_FL_BITS          5
+#define FTRACE_REF_MAX_SHIFT    26
+#define FTRACE_FL_BITS          6
 #define FTRACE_FL_MASKED_BITS   ((1UL << FTRACE_FL_BITS) - 1)
 #define FTRACE_FL_MASK          (FTRACE_FL_MASKED_BITS << FTRACE_REF_MAX_SHIFT)
 #define FTRACE_REF_MAX          ((1UL << FTRACE_REF_MAX_SHIFT) - 1)
@@ -578,6 +617,11 @@ static inline ssize_t ftrace_notrace_write(struct file *file, const char __user
                              size_t cnt, loff_t *ppos) { return -ENODEV; }
 static inline int
 ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; }
+
+static inline bool is_ftrace_trampoline(unsigned long addr)
+{
+        return false;
+}
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
 /* totally disable ftrace - can not re-enable after this */
@@ -835,6 +879,7 @@ static inline int test_tsk_trace_graph(struct task_struct *tsk)
 enum ftrace_dump_mode;
 
 extern enum ftrace_dump_mode ftrace_dump_on_oops;
+extern int tracepoint_printk;
 
 extern void disable_trace_on_warning(void);
 extern int __disable_trace_on_warning;
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 28672e87e910..0bebb5c348b8 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -138,6 +138,17 @@ enum print_line_t {
         TRACE_TYPE_NO_CONSUME   = 3     /* Handled but ask to not consume */
 };
 
+/*
+ * Several functions return TRACE_TYPE_PARTIAL_LINE if the trace_seq
+ * overflowed, and TRACE_TYPE_HANDLED otherwise. This helper function
+ * simplifies those functions and keeps them in sync.
+ */
+static inline enum print_line_t trace_handle_return(struct trace_seq *s)
+{
+        return trace_seq_has_overflowed(s) ?
+                TRACE_TYPE_PARTIAL_LINE : TRACE_TYPE_HANDLED;
+}
+
 void tracing_generic_entry_update(struct trace_entry *entry,
                                   unsigned long flags,
                                   int pc);
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
index 1c2fdaa2ffc3..1ccaab44abcc 100644
--- a/include/linux/genalloc.h
+++ b/include/linux/genalloc.h
@@ -110,6 +110,10 @@ extern void gen_pool_set_algo(struct gen_pool *pool, genpool_algo_t algo,
 extern unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size,
                 unsigned long start, unsigned int nr, void *data);
 
+extern unsigned long gen_pool_first_fit_order_align(unsigned long *map,
+                unsigned long size, unsigned long start, unsigned int nr,
+                void *data);
+
 extern unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
                 unsigned long start, unsigned int nr, void *data);
 
@@ -117,6 +121,9 @@ extern struct gen_pool *devm_gen_pool_create(struct device *dev,
                 int min_alloc_order, int nid);
 extern struct gen_pool *dev_get_gen_pool(struct device *dev);
 
+bool addr_in_gen_pool(struct gen_pool *pool, unsigned long start,
+                        size_t size);
+
 #ifdef CONFIG_OF
 extern struct gen_pool *of_get_named_gen_pool(struct device_node *np,
         const char *propname, int index);
diff --git a/include/linux/genl_magic_func.h b/include/linux/genl_magic_func.h
index c0894dd8827b..667c31101b8b 100644
--- a/include/linux/genl_magic_func.h
+++ b/include/linux/genl_magic_func.h
@@ -178,12 +178,12 @@ static int s_name ## _from_attrs_for_change(struct s_name *s,		\
 #define __assign(attr_nr, attr_flag, name, nla_type, type, assignment...)       \
                 nla = ntb[attr_nr];                                             \
                 if (nla) {                                              \
-                        if (exclude_invariants && ((attr_flag) & DRBD_F_INVARIANT)) {           \
+                        if (exclude_invariants && !!((attr_flag) & DRBD_F_INVARIANT)) {         \
                                 pr_info("<< must not change invariant attr: %s\n", #name);      \
                                 return -EEXIST;                         \
                         }                                               \
                         assignment;                                     \
-                } else if (exclude_invariants && ((attr_flag) & DRBD_F_INVARIANT)) {            \
+                } else if (exclude_invariants && !!((attr_flag) & DRBD_F_INVARIANT)) {          \
                         /* attribute missing from payload, */           \
                         /* which was expected */                        \
                 } else if ((attr_flag) & DRBD_F_REQUIRED) {             \
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 5e7219dc0fae..b840e3b2770d 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -110,11 +110,8 @@ struct vm_area_struct;
 #define GFP_TEMPORARY   (__GFP_WAIT | __GFP_IO | __GFP_FS | \
                          __GFP_RECLAIMABLE)
 #define GFP_USER        (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
-#define GFP_HIGHUSER    (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL | \
-                         __GFP_HIGHMEM)
-#define GFP_HIGHUSER_MOVABLE    (__GFP_WAIT | __GFP_IO | __GFP_FS | \
-                                 __GFP_HARDWALL | __GFP_HIGHMEM | \
-                                 __GFP_MOVABLE)
+#define GFP_HIGHUSER    (GFP_USER | __GFP_HIGHMEM)
+#define GFP_HIGHUSER_MOVABLE    (GFP_HIGHUSER | __GFP_MOVABLE)
 #define GFP_IOFS        (__GFP_IO | __GFP_FS)
 #define GFP_TRANSHUGE   (GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
                          __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN | \
@@ -156,7 +153,7 @@ struct vm_area_struct;
 #define GFP_DMA32       __GFP_DMA32
 
 /* Convert GFP flags to their corresponding migrate type */
-static inline int allocflags_to_migratetype(gfp_t gfp_flags)
+static inline int gfpflags_to_migratetype(const gfp_t gfp_flags)
 {
         WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
 
@@ -381,8 +378,8 @@ extern void free_kmem_pages(unsigned long addr, unsigned int order);
 
 void page_alloc_init(void);
 void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
-void drain_all_pages(void);
-void drain_local_pages(void *dummy);
+void drain_all_pages(struct zone *zone);
+void drain_local_pages(struct zone *zone);
 
 /*
  * gfp_allowed_mask is set to GFP_BOOT_MASK during early boot to restrict what
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 85aa5d0b9357..ab81339a8590 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -216,14 +216,15 @@ static inline int gpio_to_irq(unsigned gpio)
         return -EINVAL;
 }
 
-static inline int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
+static inline int gpiochip_lock_as_irq(struct gpio_chip *chip,
+                                       unsigned int offset)
 {
         WARN_ON(1);
         return -EINVAL;
 }
 
-static inline void gpio_unlock_as_irq(struct gpio_chip *chip,
-                                      unsigned int offset)
+static inline void gpiochip_unlock_as_irq(struct gpio_chip *chip,
+                                          unsigned int offset)
 {
         WARN_ON(1);
 }
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index 12f146fa6604..fd85cb120ee0 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -66,7 +66,7 @@ __devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
                               unsigned int index, enum gpiod_flags flags);
 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
 
-int gpiod_get_direction(const struct gpio_desc *desc);
+int gpiod_get_direction(struct gpio_desc *desc);
 int gpiod_direction_input(struct gpio_desc *desc);
 int gpiod_direction_output(struct gpio_desc *desc, int value);
 int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
@@ -74,14 +74,24 @@ int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
 /* Value get/set from non-sleeping context */
 int gpiod_get_value(const struct gpio_desc *desc);
 void gpiod_set_value(struct gpio_desc *desc, int value);
+void gpiod_set_array(unsigned int array_size,
+                     struct gpio_desc **desc_array, int *value_array);
 int gpiod_get_raw_value(const struct gpio_desc *desc);
 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array(unsigned int array_size,
+                         struct gpio_desc **desc_array, int *value_array);
 
 /* Value get/set from sleeping context */
 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
+void gpiod_set_array_cansleep(unsigned int array_size,
+                              struct gpio_desc **desc_array,
+                              int *value_array);
 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
+void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                  struct gpio_desc **desc_array,
+                                  int *value_array);
 
 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 
@@ -94,6 +104,13 @@ int gpiod_to_irq(const struct gpio_desc *desc);
 struct gpio_desc *gpio_to_desc(unsigned gpio);
 int desc_to_gpio(const struct gpio_desc *desc);
 
+/* Child properties interface */
+struct fwnode_handle;
+
+struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
+                                         const char *propname);
+struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
+                                            struct fwnode_handle *child);
 #else /* CONFIG_GPIOLIB */
 
 static inline struct gpio_desc *__must_check __gpiod_get(struct device *dev,
@@ -210,6 +227,13 @@ static inline void gpiod_set_value(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
+static inline void gpiod_set_array(unsigned int array_size,
+                                   struct gpio_desc **desc_array,
+                                   int *value_array)
+{
+        /* GPIO can never have been requested */
+        WARN_ON(1);
+}
 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 {
         /* GPIO can never have been requested */
@@ -221,6 +245,13 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
+static inline void gpiod_set_raw_array(unsigned int array_size,
+                                       struct gpio_desc **desc_array,
+                                       int *value_array)
+{
+        /* GPIO can never have been requested */
+        WARN_ON(1);
+}
 
 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 {
@@ -233,6 +264,13 @@ static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
+static inline void gpiod_set_array_cansleep(unsigned int array_size,
+                                            struct gpio_desc **desc_array,
+                                            int *value_array)
+{
+        /* GPIO can never have been requested */
+        WARN_ON(1);
+}
 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 {
         /* GPIO can never have been requested */
@@ -245,6 +283,13 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
+static inline void gpiod_set_raw_array_cansleep(unsigned int array_size,
+                                                struct gpio_desc **desc_array,
+                                                int *value_array)
+{
+        /* GPIO can never have been requested */
+        WARN_ON(1);
+}
 
 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 {
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index e78a2373e374..c497c62889d1 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -32,6 +32,7 @@ struct seq_file;
  * @get: returns value for signal "offset"; for output signals this
  *      returns either the value actually sensed, or zero
  * @set: assigns output value for signal "offset"
+ * @set_multiple: assigns output values for multiple signals defined by "mask"
  * @set_debounce: optional hook for setting debounce time for specified gpio in
  *      interrupt triggered gpio chips
  * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
@@ -56,6 +57,8 @@ struct seq_file;
  *      as the chip access may sleep when e.g. reading out the IRQ status
  *      registers.
  * @exported: flags if the gpiochip is exported for use from sysfs. Private.
+ * @irq_not_threaded: flag must be set if @can_sleep is set but the
+ *      IRQs don't need to be threaded
  *
  * A gpio_chip can help platforms abstract various sources of GPIOs so
  * they can all be accessed through a common programing interface.
@@ -87,6 +90,9 @@ struct gpio_chip {
                                                 unsigned offset);
         void                    (*set)(struct gpio_chip *chip,
                                                 unsigned offset, int value);
+        void                    (*set_multiple)(struct gpio_chip *chip,
+                                                unsigned long *mask,
+                                                unsigned long *bits);
         int                     (*set_debounce)(struct gpio_chip *chip,
                                                 unsigned offset,
                                                 unsigned debounce);
@@ -101,11 +107,12 @@ struct gpio_chip {
         struct gpio_desc        *desc;
         const char              *const *names;
         bool                    can_sleep;
+        bool                    irq_not_threaded;
         bool                    exported;
 
 #ifdef CONFIG_GPIOLIB_IRQCHIP
         /*
-         * With CONFIG_GPIO_IRQCHIP we get an irqchip inside the gpiolib
+         * With CONFIG_GPIOLIB_IRQCHIP we get an irqchip inside the gpiolib
          * to handle IRQs for most practical cases.
          */
         struct irq_chip         *irqchip;
@@ -141,13 +148,13 @@ extern const char *gpiochip_is_requested(struct gpio_chip *chip,
 
 /* add/remove chips */
 extern int gpiochip_add(struct gpio_chip *chip);
-extern int gpiochip_remove(struct gpio_chip *chip);
+extern void gpiochip_remove(struct gpio_chip *chip);
 extern struct gpio_chip *gpiochip_find(void *data,
                               int (*match)(struct gpio_chip *chip, void *data));
 
 /* lock/unlock as IRQ */
-int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset);
-void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset);
+int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset);
+void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset);
 
 struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc);
 
@@ -164,9 +171,10 @@ int gpiochip_irqchip_add(struct gpio_chip *gpiochip,
                 irq_flow_handler_t handler,
                 unsigned int type);
 
-#endif /* CONFIG_GPIO_IRQCHIP */
+#endif /* CONFIG_GPIOLIB_IRQCHIP */
 
-int gpiochip_request_own_desc(struct gpio_desc *desc, const char *label);
+struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
+                                            const char *label);
 void gpiochip_free_own_desc(struct gpio_desc *desc);
 
 #else /* CONFIG_GPIOLIB */
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index 8b622468952c..ee2d8c6f9130 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -2,6 +2,7 @@
 #define _GPIO_KEYS_H
 
 struct device;
+struct gpio_desc;
 
 /**
  * struct gpio_keys_button - configuration parameters
@@ -17,6 +18,7 @@ struct device;
  *                      disable button via sysfs
  * @value:              axis value for %EV_ABS
  * @irq:                Irq number in case of interrupt keys
+ * @gpiod:              GPIO descriptor
  */
 struct gpio_keys_button {
         unsigned int code;
@@ -29,6 +31,7 @@ struct gpio_keys_button {
         bool can_disable;
         int value;
         unsigned int irq;
+        struct gpio_desc *gpiod;
 };
 
 /**
diff --git a/include/linux/hash.h b/include/linux/hash.h
index d0494c399392..1afde47e1528 100644
--- a/include/linux/hash.h
+++ b/include/linux/hash.h
@@ -15,7 +15,6 @@
  */
 
 #include <asm/types.h>
-#include <asm/hash.h>
 #include <linux/compiler.h>
 
 /* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */
@@ -84,38 +83,4 @@ static inline u32 hash32_ptr(const void *ptr)
         return (u32)val;
 }
 
-struct fast_hash_ops {
-        u32 (*hash)(const void *data, u32 len, u32 seed);
-        u32 (*hash2)(const u32 *data, u32 len, u32 seed);
-};
-
-/**
- *      arch_fast_hash - Caclulates a hash over a given buffer that can have
- *                       arbitrary size. This function will eventually use an
- *                       architecture-optimized hashing implementation if
- *                       available, and trades off distribution for speed.
- *
- *      @data: buffer to hash
- *      @len: length of buffer in bytes
- *      @seed: start seed
- *
- *      Returns 32bit hash.
- */
-extern u32 arch_fast_hash(const void *data, u32 len, u32 seed);
-
-/**
- *      arch_fast_hash2 - Caclulates a hash over a given buffer that has a
- *                        size that is of a multiple of 32bit words. This
- *                        function will eventually use an architecture-
- *                        optimized hashing implementation if available,
- *                        and trades off distribution for speed.
- *
- *      @data: buffer to hash (must be 32bit padded)
- *      @len: number of 32bit words
- *      @seed: start seed
- *
- *      Returns 32bit hash.
- */
-extern u32 arch_fast_hash2(const u32 *data, u32 len, u32 seed);
-
 #endif /* _LINUX_HASH_H */
diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h
index 11c0182a153b..cbb5790a35cd 100644
--- a/include/linux/hdmi.h
+++ b/include/linux/hdmi.h
@@ -1,9 +1,24 @@
 /*
  * Copyright (C) 2012 Avionic Design GmbH
  *
- * 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.
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
  */
 
 #ifndef __LINUX_HDMI_H_
diff --git a/include/linux/hid.h b/include/linux/hid.h
index f53c4a9cca1d..06c4607744f6 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -234,6 +234,33 @@ struct hid_item {
 #define HID_DG_BARRELSWITCH     0x000d0044
 #define HID_DG_ERASER           0x000d0045
 #define HID_DG_TABLETPICK       0x000d0046
+
+#define HID_CP_CONSUMERCONTROL  0x000c0001
+#define HID_CP_NUMERICKEYPAD    0x000c0002
+#define HID_CP_PROGRAMMABLEBUTTONS      0x000c0003
+#define HID_CP_MICROPHONE       0x000c0004
+#define HID_CP_HEADPHONE        0x000c0005
+#define HID_CP_GRAPHICEQUALIZER 0x000c0006
+#define HID_CP_FUNCTIONBUTTONS  0x000c0036
+#define HID_CP_SELECTION        0x000c0080
+#define HID_CP_MEDIASELECTION   0x000c0087
+#define HID_CP_SELECTDISC       0x000c00ba
+#define HID_CP_PLAYBACKSPEED    0x000c00f1
+#define HID_CP_PROXIMITY        0x000c0109
+#define HID_CP_SPEAKERSYSTEM    0x000c0160
+#define HID_CP_CHANNELLEFT      0x000c0161
+#define HID_CP_CHANNELRIGHT     0x000c0162
+#define HID_CP_CHANNELCENTER    0x000c0163
+#define HID_CP_CHANNELFRONT     0x000c0164
+#define HID_CP_CHANNELCENTERFRONT       0x000c0165
+#define HID_CP_CHANNELSIDE      0x000c0166
+#define HID_CP_CHANNELSURROUND  0x000c0167
+#define HID_CP_CHANNELLOWFREQUENCYENHANCEMENT   0x000c0168
+#define HID_CP_CHANNELTOP       0x000c0169
+#define HID_CP_CHANNELUNKNOWN   0x000c016a
+#define HID_CP_APPLICATIONLAUNCHBUTTONS 0x000c0180
+#define HID_CP_GENERICGUIAPPLICATIONCONTROLS    0x000c0200
+
 #define HID_DG_CONFIDENCE       0x000d0047
 #define HID_DG_WIDTH            0x000d0048
 #define HID_DG_HEIGHT           0x000d0049
@@ -265,6 +292,7 @@ struct hid_item {
 #define HID_CONNECT_HIDDEV              0x08
 #define HID_CONNECT_HIDDEV_FORCE        0x10
 #define HID_CONNECT_FF                  0x20
+#define HID_CONNECT_DRIVER              0x40
 #define HID_CONNECT_DEFAULT     (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| \
                 HID_CONNECT_HIDDEV|HID_CONNECT_FF)
 
@@ -287,6 +315,7 @@ struct hid_item {
 #define HID_QUIRK_HIDINPUT_FORCE                0x00000080
 #define HID_QUIRK_NO_EMPTY_INPUT                0x00000100
 #define HID_QUIRK_NO_INIT_INPUT_REPORTS         0x00000200
+#define HID_QUIRK_ALWAYS_POLL                   0x00000400
 #define HID_QUIRK_SKIP_OUTPUT_REPORTS           0x00010000
 #define HID_QUIRK_SKIP_OUTPUT_REPORT_ID         0x00020000
 #define HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP  0x00040000
@@ -310,11 +339,8 @@ struct hid_item {
  * Vendor specific HID device groups
  */
 #define HID_GROUP_RMI                           0x0100
-
-/*
- * Vendor specific HID device groups
- */
 #define HID_GROUP_WACOM                         0x0101
+#define HID_GROUP_LOGITECH_DJ_DEVICE            0x0102
 
 /*
  * This is the global environment of the parser. This information is
@@ -440,6 +466,7 @@ struct hid_output_fifo {
 #define HID_CLAIMED_INPUT       1
 #define HID_CLAIMED_HIDDEV      2
 #define HID_CLAIMED_HIDRAW      4
+#define HID_CLAIMED_DRIVER      8
 
 #define HID_STAT_ADDED          1
 #define HID_STAT_PARSED         2
@@ -1060,6 +1087,17 @@ static inline void hid_hw_wait(struct hid_device *hdev)
                 hdev->ll_driver->wait(hdev);
 }
 
+/**
+ * hid_report_len - calculate the report length
+ *
+ * @report: the report we want to know the length
+ */
+static inline int hid_report_len(struct hid_report *report)
+{
+        /* equivalent to DIV_ROUND_UP(report->size, 8) + !!(report->id > 0) */
+        return ((report->size - 1) >> 3) + 1 + (report->id > 0);
+}
+
 int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
                 int interrupt);
 
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 63579cb8d3dc..ad9051bab267 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -132,7 +132,7 @@ extern int __pmd_trans_huge_lock(pmd_t *pmd, struct vm_area_struct *vma,
 static inline int pmd_trans_huge_lock(pmd_t *pmd, struct vm_area_struct *vma,
                 spinlock_t **ptl)
 {
-        VM_BUG_ON(!rwsem_is_locked(&vma->vm_mm->mmap_sem));
+        VM_BUG_ON_VMA(!rwsem_is_locked(&vma->vm_mm->mmap_sem), vma);
         if (pmd_trans_huge(*pmd))
                 return __pmd_trans_huge_lock(pmd, vma, ptl);
         else
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 6e6d338641fe..431b7fc605c9 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -175,6 +175,52 @@ static inline void __unmap_hugepage_range(struct mmu_gather *tlb,
 }
 
 #endif /* !CONFIG_HUGETLB_PAGE */
+/*
+ * hugepages at page global directory. If arch support
+ * hugepages at pgd level, they need to define this.
+ */
+#ifndef pgd_huge
+#define pgd_huge(x)     0
+#endif
+
+#ifndef pgd_write
+static inline int pgd_write(pgd_t pgd)
+{
+        BUG();
+        return 0;
+}
+#endif
+
+#ifndef pud_write
+static inline int pud_write(pud_t pud)
+{
+        BUG();
+        return 0;
+}
+#endif
+
+#ifndef is_hugepd
+/*
+ * Some architectures requires a hugepage directory format that is
+ * required to support multiple hugepage sizes. For example
+ * a4fe3ce76 "powerpc/mm: Allow more flexible layouts for hugepage pagetables"
+ * introduced the same on powerpc. This allows for a more flexible hugepage
+ * pagetable layout.
+ */
+typedef struct { unsigned long pd; } hugepd_t;
+#define is_hugepd(hugepd) (0)
+#define __hugepd(x) ((hugepd_t) { (x) })
+static inline int gup_huge_pd(hugepd_t hugepd, unsigned long addr,
+                              unsigned pdshift, unsigned long end,
+                              int write, struct page **pages, int *nr)
+{
+        return 0;
+}
+#else
+extern int gup_huge_pd(hugepd_t hugepd, unsigned long addr,
+                       unsigned pdshift, unsigned long end,
+                       int write, struct page **pages, int *nr);
+#endif
 
 #define HUGETLB_ANON_FILE "anon_hugepage"
 
@@ -311,7 +357,8 @@ static inline struct hstate *hstate_sizelog(int page_size_log)
 {
         if (!page_size_log)
                 return &default_hstate;
-        return size_to_hstate(1 << page_size_log);
+
+        return size_to_hstate(1UL << page_size_log);
 }
 
 static inline struct hstate *hstate_vma(struct vm_area_struct *vma)
diff --git a/include/linux/hugetlb_cgroup.h b/include/linux/hugetlb_cgroup.h
index 0129f89cf98d..bcc853eccc85 100644
--- a/include/linux/hugetlb_cgroup.h
+++ b/include/linux/hugetlb_cgroup.h
@@ -16,7 +16,6 @@
 #define _LINUX_HUGETLB_CGROUP_H
 
 #include <linux/mmdebug.h>
-#include <linux/res_counter.h>
 
 struct hugetlb_cgroup;
 /*
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 08cfaff8a072..476c685ca6f9 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -650,6 +650,8 @@ struct vmbus_channel {
         u8 monitor_grp;
         u8 monitor_bit;
 
+        bool rescind; /* got rescind msg */
+
         u32 ringbuffer_gpadlhandle;
 
         /* Allocated memory for ring buffer */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index b556e0ab946f..e3a1721c8354 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -46,6 +46,8 @@ struct i2c_client;
 struct i2c_driver;
 union i2c_smbus_data;
 struct i2c_board_info;
+enum i2c_slave_event;
+typedef int (*i2c_slave_cb_t)(struct i2c_client *, enum i2c_slave_event, u8 *);
 
 struct module;
 
@@ -209,6 +211,8 @@ struct i2c_driver {
  * @irq: indicates the IRQ generated by this device (if any)
  * @detected: member of an i2c_driver.clients list or i2c-core's
  *      userspace_devices list
+ * @slave_cb: Callback when I2C slave mode of an adapter is used. The adapter
+ *      calls it to pass on slave events to the slave driver.
  *
  * An i2c_client identifies a single device (i.e. chip) connected to an
  * i2c bus. The behaviour exposed to Linux is defined by the driver
@@ -224,6 +228,7 @@ struct i2c_client {
         struct device dev;              /* the device structure         */
         int irq;                        /* irq issued by device         */
         struct list_head detected;
+        i2c_slave_cb_t slave_cb;        /* callback for slave mode      */
 };
 #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
 
@@ -246,6 +251,25 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
         dev_set_drvdata(&dev->dev, data);
 }
 
+/* I2C slave support */
+
+enum i2c_slave_event {
+        I2C_SLAVE_REQ_READ_START,
+        I2C_SLAVE_REQ_READ_END,
+        I2C_SLAVE_REQ_WRITE_START,
+        I2C_SLAVE_REQ_WRITE_END,
+        I2C_SLAVE_STOP,
+};
+
+extern int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb);
+extern int i2c_slave_unregister(struct i2c_client *client);
+
+static inline int i2c_slave_event(struct i2c_client *client,
+                                  enum i2c_slave_event event, u8 *val)
+{
+        return client->slave_cb(client, event, val);
+}
+
 /**
  * struct i2c_board_info - template for device creation
  * @type: chip type, to initialize i2c_client.name
@@ -352,6 +376,8 @@ i2c_register_board_info(int busnum, struct i2c_board_info const *info,
  *   into I2C transfers instead.
  * @functionality: Return the flags that this algorithm/adapter pair supports
  *   from the I2C_FUNC_* flags.
+ * @reg_slave: Register given client to I2C slave mode of this adapter
+ * @unreg_slave: Unregister given client from I2C slave mode of this adapter
  *
  * The following structs are for those who like to implement new bus drivers:
  * i2c_algorithm is the interface to a class of hardware solutions which can
@@ -359,7 +385,7 @@ i2c_register_board_info(int busnum, struct i2c_board_info const *info,
  * to name two of the most common.
  *
  * The return codes from the @master_xfer field should indicate the type of
- * error code that occured during the transfer, as documented in the kernel
+ * error code that occurred during the transfer, as documented in the kernel
  * Documentation file Documentation/i2c/fault-codes.
  */
 struct i2c_algorithm {
@@ -377,6 +403,9 @@ struct i2c_algorithm {
 
         /* To determine what the adapter supports */
         u32 (*functionality) (struct i2c_adapter *);
+
+        int (*reg_slave)(struct i2c_client *client);
+        int (*unreg_slave)(struct i2c_client *client);
 };
 
 /**
diff --git a/include/linux/i2c/pmbus.h b/include/linux/i2c/pmbus.h
index 69280db02c41..ee3c2aba2a8e 100644
--- a/include/linux/i2c/pmbus.h
+++ b/include/linux/i2c/pmbus.h
@@ -40,6 +40,10 @@
 
 struct pmbus_platform_data {
         u32 flags;              /* Device specific flags */
+
+        /* regulator support */
+        int num_regulators;
+        struct regulator_init_data *reg_init_data;
 };
 
 #endif /* _PMBUS_H_ */
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index 8cfb50f38529..0bc03f100d04 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -26,7 +26,6 @@
 #define __TWL_H_
 
 #include <linux/types.h>
-#include <linux/phy/phy.h>
 #include <linux/input/matrix_keypad.h>
 
 /*
@@ -634,7 +633,6 @@ enum twl4030_usb_mode {
 struct twl4030_usb_data {
         enum twl4030_usb_mode   usb_mode;
         unsigned long           features;
-        struct phy_init_data    *init_data;
 
         int             (*phy_init)(struct device *dev);
         int             (*phy_exit)(struct device *dev);
diff --git a/include/linux/i82593.h b/include/linux/i82593.h
deleted file mode 100644
index afac5c7a323d..000000000000
--- a/include/linux/i82593.h
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Definitions for Intel 82593 CSMA/CD Core LAN Controller
- * The definitions are taken from the 1992 users manual with Intel
- * order number 297125-001.
- *
- * /usr/src/pc/RCS/i82593.h,v 1.1 1996/07/17 15:23:12 root Exp
- *
- * Copyright 1994, Anders Klemets <klemets@it.kth.se>
- *
- * HISTORY
- * i82593.h,v
- * Revision 1.4  2005/11/4  09:15:00  baroniunas
- * Modified copyright with permission of author as follows:
- *
- *   "If I82539.H is the only file with my copyright statement
- *    that is included in the Source Forge project, then you have
- *    my approval to change the copyright statement to be a GPL
- *    license, in the way you proposed on October 10."
- *
- * Revision 1.1  1996/07/17 15:23:12  root
- * Initial revision
- *
- * Revision 1.3  1995/04/05  15:13:58  adj
- * Initial alpha release
- *
- * Revision 1.2  1994/06/16  23:57:31  klemets
- * Mirrored all the fields in the configuration block.
- *
- * Revision 1.1  1994/06/02  20:25:34  klemets
- * Initial revision
- *
- *
- */
-#ifndef _I82593_H
-#define _I82593_H
-
-/* Intel 82593 CSMA/CD Core LAN Controller */
-
-/* Port 0 Command Register definitions */
-
-/* Execution operations */
-#define OP0_NOP                 0       /* CHNL = 0 */
-#define OP0_SWIT_TO_PORT_1      0       /* CHNL = 1 */
-#define OP0_IA_SETUP            1
-#define OP0_CONFIGURE           2
-#define OP0_MC_SETUP            3
-#define OP0_TRANSMIT            4
-#define OP0_TDR                 5
-#define OP0_DUMP                6
-#define OP0_DIAGNOSE            7
-#define OP0_TRANSMIT_NO_CRC     9
-#define OP0_RETRANSMIT          12
-#define OP0_ABORT               13
-/* Reception operations */
-#define OP0_RCV_ENABLE          8
-#define OP0_RCV_DISABLE         10
-#define OP0_STOP_RCV            11
-/* Status pointer control operations */
-#define OP0_FIX_PTR             15      /* CHNL = 1 */
-#define OP0_RLS_PTR             15      /* CHNL = 0 */
-#define OP0_RESET               14
-
-#define CR0_CHNL                (1 << 4)        /* 0=Channel 0, 1=Channel 1 */
-#define CR0_STATUS_0            0x00
-#define CR0_STATUS_1            0x20
-#define CR0_STATUS_2            0x40
-#define CR0_STATUS_3            0x60
-#define CR0_INT_ACK             (1 << 7)        /* 0=No ack, 1=acknowledge */
-
-/* Port 0 Status Register definitions */
-
-#define SR0_NO_RESULT           0               /* dummy */
-#define SR0_EVENT_MASK          0x0f
-#define SR0_IA_SETUP_DONE       1
-#define SR0_CONFIGURE_DONE      2
-#define SR0_MC_SETUP_DONE       3
-#define SR0_TRANSMIT_DONE       4
-#define SR0_TDR_DONE            5
-#define SR0_DUMP_DONE           6
-#define SR0_DIAGNOSE_PASSED     7
-#define SR0_TRANSMIT_NO_CRC_DONE 9
-#define SR0_RETRANSMIT_DONE     12
-#define SR0_EXECUTION_ABORTED   13
-#define SR0_END_OF_FRAME        8
-#define SR0_RECEPTION_ABORTED   10
-#define SR0_DIAGNOSE_FAILED     15
-#define SR0_STOP_REG_HIT        11
-
-#define SR0_CHNL                (1 << 4)
-#define SR0_EXECUTION           (1 << 5)
-#define SR0_RECEPTION           (1 << 6)
-#define SR0_INTERRUPT           (1 << 7)
-#define SR0_BOTH_RX_TX          (SR0_EXECUTION | SR0_RECEPTION)
-
-#define SR3_EXEC_STATE_MASK     0x03
-#define SR3_EXEC_IDLE           0
-#define SR3_TX_ABORT_IN_PROGRESS 1
-#define SR3_EXEC_ACTIVE         2
-#define SR3_ABORT_IN_PROGRESS   3
-#define SR3_EXEC_CHNL           (1 << 2)
-#define SR3_STP_ON_NO_RSRC      (1 << 3)
-#define SR3_RCVING_NO_RSRC      (1 << 4)
-#define SR3_RCV_STATE_MASK      0x60
-#define SR3_RCV_IDLE            0x00
-#define SR3_RCV_READY           0x20
-#define SR3_RCV_ACTIVE          0x40
-#define SR3_RCV_STOP_IN_PROG    0x60
-#define SR3_RCV_CHNL            (1 << 7)
-
-/* Port 1 Command Register definitions */
-
-#define OP1_NOP                 0
-#define OP1_SWIT_TO_PORT_0      1
-#define OP1_INT_DISABLE         2
-#define OP1_INT_ENABLE          3
-#define OP1_SET_TS              5
-#define OP1_RST_TS              7
-#define OP1_POWER_DOWN          8
-#define OP1_RESET_RING_MNGMT    11
-#define OP1_RESET               14
-#define OP1_SEL_RST             15
-
-#define CR1_STATUS_4            0x00
-#define CR1_STATUS_5            0x20
-#define CR1_STATUS_6            0x40
-#define CR1_STOP_REG_UPDATE     (1 << 7)
-
-/* Receive frame status bits */
-
-#define RX_RCLD                 (1 << 0)
-#define RX_IA_MATCH             (1 << 1)
-#define RX_NO_AD_MATCH          (1 << 2)
-#define RX_NO_SFD               (1 << 3)
-#define RX_SRT_FRM              (1 << 7)
-#define RX_OVRRUN               (1 << 8)
-#define RX_ALG_ERR              (1 << 10)
-#define RX_CRC_ERR              (1 << 11)
-#define RX_LEN_ERR              (1 << 12)
-#define RX_RCV_OK               (1 << 13)
-#define RX_TYP_LEN              (1 << 15)
-
-/* Transmit status bits */
-
-#define TX_NCOL_MASK            0x0f
-#define TX_FRTL                 (1 << 4)
-#define TX_MAX_COL              (1 << 5)
-#define TX_HRT_BEAT             (1 << 6)
-#define TX_DEFER                (1 << 7)
-#define TX_UND_RUN              (1 << 8)
-#define TX_LOST_CTS             (1 << 9)
-#define TX_LOST_CRS             (1 << 10)
-#define TX_LTCOL                (1 << 11)
-#define TX_OK                   (1 << 13)
-#define TX_COLL                 (1 << 15)
-
-struct i82593_conf_block {
-  u_char fifo_limit : 4,
-         forgnesi   : 1,
-         fifo_32    : 1,
-         d6mod      : 1,
-         throttle_enb : 1;
-  u_char throttle   : 6,
-         cntrxint   : 1,
-         contin     : 1;
-  u_char addr_len   : 3,
-         acloc      : 1,
-         preamb_len : 2,
-         loopback   : 2;
-  u_char lin_prio   : 3,
-         tbofstop   : 1,
-         exp_prio   : 3,
-         bof_met    : 1;
-  u_char            : 4,
-         ifrm_spc   : 4;
-  u_char            : 5,
-         slottim_low : 3;
-  u_char slottim_hi : 3,
-                    : 1,
-         max_retr   : 4;
-  u_char prmisc     : 1,
-         bc_dis     : 1,
-                    : 1,
-         crs_1      : 1,
-         nocrc_ins  : 1,
-         crc_1632   : 1,
-                    : 1,
-         crs_cdt    : 1;
-  u_char cs_filter  : 3,
-         crs_src    : 1,
-         cd_filter  : 3,
-                    : 1;
-  u_char            : 2,
-         min_fr_len : 6;
-  u_char lng_typ    : 1,
-         lng_fld    : 1,
-         rxcrc_xf   : 1,
-         artx       : 1,
-         sarec      : 1,
-         tx_jabber  : 1,        /* why is this called max_len in the manual? */
-         hash_1     : 1,
-         lbpkpol    : 1;
-  u_char            : 6,
-         fdx        : 1,
-                    : 1;
-  u_char dummy_6    : 6,        /* supposed to be ones */
-         mult_ia    : 1,
-         dis_bof    : 1;
-  u_char dummy_1    : 1,        /* supposed to be one */
-         tx_ifs_retrig : 2,
-         mc_all     : 1,
-         rcv_mon    : 2,
-         frag_acpt  : 1,
-         tstrttrs   : 1;
-  u_char fretx      : 1,
-         runt_eop   : 1,
-         hw_sw_pin  : 1,
-         big_endn   : 1,
-         syncrqs    : 1,
-         sttlen     : 1,
-         tx_eop     : 1,
-         rx_eop     : 1;
-  u_char rbuf_size  : 5,
-         rcvstop    : 1,
-                    : 2;
-};
-
-#define I82593_MAX_MULTICAST_ADDRESSES  128     /* Hardware hashed filter */
-
-#endif /* _I82593_H */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 63ab3873c5ed..4f4eea8a6288 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -6,6 +6,7 @@
  * Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
  * Copyright (c) 2005, Devicescape Software, Inc.
  * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
+ * Copyright (c) 2013 - 2014 Intel Mobile Communications GmbH
  *
  * 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
@@ -18,6 +19,7 @@
 #include <linux/types.h>
 #include <linux/if_ether.h>
 #include <asm/byteorder.h>
+#include <asm/unaligned.h>
 
 /*
  * DS bit usage
@@ -165,8 +167,12 @@ static inline u16 ieee80211_sn_sub(u16 sn1, u16 sn2)
 
 #define IEEE80211_MAX_MESH_ID_LEN       32
 
+#define IEEE80211_FIRST_TSPEC_TSID      8
 #define IEEE80211_NUM_TIDS              16
 
+/* number of user priorities 802.11 uses */
+#define IEEE80211_NUM_UPS               8
+
 #define IEEE80211_QOS_CTL_LEN           2
 /* 1d tag mask */
 #define IEEE80211_QOS_CTL_TAG1D_MASK            0x0007
@@ -838,6 +844,16 @@ enum ieee80211_vht_opmode_bits {
 
 #define WLAN_SA_QUERY_TR_ID_LEN 2
 
+/**
+ * struct ieee80211_tpc_report_ie
+ *
+ * This structure refers to "TPC Report element"
+ */
+struct ieee80211_tpc_report_ie {
+        u8 tx_power;
+        u8 link_margin;
+} __packed;
+
 struct ieee80211_mgmt {
         __le16 frame_control;
         __le16 duration;
@@ -973,6 +989,13 @@ struct ieee80211_mgmt {
                                         u8 action_code;
                                         u8 operating_mode;
                                 } __packed vht_opmode_notif;
+                                struct {
+                                        u8 action_code;
+                                        u8 dialog_token;
+                                        u8 tpc_elem_id;
+                                        u8 tpc_elem_length;
+                                        struct ieee80211_tpc_report_ie tpc;
+                                } __packed tpc_report;
                         } u;
                 } __packed action;
         } u;
@@ -1044,6 +1067,12 @@ struct ieee80211_pspoll {
 
 /* TDLS */
 
+/* Channel switch timing */
+struct ieee80211_ch_switch_timing {
+        __le16 switch_time;
+        __le16 switch_timeout;
+} __packed;
+
 /* Link-id information element */
 struct ieee80211_tdls_lnkie {
         u8 ie_type; /* Link Identifier IE */
@@ -1085,6 +1114,15 @@ struct ieee80211_tdls_data {
                         u8 dialog_token;
                         u8 variable[0];
                 } __packed discover_req;
+                struct {
+                        u8 target_channel;
+                        u8 oper_class;
+                        u8 variable[0];
+                } __packed chan_switch_req;
+                struct {
+                        __le16 status_code;
+                        u8 variable[0];
+                } __packed chan_switch_resp;
         } u;
 } __packed;
 
@@ -1252,7 +1290,7 @@ struct ieee80211_ht_cap {
 #define         IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT   2
 
 /*
- * Maximum length of AMPDU that the STA can receive.
+ * Maximum length of AMPDU that the STA can receive in high-throughput (HT).
  * Length = 2 ^ (13 + max_ampdu_length_exp) - 1 (octets)
  */
 enum ieee80211_max_ampdu_length_exp {
@@ -1262,6 +1300,21 @@ enum ieee80211_max_ampdu_length_exp {
         IEEE80211_HT_MAX_AMPDU_64K = 3
 };
 
+/*
+ * Maximum length of AMPDU that the STA can receive in VHT.
+ * Length = 2 ^ (13 + max_ampdu_length_exp) - 1 (octets)
+ */
+enum ieee80211_vht_max_ampdu_length_exp {
+        IEEE80211_VHT_MAX_AMPDU_8K = 0,
+        IEEE80211_VHT_MAX_AMPDU_16K = 1,
+        IEEE80211_VHT_MAX_AMPDU_32K = 2,
+        IEEE80211_VHT_MAX_AMPDU_64K = 3,
+        IEEE80211_VHT_MAX_AMPDU_128K = 4,
+        IEEE80211_VHT_MAX_AMPDU_256K = 5,
+        IEEE80211_VHT_MAX_AMPDU_512K = 6,
+        IEEE80211_VHT_MAX_AMPDU_1024K = 7
+};
+
 #define IEEE80211_HT_MAX_AMPDU_FACTOR 13
 
 /* Minimum MPDU start spacing */
@@ -1806,7 +1859,8 @@ enum ieee80211_eid {
         WLAN_EID_DMG_TSPEC = 146,
         WLAN_EID_DMG_AT = 147,
         WLAN_EID_DMG_CAP = 148,
-        /* 149-150 reserved for Cisco */
+        /* 149 reserved for Cisco */
+        WLAN_EID_CISCO_VENDOR_SPECIFIC = 150,
         WLAN_EID_DMG_OPERATION = 151,
         WLAN_EID_DMG_BSS_PARAM_CHANGE = 152,
         WLAN_EID_DMG_BEAM_REFINEMENT = 153,
@@ -1865,6 +1919,7 @@ enum ieee80211_category {
         WLAN_CATEGORY_DLS = 2,
         WLAN_CATEGORY_BACK = 3,
         WLAN_CATEGORY_PUBLIC = 4,
+        WLAN_CATEGORY_RADIO_MEASUREMENT = 5,
         WLAN_CATEGORY_HT = 7,
         WLAN_CATEGORY_SA_QUERY = 8,
         WLAN_CATEGORY_PROTECTED_DUAL_OF_ACTION = 9,
@@ -1974,6 +2029,16 @@ enum ieee80211_tdls_actioncode {
         WLAN_TDLS_DISCOVERY_REQUEST = 10,
 };
 
+/* Extended Channel Switching capability to be set in the 1st byte of
+ * the @WLAN_EID_EXT_CAPABILITY information element
+ */
+#define WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING    BIT(2)
+
+/* TDLS capabilities in the the 4th byte of @WLAN_EID_EXT_CAPABILITY */
+#define WLAN_EXT_CAPA4_TDLS_BUFFER_STA          BIT(4)
+#define WLAN_EXT_CAPA4_TDLS_PEER_PSM            BIT(5)
+#define WLAN_EXT_CAPA4_TDLS_CHAN_SWITCH         BIT(6)
+
 /* Interworking capabilities are set in 7th bit of 4th byte of the
  * @WLAN_EID_EXT_CAPABILITY information element
  */
@@ -1985,6 +2050,7 @@ enum ieee80211_tdls_actioncode {
  */
 #define WLAN_EXT_CAPA5_TDLS_ENABLED     BIT(5)
 #define WLAN_EXT_CAPA5_TDLS_PROHIBITED  BIT(6)
+#define WLAN_EXT_CAPA5_TDLS_CH_SW_PROHIBITED    BIT(7)
 
 #define WLAN_EXT_CAPA8_OPMODE_NOTIF     BIT(6)
 #define WLAN_EXT_CAPA8_TDLS_WIDE_BW_ENABLED     BIT(7)
@@ -1992,6 +2058,9 @@ enum ieee80211_tdls_actioncode {
 /* TDLS specific payload type in the LLC/SNAP header */
 #define WLAN_TDLS_SNAP_RFTYPE   0x2
 
+/* BSS Coex IE information field bits */
+#define WLAN_BSS_COEX_INFORMATION_REQUEST       BIT(0)
+
 /**
  * enum - mesh synchronization method identifier
  *
@@ -2374,8 +2443,79 @@ static inline bool ieee80211_check_tim(const struct ieee80211_tim_ie *tim,
         return !!(tim->virtual_map[index] & mask);
 }
 
+/**
+ * ieee80211_get_tdls_action - get tdls packet action (or -1, if not tdls packet)
+ * @skb: the skb containing the frame, length will not be checked
+ * @hdr_size: the size of the ieee80211_hdr that starts at skb->data
+ *
+ * This function assumes the frame is a data frame, and that the network header
+ * is in the correct place.
+ */
+static inline int ieee80211_get_tdls_action(struct sk_buff *skb, u32 hdr_size)
+{
+        if (!skb_is_nonlinear(skb) &&
+            skb->len > (skb_network_offset(skb) + 2)) {
+                /* Point to where the indication of TDLS should start */
+                const u8 *tdls_data = skb_network_header(skb) - 2;
+
+                if (get_unaligned_be16(tdls_data) == ETH_P_TDLS &&
+                    tdls_data[2] == WLAN_TDLS_SNAP_RFTYPE &&
+                    tdls_data[3] == WLAN_CATEGORY_TDLS)
+                        return tdls_data[4];
+        }
+
+        return -1;
+}
+
 /* convert time units */
 #define TU_TO_JIFFIES(x)        (usecs_to_jiffies((x) * 1024))
 #define TU_TO_EXP_TIME(x)       (jiffies + TU_TO_JIFFIES(x))
 
+/**
+ * ieee80211_action_contains_tpc - checks if the frame contains TPC element
+ * @skb: the skb containing the frame, length will be checked
+ *
+ * This function checks if it's either TPC report action frame or Link
+ * Measurement report action frame as defined in IEEE Std. 802.11-2012 8.5.2.5
+ * and 8.5.7.5 accordingly.
+ */
+static inline bool ieee80211_action_contains_tpc(struct sk_buff *skb)
+{
+        struct ieee80211_mgmt *mgmt = (void *)skb->data;
+
+        if (!ieee80211_is_action(mgmt->frame_control))
+                return false;
+
+        if (skb->len < IEEE80211_MIN_ACTION_SIZE +
+                       sizeof(mgmt->u.action.u.tpc_report))
+                return false;
+
+        /*
+         * TPC report - check that:
+         * category = 0 (Spectrum Management) or 5 (Radio Measurement)
+         * spectrum management action = 3 (TPC/Link Measurement report)
+         * TPC report EID = 35
+         * TPC report element length = 2
+         *
+         * The spectrum management's tpc_report struct is used here both for
+         * parsing tpc_report and radio measurement's link measurement report
+         * frame, since the relevant part is identical in both frames.
+         */
+        if (mgmt->u.action.category != WLAN_CATEGORY_SPECTRUM_MGMT &&
+            mgmt->u.action.category != WLAN_CATEGORY_RADIO_MEASUREMENT)
+                return false;
+
+        /* both spectrum mgmt and link measurement have same action code */
+        if (mgmt->u.action.u.tpc_report.action_code !=
+            WLAN_ACTION_SPCT_TPC_RPRT)
+                return false;
+
+        if (mgmt->u.action.u.tpc_report.tpc_elem_id != WLAN_EID_TPC_REPORT ||
+            mgmt->u.action.u.tpc_report.tpc_elem_length !=
+            sizeof(struct ieee80211_tpc_report_ie))
+                return false;
+
+        return true;
+}
+
 #endif /* LINUX_IEEE80211_H */
diff --git a/include/linux/ieee802154.h b/include/linux/ieee802154.h
new file mode 100644
index 000000000000..6e82d888287c
--- /dev/null
+++ b/include/linux/ieee802154.h
@@ -0,0 +1,242 @@
+/*
+ * IEEE802.15.4-2003 specification
+ *
+ * Copyright (C) 2007, 2008 Siemens AG
+ *
+ * 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.
+ *
+ * Written by:
+ * Pavel Smolenskiy <pavel.smolenskiy@gmail.com>
+ * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
+ * Maxim Osipov <maxim.osipov@siemens.com>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ * Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
+ */
+
+#ifndef LINUX_IEEE802154_H
+#define LINUX_IEEE802154_H
+
+#include <linux/types.h>
+#include <linux/random.h>
+#include <asm/byteorder.h>
+
+#define IEEE802154_MTU                  127
+#define IEEE802154_MIN_PSDU_LEN         5
+
+#define IEEE802154_PAN_ID_BROADCAST     0xffff
+#define IEEE802154_ADDR_SHORT_BROADCAST 0xffff
+#define IEEE802154_ADDR_SHORT_UNSPEC    0xfffe
+
+#define IEEE802154_EXTENDED_ADDR_LEN    8
+
+#define IEEE802154_LIFS_PERIOD          40
+#define IEEE802154_SIFS_PERIOD          12
+
+#define IEEE802154_MAX_CHANNEL          26
+#define IEEE802154_MAX_PAGE             31
+
+#define IEEE802154_FC_TYPE_BEACON       0x0     /* Frame is beacon */
+#define IEEE802154_FC_TYPE_DATA         0x1     /* Frame is data */
+#define IEEE802154_FC_TYPE_ACK          0x2     /* Frame is acknowledgment */
+#define IEEE802154_FC_TYPE_MAC_CMD      0x3     /* Frame is MAC command */
+
+#define IEEE802154_FC_TYPE_SHIFT                0
+#define IEEE802154_FC_TYPE_MASK         ((1 << 3) - 1)
+#define IEEE802154_FC_TYPE(x)           ((x & IEEE802154_FC_TYPE_MASK) >> IEEE802154_FC_TYPE_SHIFT)
+#define IEEE802154_FC_SET_TYPE(v, x)    do {    \
+        v = (((v) & ~IEEE802154_FC_TYPE_MASK) | \
+            (((x) << IEEE802154_FC_TYPE_SHIFT) & IEEE802154_FC_TYPE_MASK)); \
+        } while (0)
+
+#define IEEE802154_FC_SECEN_SHIFT       3
+#define IEEE802154_FC_SECEN             (1 << IEEE802154_FC_SECEN_SHIFT)
+#define IEEE802154_FC_FRPEND_SHIFT      4
+#define IEEE802154_FC_FRPEND            (1 << IEEE802154_FC_FRPEND_SHIFT)
+#define IEEE802154_FC_ACK_REQ_SHIFT     5
+#define IEEE802154_FC_ACK_REQ           (1 << IEEE802154_FC_ACK_REQ_SHIFT)
+#define IEEE802154_FC_INTRA_PAN_SHIFT   6
+#define IEEE802154_FC_INTRA_PAN         (1 << IEEE802154_FC_INTRA_PAN_SHIFT)
+
+#define IEEE802154_FC_SAMODE_SHIFT      14
+#define IEEE802154_FC_SAMODE_MASK       (3 << IEEE802154_FC_SAMODE_SHIFT)
+#define IEEE802154_FC_DAMODE_SHIFT      10
+#define IEEE802154_FC_DAMODE_MASK       (3 << IEEE802154_FC_DAMODE_SHIFT)
+
+#define IEEE802154_FC_VERSION_SHIFT     12
+#define IEEE802154_FC_VERSION_MASK      (3 << IEEE802154_FC_VERSION_SHIFT)
+#define IEEE802154_FC_VERSION(x)        ((x & IEEE802154_FC_VERSION_MASK) >> IEEE802154_FC_VERSION_SHIFT)
+
+#define IEEE802154_FC_SAMODE(x)         \
+        (((x) & IEEE802154_FC_SAMODE_MASK) >> IEEE802154_FC_SAMODE_SHIFT)
+
+#define IEEE802154_FC_DAMODE(x)         \
+        (((x) & IEEE802154_FC_DAMODE_MASK) >> IEEE802154_FC_DAMODE_SHIFT)
+
+#define IEEE802154_SCF_SECLEVEL_MASK            7
+#define IEEE802154_SCF_SECLEVEL_SHIFT           0
+#define IEEE802154_SCF_SECLEVEL(x)              (x & IEEE802154_SCF_SECLEVEL_MASK)
+#define IEEE802154_SCF_KEY_ID_MODE_SHIFT        3
+#define IEEE802154_SCF_KEY_ID_MODE_MASK         (3 << IEEE802154_SCF_KEY_ID_MODE_SHIFT)
+#define IEEE802154_SCF_KEY_ID_MODE(x)           \
+        ((x & IEEE802154_SCF_KEY_ID_MODE_MASK) >> IEEE802154_SCF_KEY_ID_MODE_SHIFT)
+
+#define IEEE802154_SCF_KEY_IMPLICIT             0
+#define IEEE802154_SCF_KEY_INDEX                1
+#define IEEE802154_SCF_KEY_SHORT_INDEX          2
+#define IEEE802154_SCF_KEY_HW_INDEX             3
+
+#define IEEE802154_SCF_SECLEVEL_NONE            0
+#define IEEE802154_SCF_SECLEVEL_MIC32           1
+#define IEEE802154_SCF_SECLEVEL_MIC64           2
+#define IEEE802154_SCF_SECLEVEL_MIC128          3
+#define IEEE802154_SCF_SECLEVEL_ENC             4
+#define IEEE802154_SCF_SECLEVEL_ENC_MIC32       5
+#define IEEE802154_SCF_SECLEVEL_ENC_MIC64       6
+#define IEEE802154_SCF_SECLEVEL_ENC_MIC128      7
+
+/* MAC footer size */
+#define IEEE802154_MFR_SIZE     2 /* 2 octets */
+
+/* MAC's Command Frames Identifiers */
+#define IEEE802154_CMD_ASSOCIATION_REQ          0x01
+#define IEEE802154_CMD_ASSOCIATION_RESP         0x02
+#define IEEE802154_CMD_DISASSOCIATION_NOTIFY    0x03
+#define IEEE802154_CMD_DATA_REQ                 0x04
+#define IEEE802154_CMD_PANID_CONFLICT_NOTIFY    0x05
+#define IEEE802154_CMD_ORPHAN_NOTIFY            0x06
+#define IEEE802154_CMD_BEACON_REQ               0x07
+#define IEEE802154_CMD_COORD_REALIGN_NOTIFY     0x08
+#define IEEE802154_CMD_GTS_REQ                  0x09
+
+/*
+ * The return values of MAC operations
+ */
+enum {
+        /*
+         * The requested operation was completed successfully.
+         * For a transmission request, this value indicates
+         * a successful transmission.
+         */
+        IEEE802154_SUCCESS = 0x0,
+
+        /* The beacon was lost following a synchronization request. */
+        IEEE802154_BEACON_LOSS = 0xe0,
+        /*
+         * A transmission could not take place due to activity on the
+         * channel, i.e., the CSMA-CA mechanism has failed.
+         */
+        IEEE802154_CHNL_ACCESS_FAIL = 0xe1,
+        /* The GTS request has been denied by the PAN coordinator. */
+        IEEE802154_DENINED = 0xe2,
+        /* The attempt to disable the transceiver has failed. */
+        IEEE802154_DISABLE_TRX_FAIL = 0xe3,
+        /*
+         * The received frame induces a failed security check according to
+         * the security suite.
+         */
+        IEEE802154_FAILED_SECURITY_CHECK = 0xe4,
+        /*
+         * The frame resulting from secure processing has a length that is
+         * greater than aMACMaxFrameSize.
+         */
+        IEEE802154_FRAME_TOO_LONG = 0xe5,
+        /*
+         * The requested GTS transmission failed because the specified GTS
+         * either did not have a transmit GTS direction or was not defined.
+         */
+        IEEE802154_INVALID_GTS = 0xe6,
+        /*
+         * A request to purge an MSDU from the transaction queue was made using
+         * an MSDU handle that was not found in the transaction table.
+         */
+        IEEE802154_INVALID_HANDLE = 0xe7,
+        /* A parameter in the primitive is out of the valid range.*/
+        IEEE802154_INVALID_PARAMETER = 0xe8,
+        /* No acknowledgment was received after aMaxFrameRetries. */
+        IEEE802154_NO_ACK = 0xe9,
+        /* A scan operation failed to find any network beacons.*/
+        IEEE802154_NO_BEACON = 0xea,
+        /* No response data were available following a request. */
+        IEEE802154_NO_DATA = 0xeb,
+        /* The operation failed because a short address was not allocated. */
+        IEEE802154_NO_SHORT_ADDRESS = 0xec,
+        /*
+         * A receiver enable request was unsuccessful because it could not be
+         * completed within the CAP.
+         */
+        IEEE802154_OUT_OF_CAP = 0xed,
+        /*
+         * A PAN identifier conflict has been detected and communicated to the
+         * PAN coordinator.
+         */
+        IEEE802154_PANID_CONFLICT = 0xee,
+        /* A coordinator realignment command has been received. */
+        IEEE802154_REALIGMENT = 0xef,
+        /* The transaction has expired and its information discarded. */
+        IEEE802154_TRANSACTION_EXPIRED = 0xf0,
+        /* There is no capacity to store the transaction. */
+        IEEE802154_TRANSACTION_OVERFLOW = 0xf1,
+        /*
+         * The transceiver was in the transmitter enabled state when the
+         * receiver was requested to be enabled.
+         */
+        IEEE802154_TX_ACTIVE = 0xf2,
+        /* The appropriate key is not available in the ACL. */
+        IEEE802154_UNAVAILABLE_KEY = 0xf3,
+        /*
+         * A SET/GET request was issued with the identifier of a PIB attribute
+         * that is not supported.
+         */
+        IEEE802154_UNSUPPORTED_ATTR = 0xf4,
+        /*
+         * A request to perform a scan operation failed because the MLME was
+         * in the process of performing a previously initiated scan operation.
+         */
+        IEEE802154_SCAN_IN_PROGRESS = 0xfc,
+};
+
+/**
+ * ieee802154_is_valid_psdu_len - check if psdu len is valid
+ * @len: psdu len with (MHR + payload + MFR)
+ */
+static inline bool ieee802154_is_valid_psdu_len(const u8 len)
+{
+        return (len >= IEEE802154_MIN_PSDU_LEN && len <= IEEE802154_MTU);
+}
+
+/**
+ * ieee802154_is_valid_psdu_len - check if extended addr is valid
+ * @addr: extended addr to check
+ */
+static inline bool ieee802154_is_valid_extended_addr(const __le64 addr)
+{
+        /* These EUI-64 addresses are reserved by IEEE. 0xffffffffffffffff
+         * is used internally as extended to short address broadcast mapping.
+         * This is currently a workaround because neighbor discovery can't
+         * deal with short addresses types right now.
+         */
+        return ((addr != cpu_to_le64(0x0000000000000000ULL)) &&
+                (addr != cpu_to_le64(0xffffffffffffffffULL)));
+}
+
+/**
+ * ieee802154_random_extended_addr - generates a random extended address
+ * @addr: extended addr pointer to place the random address
+ */
+static inline void ieee802154_random_extended_addr(__le64 *addr)
+{
+        get_random_bytes(addr, IEEE802154_EXTENDED_ADDR_LEN);
+
+        /* toggle some bit if we hit an invalid extended addr */
+        if (!ieee802154_is_valid_extended_addr(*addr))
+                ((u8 *)addr)[IEEE802154_EXTENDED_ADDR_LEN - 1] ^= 0x01;
+}
+
+#endif /* LINUX_IEEE802154_H */
diff --git a/include/linux/if_bridge.h b/include/linux/if_bridge.h
index 808dcb8cc04f..0a8ce762a47f 100644
--- a/include/linux/if_bridge.h
+++ b/include/linux/if_bridge.h
@@ -15,6 +15,7 @@
 
 #include <linux/netdevice.h>
 #include <uapi/linux/if_bridge.h>
+#include <linux/bitops.h>
 
 struct br_ip {
         union {
@@ -32,11 +33,41 @@ struct br_ip_list {
         struct br_ip addr;
 };
 
+#define BR_HAIRPIN_MODE         BIT(0)
+#define BR_BPDU_GUARD           BIT(1)
+#define BR_ROOT_BLOCK           BIT(2)
+#define BR_MULTICAST_FAST_LEAVE BIT(3)
+#define BR_ADMIN_COST           BIT(4)
+#define BR_LEARNING             BIT(5)
+#define BR_FLOOD                BIT(6)
+#define BR_AUTO_MASK            (BR_FLOOD | BR_LEARNING)
+#define BR_PROMISC              BIT(7)
+#define BR_PROXYARP             BIT(8)
+#define BR_LEARNING_SYNC        BIT(9)
+
 extern void brioctl_set(int (*ioctl_hook)(struct net *, unsigned int, void __user *));
 
 typedef int br_should_route_hook_t(struct sk_buff *skb);
 extern br_should_route_hook_t __rcu *br_should_route_hook;
 
+#if IS_ENABLED(CONFIG_BRIDGE)
+int br_fdb_external_learn_add(struct net_device *dev,
+                              const unsigned char *addr, u16 vid);
+int br_fdb_external_learn_del(struct net_device *dev,
+                              const unsigned char *addr, u16 vid);
+#else
+static inline int br_fdb_external_learn_add(struct net_device *dev,
+                                            const unsigned char *addr, u16 vid)
+{
+        return 0;
+}
+static inline int br_fdb_external_learn_del(struct net_device *dev,
+                                            const unsigned char *addr, u16 vid)
+{
+        return 0;
+}
+#endif
+
 #if IS_ENABLED(CONFIG_BRIDGE) && IS_ENABLED(CONFIG_BRIDGE_IGMP_SNOOPING)
 int br_multicast_list_adjacent(struct net_device *dev,
                                struct list_head *br_ip_list);
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
index 6b2c7cf352a5..6f6929ea8a0c 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -60,6 +60,7 @@ struct macvlan_dev {
 #ifdef CONFIG_NET_POLL_CONTROLLER
         struct netpoll          *netpoll;
 #endif
+        unsigned int            macaddr_count;
 };
 
 static inline void macvlan_count_rx(const struct macvlan_dev *vlan,
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index d69f0577a319..515a35e2a48a 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -282,28 +282,24 @@ static inline bool vlan_hw_offload_capable(netdev_features_t features,
 }
 
 /**
- * vlan_insert_tag - regular VLAN tag inserting
+ * __vlan_insert_tag - regular VLAN tag inserting
  * @skb: skbuff to tag
  * @vlan_proto: VLAN encapsulation protocol
  * @vlan_tci: VLAN TCI to insert
  *
  * Inserts the VLAN tag into @skb as part of the payload
- * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
- *
- * Following the skb_unshare() example, in case of error, the calling function
- * doesn't have to worry about freeing the original skb.
+ * Returns error if skb_cow_head failes.
  *
  * Does not change skb->protocol so this function can be used during receive.
  */
-static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
-                                              __be16 vlan_proto, u16 vlan_tci)
+static inline int __vlan_insert_tag(struct sk_buff *skb,
+                                    __be16 vlan_proto, u16 vlan_tci)
 {
         struct vlan_ethhdr *veth;
 
-        if (skb_cow_head(skb, VLAN_HLEN) < 0) {
-                dev_kfree_skb_any(skb);
-                return NULL;
-        }
+        if (skb_cow_head(skb, VLAN_HLEN) < 0)
+                return -ENOMEM;
+
         veth = (struct vlan_ethhdr *)skb_push(skb, VLAN_HLEN);
 
         /* Move the mac addresses to the beginning of the new header. */
@@ -316,12 +312,40 @@ static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
         /* now, the TCI */
         veth->h_vlan_TCI = htons(vlan_tci);
 
+        return 0;
+}
+
+/**
+ * vlan_insert_tag - regular VLAN tag inserting
+ * @skb: skbuff to tag
+ * @vlan_proto: VLAN encapsulation protocol
+ * @vlan_tci: VLAN TCI to insert
+ *
+ * Inserts the VLAN tag into @skb as part of the payload
+ * Returns a VLAN tagged skb. If a new skb is created, @skb is freed.
+ *
+ * Following the skb_unshare() example, in case of error, the calling function
+ * doesn't have to worry about freeing the original skb.
+ *
+ * Does not change skb->protocol so this function can be used during receive.
+ */
+static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
+                                              __be16 vlan_proto, u16 vlan_tci)
+{
+        int err;
+
+        err = __vlan_insert_tag(skb, vlan_proto, vlan_tci);
+        if (err) {
+                dev_kfree_skb_any(skb);
+                return NULL;
+        }
         return skb;
 }
 
 /**
- * __vlan_put_tag - regular VLAN tag inserting
+ * vlan_insert_tag_set_proto - regular VLAN tag inserting
  * @skb: skbuff to tag
+ * @vlan_proto: VLAN encapsulation protocol
  * @vlan_tci: VLAN TCI to insert
  *
  * Inserts the VLAN tag into @skb as part of the payload
@@ -330,8 +354,9 @@ static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
  * Following the skb_unshare() example, in case of error, the calling function
  * doesn't have to worry about freeing the original skb.
  */
-static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb,
-                                             __be16 vlan_proto, u16 vlan_tci)
+static inline struct sk_buff *vlan_insert_tag_set_proto(struct sk_buff *skb,
+                                                        __be16 vlan_proto,
+                                                        u16 vlan_tci)
 {
         skb = vlan_insert_tag(skb, vlan_proto, vlan_tci);
         if (skb)
@@ -339,39 +364,53 @@ static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb,
         return skb;
 }
 
-/**
- * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
+/*
+ * __vlan_hwaccel_push_inside - pushes vlan tag to the payload
  * @skb: skbuff to tag
- * @vlan_proto: VLAN encapsulation protocol
- * @vlan_tci: VLAN TCI to insert
  *
- * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
+ * Pushes the VLAN tag from @skb->vlan_tci inside to the payload.
+ *
+ * Following the skb_unshare() example, in case of error, the calling function
+ * doesn't have to worry about freeing the original skb.
  */
-static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb,
-                                                     __be16 vlan_proto,
-                                                     u16 vlan_tci)
+static inline struct sk_buff *__vlan_hwaccel_push_inside(struct sk_buff *skb)
 {
-        skb->vlan_proto = vlan_proto;
-        skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci;
+        skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto,
+                                        vlan_tx_tag_get(skb));
+        if (likely(skb))
+                skb->vlan_tci = 0;
+        return skb;
+}
+/*
+ * vlan_hwaccel_push_inside - pushes vlan tag to the payload
+ * @skb: skbuff to tag
+ *
+ * Checks is tag is present in @skb->vlan_tci and if it is, it pushes the
+ * VLAN tag from @skb->vlan_tci inside to the payload.
+ *
+ * Following the skb_unshare() example, in case of error, the calling function
+ * doesn't have to worry about freeing the original skb.
+ */
+static inline struct sk_buff *vlan_hwaccel_push_inside(struct sk_buff *skb)
+{
+        if (vlan_tx_tag_present(skb))
+                skb = __vlan_hwaccel_push_inside(skb);
         return skb;
 }
 
 /**
- * vlan_put_tag - inserts VLAN tag according to device features
+ * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
  * @skb: skbuff to tag
+ * @vlan_proto: VLAN encapsulation protocol
  * @vlan_tci: VLAN TCI to insert
  *
- * Assumes skb->dev is the target that will xmit this frame.
- * Returns a VLAN tagged skb.
+ * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
  */
-static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb,
-                                           __be16 vlan_proto, u16 vlan_tci)
+static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb,
+                                          __be16 vlan_proto, u16 vlan_tci)
 {
-        if (vlan_hw_offload_capable(skb->dev->features, vlan_proto)) {
-                return __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci);
-        } else {
-                return __vlan_put_tag(skb, vlan_proto, vlan_tci);
-        }
+        skb->vlan_proto = vlan_proto;
+        skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci;
 }
 
 /**
diff --git a/include/linux/igmp.h b/include/linux/igmp.h
index f47550d75f85..2c677afeea47 100644
--- a/include/linux/igmp.h
+++ b/include/linux/igmp.h
@@ -39,6 +39,7 @@ static inline struct igmpv3_query *
 
 extern int sysctl_igmp_max_memberships;
 extern int sysctl_igmp_max_msf;
+extern int sysctl_igmp_qrv;
 
 struct ip_sf_socklist {
         unsigned int            sl_max;
diff --git a/include/linux/iio/common/st_sensors.h b/include/linux/iio/common/st_sensors.h
index d8257ab60bac..2c476acb87d9 100644
--- a/include/linux/iio/common/st_sensors.h
+++ b/include/linux/iio/common/st_sensors.h
@@ -164,7 +164,7 @@ struct st_sensor_transfer_function {
 };
 
 /**
- * struct st_sensors - ST sensors list
+ * struct st_sensor_settings - ST specific sensor settings
  * @wai: Contents of WhoAmI register.
  * @sensors_supported: List of supported sensors by struct itself.
  * @ch: IIO channels for the sensor.
@@ -177,7 +177,7 @@ struct st_sensor_transfer_function {
  * @multi_read_bit: Use or not particular bit for [I2C/SPI] multi-read.
  * @bootime: samples to discard when sensor passing from power-down to power-up.
  */
-struct st_sensors {
+struct st_sensor_settings {
         u8 wai;
         char sensors_supported[ST_SENSORS_MAX_4WAI][ST_SENSORS_MAX_NAME];
         struct iio_chan_spec *ch;
@@ -196,7 +196,7 @@ struct st_sensors {
  * struct st_sensor_data - ST sensor device status
  * @dev: Pointer to instance of struct device (I2C or SPI).
  * @trig: The trigger in use by the core driver.
- * @sensor: Pointer to the current sensor struct in use.
+ * @sensor_settings: Pointer to the specific sensor settings in use.
  * @current_fullscale: Maximum range of measure by the sensor.
  * @vdd: Pointer to sensor's Vdd power supply
  * @vdd_io: Pointer to sensor's Vdd-IO power supply
@@ -213,7 +213,7 @@ struct st_sensors {
 struct st_sensor_data {
         struct device *dev;
         struct iio_trigger *trig;
-        struct st_sensors *sensor;
+        struct st_sensor_settings *sensor_settings;
         struct st_sensor_fullscale_avl *current_fullscale;
         struct regulator *vdd;
         struct regulator *vdd_io;
@@ -279,7 +279,7 @@ int st_sensors_read_info_raw(struct iio_dev *indio_dev,
                                 struct iio_chan_spec const *ch, int *val);
 
 int st_sensors_check_device_support(struct iio_dev *indio_dev,
-                        int num_sensors_list, const struct st_sensors *sensors);
+        int num_sensors_list, const struct st_sensor_settings *sensor_settings);
 
 ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
                                 struct device_attribute *attr, char *buf);
diff --git a/include/linux/iio/events.h b/include/linux/iio/events.h
index 8bbd7bc1043d..03fa332ad2a8 100644
--- a/include/linux/iio/events.h
+++ b/include/linux/iio/events.h
@@ -72,7 +72,7 @@ struct iio_event_data {
 
 #define IIO_EVENT_CODE_EXTRACT_TYPE(mask) ((mask >> 56) & 0xFF)
 
-#define IIO_EVENT_CODE_EXTRACT_DIR(mask) ((mask >> 48) & 0xCF)
+#define IIO_EVENT_CODE_EXTRACT_DIR(mask) ((mask >> 48) & 0x7F)
 
 #define IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(mask) ((mask >> 32) & 0xFF)
 
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index 15dc6bc2bdd2..3642ce7ef512 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -13,6 +13,7 @@
 #include <linux/device.h>
 #include <linux/cdev.h>
 #include <linux/iio/types.h>
+#include <linux/of.h>
 /* IIO TODO LIST */
 /*
  * Provide means of adjusting timer accuracy.
@@ -326,6 +327,11 @@ struct iio_dev;
  * @update_scan_mode:   function to configure device and scan buffer when
  *                      channels have changed
  * @debugfs_reg_access: function to read or write register value of device
+ * @of_xlate:           function pointer to obtain channel specifier index.
+ *                      When #iio-cells is greater than '0', the driver could
+ *                      provide a custom of_xlate function that reads the
+ *                      *args* and returns the appropriate index in registered
+ *                      IIO channels array.
  **/
 struct iio_info {
         struct module                   *driver_module;
@@ -385,6 +391,8 @@ struct iio_info {
         int (*debugfs_reg_access)(struct iio_dev *indio_dev,
                                   unsigned reg, unsigned writeval,
                                   unsigned *readval);
+        int (*of_xlate)(struct iio_dev *indio_dev,
+                        const struct of_phandle_args *iiospec);
 };
 
 /**
diff --git a/include/linux/ima.h b/include/linux/ima.h
index 7cf5e9b32550..120ccc53fcb7 100644
--- a/include/linux/ima.h
+++ b/include/linux/ima.h
@@ -15,7 +15,7 @@ struct linux_binprm;
 
 #ifdef CONFIG_IMA
 extern int ima_bprm_check(struct linux_binprm *bprm);
-extern int ima_file_check(struct file *file, int mask);
+extern int ima_file_check(struct file *file, int mask, int opened);
 extern void ima_file_free(struct file *file);
 extern int ima_file_mmap(struct file *file, unsigned long prot);
 extern int ima_module_check(struct file *file);
@@ -27,7 +27,7 @@ static inline int ima_bprm_check(struct linux_binprm *bprm)
         return 0;
 }
 
-static inline int ima_file_check(struct file *file, int mask)
+static inline int ima_file_check(struct file *file, int mask, int opened)
 {
         return 0;
 }
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 0068708161ff..0a21fbefdfbe 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -242,7 +242,7 @@ static inline void in_dev_put(struct in_device *idev)
 static __inline__ __be32 inet_make_mask(int logmask)
 {
         if (logmask)
-                return htonl(~((1<<(32-logmask))-1));
+                return htonl(~((1U<<(32-logmask))-1));
         return 0;
 }
 
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 2bb4c4f3531a..3037fc085e8e 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -102,7 +102,7 @@ extern struct group_info init_groups;
 #define INIT_IDS
 #endif
 
-#ifdef CONFIG_TREE_PREEMPT_RCU
+#ifdef CONFIG_PREEMPT_RCU
 #define INIT_TASK_RCU_TREE_PREEMPT()                                    \
         .rcu_blocked_node = NULL,
 #else
@@ -111,12 +111,21 @@ extern struct group_info init_groups;
 #ifdef CONFIG_PREEMPT_RCU
 #define INIT_TASK_RCU_PREEMPT(tsk)                                      \
         .rcu_read_lock_nesting = 0,                                     \
-        .rcu_read_unlock_special = 0,                                   \
+        .rcu_read_unlock_special.s = 0,                                 \
         .rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry),           \
         INIT_TASK_RCU_TREE_PREEMPT()
 #else
 #define INIT_TASK_RCU_PREEMPT(tsk)
 #endif
+#ifdef CONFIG_TASKS_RCU
+#define INIT_TASK_RCU_TASKS(tsk)                                        \
+        .rcu_tasks_holdout = false,                                     \
+        .rcu_tasks_holdout_list =                                       \
+                LIST_HEAD_INIT(tsk.rcu_tasks_holdout_list),             \
+        .rcu_tasks_idle_cpu = -1,
+#else
+#define INIT_TASK_RCU_TASKS(tsk)
+#endif
 
 extern struct cred init_cred;
 
@@ -157,6 +166,15 @@ extern struct task_group root_task_group;
 # define INIT_RT_MUTEXES(tsk)
 #endif
 
+#ifdef CONFIG_NUMA_BALANCING
+# define INIT_NUMA_BALANCING(tsk)                                       \
+        .numa_preferred_nid = -1,                                       \
+        .numa_group = NULL,                                             \
+        .numa_faults = NULL,
+#else
+# define INIT_NUMA_BALANCING(tsk)
+#endif
+
 /*
  *  INIT_TASK is used to set up the first task table, touch at
  * your own risk!. Base=0, limit=0x1fffff (=2MB)
@@ -224,9 +242,11 @@ extern struct task_group root_task_group;
         INIT_FTRACE_GRAPH                                               \
         INIT_TRACE_RECURSION                                            \
         INIT_TASK_RCU_PREEMPT(tsk)                                      \
+        INIT_TASK_RCU_TASKS(tsk)                                        \
         INIT_CPUSET_SEQ(tsk)                                            \
         INIT_RT_MUTEXES(tsk)                                            \
         INIT_VTIME(tsk)                                                 \
+        INIT_NUMA_BALANCING(tsk)                                        \
 }
 
 
diff --git a/include/linux/integrity.h b/include/linux/integrity.h
index 83222cebd47b..c2d6082a1a4c 100644
--- a/include/linux/integrity.h
+++ b/include/linux/integrity.h
@@ -24,6 +24,7 @@ enum integrity_status {
 #ifdef CONFIG_INTEGRITY
 extern struct integrity_iint_cache *integrity_inode_get(struct inode *inode);
 extern void integrity_inode_free(struct inode *inode);
+extern void __init integrity_load_keys(void);
 
 #else
 static inline struct integrity_iint_cache *
@@ -36,5 +37,10 @@ static inline void integrity_inode_free(struct inode *inode)
 {
         return;
 }
+
+static inline void integrity_load_keys(void)
+{
+}
 #endif /* CONFIG_INTEGRITY */
+
 #endif /* _LINUX_INTEGRITY_H */
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 698ad053d064..d9b05b5bf8c7 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -193,11 +193,6 @@ 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);
 extern void resume_device_irqs(void);
-#ifdef CONFIG_PM_SLEEP
-extern int check_wakeup_irqs(void);
-#else
-static inline int check_wakeup_irqs(void) { return 0; }
-#endif
 
 /**
  * struct irq_affinity_notify - context for notification of IRQ affinity changes
@@ -561,12 +556,6 @@ static inline void tasklet_enable(struct tasklet_struct *t)
         atomic_dec(&t->count);
 }
 
-static inline void tasklet_hi_enable(struct tasklet_struct *t)
-{
-        smp_mb__before_atomic();
-        atomic_dec(&t->count);
-}
-
 extern void tasklet_kill(struct tasklet_struct *t);
 extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
 extern void tasklet_init(struct tasklet_struct *t,
diff --git a/include/linux/io.h b/include/linux/io.h
index d5fc9b8d8b03..fa02e55e5a2e 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -61,9 +61,9 @@ static inline void devm_ioport_unmap(struct device *dev, void __iomem *addr)
 #define IOMEM_ERR_PTR(err) (__force void __iomem *)ERR_PTR(err)
 
 void __iomem *devm_ioremap(struct device *dev, resource_size_t offset,
-                            unsigned long size);
+                           resource_size_t size);
 void __iomem *devm_ioremap_nocache(struct device *dev, resource_size_t offset,
-                                    unsigned long size);
+                                   resource_size_t size);
 void devm_iounmap(struct device *dev, void __iomem *addr);
 int check_signature(const volatile void __iomem *io_addr,
                         const unsigned char *signature, int length);
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 20f9a527922a..38daa453f2e5 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -21,13 +21,15 @@
 
 #include <linux/errno.h>
 #include <linux/err.h>
+#include <linux/of.h>
 #include <linux/types.h>
+#include <linux/scatterlist.h>
 #include <trace/events/iommu.h>
 
 #define IOMMU_READ      (1 << 0)
 #define IOMMU_WRITE     (1 << 1)
 #define IOMMU_CACHE     (1 << 2) /* DMA cache coherency */
-#define IOMMU_EXEC      (1 << 3)
+#define IOMMU_NOEXEC    (1 << 3)
 
 struct iommu_ops;
 struct iommu_group;
@@ -57,8 +59,12 @@ struct iommu_domain {
         struct iommu_domain_geometry geometry;
 };
 
-#define IOMMU_CAP_CACHE_COHERENCY       0x1
-#define IOMMU_CAP_INTR_REMAP            0x2     /* isolates device intrs */
+enum iommu_cap {
+        IOMMU_CAP_CACHE_COHERENCY,      /* IOMMU can enforce cache coherent DMA
+                                           transactions */
+        IOMMU_CAP_INTR_REMAP,           /* IOMMU supports interrupt isolation */
+        IOMMU_CAP_NOEXEC,               /* IOMMU_NOEXEC flag */
+};
 
 /*
  * Following constraints are specifc to FSL_PAMUV1:
@@ -80,6 +86,7 @@ enum iommu_attr {
         DOMAIN_ATTR_FSL_PAMU_STASH,
         DOMAIN_ATTR_FSL_PAMU_ENABLE,
         DOMAIN_ATTR_FSL_PAMUV1,
+        DOMAIN_ATTR_NESTING,    /* two stages of translation */
         DOMAIN_ATTR_MAX,
 };
 
@@ -93,15 +100,19 @@ enum iommu_attr {
  * @detach_dev: detach device from an iommu domain
  * @map: map a physically contiguous memory region to an iommu domain
  * @unmap: unmap a physically contiguous memory region from an iommu domain
+ * @map_sg: map a scatter-gather list of physically contiguous memory chunks
+ * to an iommu domain
  * @iova_to_phys: translate iova to physical address
- * @domain_has_cap: domain capabilities query
  * @add_device: add device to iommu grouping
  * @remove_device: remove device from iommu grouping
  * @domain_get_attr: Query domain attributes
  * @domain_set_attr: Change domain attributes
+ * @of_xlate: add OF master IDs to iommu grouping
  * @pgsize_bitmap: bitmap of supported page sizes
+ * @priv: per-instance data private to the iommu driver
  */
 struct iommu_ops {
+        bool (*capable)(enum iommu_cap);
         int (*domain_init)(struct iommu_domain *domain);
         void (*domain_destroy)(struct iommu_domain *domain);
         int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
@@ -110,9 +121,9 @@ struct iommu_ops {
                    phys_addr_t paddr, size_t size, int prot);
         size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
                      size_t size);
+        size_t (*map_sg)(struct iommu_domain *domain, unsigned long iova,
+                         struct scatterlist *sg, unsigned int nents, int prot);
         phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova);
-        int (*domain_has_cap)(struct iommu_domain *domain,
-                              unsigned long cap);
         int (*add_device)(struct device *dev);
         void (*remove_device)(struct device *dev);
         int (*device_group)(struct device *dev, unsigned int *groupid);
@@ -130,7 +141,12 @@ struct iommu_ops {
         /* Get the numer of window per domain */
         u32 (*domain_get_windows)(struct iommu_domain *domain);
 
+#ifdef CONFIG_OF_IOMMU
+        int (*of_xlate)(struct device *dev, struct of_phandle_args *args);
+#endif
+
         unsigned long pgsize_bitmap;
+        void *priv;
 };
 
 #define IOMMU_GROUP_NOTIFY_ADD_DEVICE           1 /* Device added */
@@ -142,6 +158,7 @@ struct iommu_ops {
 
 extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
 extern bool iommu_present(struct bus_type *bus);
+extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap);
 extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
 extern struct iommu_group *iommu_group_get_by_id(int id);
 extern void iommu_domain_free(struct iommu_domain *domain);
@@ -153,9 +170,10 @@ extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
                      phys_addr_t paddr, size_t size, int prot);
 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
                        size_t size);
+extern size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
+                                struct scatterlist *sg,unsigned int nents,
+                                int prot);
 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
-extern int iommu_domain_has_cap(struct iommu_domain *domain,
-                                unsigned long cap);
 extern void iommu_set_fault_handler(struct iommu_domain *domain,
                         iommu_fault_handler_t handler, void *token);
 
@@ -240,6 +258,13 @@ static inline int report_iommu_fault(struct iommu_domain *domain,
         return ret;
 }
 
+static inline size_t iommu_map_sg(struct iommu_domain *domain,
+                                  unsigned long iova, struct scatterlist *sg,
+                                  unsigned int nents, int prot)
+{
+        return domain->ops->map_sg(domain, iova, sg, nents, prot);
+}
+
 #else /* CONFIG_IOMMU_API */
 
 struct iommu_ops {};
@@ -250,6 +275,11 @@ static inline bool iommu_present(struct bus_type *bus)
         return false;
 }
 
+static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
+{
+        return false;
+}
+
 static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
 {
         return NULL;
@@ -287,6 +317,13 @@ static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
         return -ENODEV;
 }
 
+static inline size_t iommu_map_sg(struct iommu_domain *domain,
+                                  unsigned long iova, struct scatterlist *sg,
+                                  unsigned int nents, int prot)
+{
+        return -ENODEV;
+}
+
 static inline int iommu_domain_window_enable(struct iommu_domain *domain,
                                              u32 wnd_nr, phys_addr_t paddr,
                                              u64 size, int prot)
@@ -304,12 +341,6 @@ static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_ad
         return 0;
 }
 
-static inline int iommu_domain_has_cap(struct iommu_domain *domain,
-                                       unsigned long cap)
-{
-        return 0;
-}
-
 static inline void iommu_set_fault_handler(struct iommu_domain *domain,
                                 iommu_fault_handler_t handler, void *token)
 {
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 142ec544167c..2c5250222278 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -215,6 +215,11 @@ static inline int __deprecated check_region(resource_size_t s,
 
 /* Wrappers for managed devices */
 struct device;
+
+extern int devm_request_resource(struct device *dev, struct resource *root,
+                                 struct resource *new);
+extern void devm_release_resource(struct device *dev, struct resource *new);
+
 #define devm_request_region(dev,start,n,name) \
         __devm_request_region(dev, &ioport_resource, (start), (n), (name))
 #define devm_request_mem_region(dev,start,n,name) \
diff --git a/include/linux/ipack.h b/include/linux/ipack.h
index 1888e06ddf64..8bddc3fbdddf 100644
--- a/include/linux/ipack.h
+++ b/include/linux/ipack.h
@@ -172,6 +172,7 @@ struct ipack_bus_ops {
  *      @ops: bus operations for the mezzanine drivers
  */
 struct ipack_bus_device {
+        struct module *owner;
         struct device *parent;
         int slots;
         int bus_nr;
@@ -189,7 +190,8 @@ struct ipack_bus_device {
  * available bus device in ipack.
  */
 struct ipack_bus_device *ipack_bus_register(struct device *parent, int slots,
-                                            const struct ipack_bus_ops *ops);
+                                            const struct ipack_bus_ops *ops,
+                                            struct module *owner);
 
 /**
  *      ipack_bus_unregister -- unregister an ipack bus
@@ -265,3 +267,23 @@ void ipack_put_device(struct ipack_device *dev);
          .format = (_format), \
          .vendor = (vend), \
          .device = (dev)
+
+/**
+ * ipack_get_carrier - it increase the carrier ref. counter of
+ *                     the carrier module
+ * @dev: mezzanine device which wants to get the carrier
+ */
+static inline int ipack_get_carrier(struct ipack_device *dev)
+{
+        return try_module_get(dev->bus->owner);
+}
+
+/**
+ * ipack_get_carrier - it decrease the carrier ref. counter of
+ *                     the carrier module
+ * @dev: mezzanine device which wants to get the carrier
+ */
+static inline void ipack_put_carrier(struct ipack_device *dev)
+{
+        module_put(dev->bus->owner);
+}
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index 35e7eca4e33b..1eee6bcfcf76 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -6,15 +6,7 @@
 #include <linux/rwsem.h>
 #include <linux/notifier.h>
 #include <linux/nsproxy.h>
-
-/*
- * ipc namespace events
- */
-#define IPCNS_MEMCHANGED   0x00000001   /* Notify lowmem size changed */
-#define IPCNS_CREATED  0x00000002   /* Notify new ipc namespace created */
-#define IPCNS_REMOVED  0x00000003   /* Notify ipc namespace removed */
-
-#define IPCNS_CALLBACK_PRI 0
+#include <linux/ns_common.h>
 
 struct user_namespace;
 
@@ -38,7 +30,6 @@ struct ipc_namespace {
         unsigned int    msg_ctlmni;
         atomic_t        msg_bytes;
         atomic_t        msg_hdrs;
-        int             auto_msgmni;
 
         size_t          shm_ctlmax;
         size_t          shm_ctlall;
@@ -68,7 +59,7 @@ struct ipc_namespace {
         /* user_ns which owns the ipc ns */
         struct user_namespace *user_ns;
 
-        unsigned int    proc_inum;
+        struct ns_common ns;
 };
 
 extern struct ipc_namespace init_ipc_ns;
@@ -77,18 +68,8 @@ extern atomic_t nr_ipc_ns;
 extern spinlock_t mq_lock;
 
 #ifdef CONFIG_SYSVIPC
-extern int register_ipcns_notifier(struct ipc_namespace *);
-extern int cond_register_ipcns_notifier(struct ipc_namespace *);
-extern void unregister_ipcns_notifier(struct ipc_namespace *);
-extern int ipcns_notify(unsigned long);
 extern void shm_destroy_orphaned(struct ipc_namespace *ns);
 #else /* CONFIG_SYSVIPC */
-static inline int register_ipcns_notifier(struct ipc_namespace *ns)
-{ return 0; }
-static inline int cond_register_ipcns_notifier(struct ipc_namespace *ns)
-{ return 0; }
-static inline void unregister_ipcns_notifier(struct ipc_namespace *ns) { }
-static inline int ipcns_notify(unsigned long l) { return 0; }
 static inline void shm_destroy_orphaned(struct ipc_namespace *ns) {}
 #endif /* CONFIG_SYSVIPC */
 
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index 76d2acbfa7c6..838dbfa3c331 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -37,6 +37,7 @@
 
 #include <linux/list.h>
 #include <linux/proc_fs.h>
+#include <linux/acpi.h> /* For acpi_handle */
 
 struct module;
 struct device;
@@ -278,15 +279,18 @@ enum ipmi_addr_src {
         SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS,
         SI_PCI, SI_DEVICETREE, SI_DEFAULT
 };
+const char *ipmi_addr_src_to_str(enum ipmi_addr_src src);
 
 union ipmi_smi_info_union {
+#ifdef CONFIG_ACPI
         /*
          * the acpi_info element is defined for the SI_ACPI
          * address type
          */
         struct {
-                void *acpi_handle;
+                acpi_handle acpi_handle;
         } acpi_info;
+#endif
 };
 
 struct ipmi_smi_info {
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index bd349240d50e..0b1e569f5ff5 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -98,12 +98,11 @@ struct ipmi_smi_handlers {
            operation is not allowed to fail.  If an error occurs, it
            should report back the error in a received message.  It may
            do this in the current call context, since no write locks
-           are held when this is run.  If the priority is > 0, the
-           message will go into a high-priority queue and be sent
-           first.  Otherwise, it goes into a normal-priority queue. */
+           are held when this is run.  Message are delivered one at
+           a time by the message handler, a new message will not be
+           delivered until the previous message is returned. */
         void (*sender)(void                *send_info,
-                       struct ipmi_smi_msg *msg,
-                       int                 priority);
+                       struct ipmi_smi_msg *msg);
 
         /* Called by the upper layer to request that we try to get
            events from the BMC we are attached to. */
@@ -212,7 +211,6 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
                       void                     *send_info,
                       struct ipmi_device_id    *device_id,
                       struct device            *dev,
-                      const char               *sysfs_name,
                       unsigned char            slave_addr);
 
 /*
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index ff560537dd61..c694e7baa621 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -42,6 +42,7 @@ struct ipv6_devconf {
         __s32           accept_ra_from_local;
 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
         __s32           optimistic_dad;
+        __s32           use_optimistic;
 #endif
 #ifdef CONFIG_IPV6_MROUTE
         __s32           mc_forwarding;
@@ -316,14 +317,4 @@ static inline struct raw6_sock *raw6_sk(const struct sock *sk)
 #define tcp_twsk_ipv6only(__sk)         0
 #define inet_v6_ipv6only(__sk)          0
 #endif /* IS_ENABLED(CONFIG_IPV6) */
-
-#define INET6_MATCH(__sk, __net, __saddr, __daddr, __ports, __dif)      \
-        (((__sk)->sk_portpair == (__ports))                     &&      \
-         ((__sk)->sk_family == AF_INET6)                        &&      \
-         ipv6_addr_equal(&(__sk)->sk_v6_daddr, (__saddr))               &&      \
-         ipv6_addr_equal(&(__sk)->sk_v6_rcv_saddr, (__daddr))   &&      \
-         (!(__sk)->sk_bound_dev_if      ||                              \
-           ((__sk)->sk_bound_dev_if == (__dif)))                &&      \
-         net_eq(sock_net(__sk), (__net)))
-
 #endif /* _IPV6_H */
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 62af59242ddc..d09ec7a1243e 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -15,11 +15,13 @@
 #include <linux/spinlock.h>
 #include <linux/cpumask.h>
 #include <linux/gfp.h>
+#include <linux/irqhandler.h>
 #include <linux/irqreturn.h>
 #include <linux/irqnr.h>
 #include <linux/errno.h>
 #include <linux/topology.h>
 #include <linux/wait.h>
+#include <linux/io.h>
 
 #include <asm/irq.h>
 #include <asm/ptrace.h>
@@ -27,11 +29,7 @@
 
 struct seq_file;
 struct module;
-struct irq_desc;
-struct irq_data;
-typedef void (*irq_flow_handler_t)(unsigned int irq,
-                                            struct irq_desc *desc);
-typedef void (*irq_preflow_handler_t)(struct irq_data *data);
+struct msi_msg;
 
 /*
  * IRQ line status.
@@ -113,10 +111,14 @@ enum {
  *
  * IRQ_SET_MASK_OK      - OK, core updates irq_data.affinity
  * IRQ_SET_MASK_NOCPY   - OK, chip did update irq_data.affinity
+ * IRQ_SET_MASK_OK_DONE - Same as IRQ_SET_MASK_OK for core. Special code to
+ *                        support stacked irqchips, which indicates skipping
+ *                        all descendent irqchips.
  */
 enum {
         IRQ_SET_MASK_OK = 0,
         IRQ_SET_MASK_OK_NOCOPY,
+        IRQ_SET_MASK_OK_DONE,
 };
 
 struct msi_desc;
@@ -133,6 +135,8 @@ struct irq_domain;
  * @chip:               low level interrupt hardware access
  * @domain:             Interrupt translation domain; responsible for mapping
  *                      between hwirq number and linux irq number.
+ * @parent_data:        pointer to parent struct irq_data to support hierarchy
+ *                      irq_domain
  * @handler_data:       per-IRQ data for the irq_chip methods
  * @chip_data:          platform-specific per-chip private data for the chip
  *                      methods, to allow shared chip implementations
@@ -151,6 +155,9 @@ struct irq_data {
         unsigned int            state_use_accessors;
         struct irq_chip         *chip;
         struct irq_domain       *domain;
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+        struct irq_data         *parent_data;
+#endif
         void                    *handler_data;
         void                    *chip_data;
         struct msi_desc         *msi_desc;
@@ -173,6 +180,7 @@ struct irq_data {
  * IRQD_IRQ_DISABLED            - Disabled state of the interrupt
  * IRQD_IRQ_MASKED              - Masked state of the interrupt
  * IRQD_IRQ_INPROGRESS          - In progress state of the interrupt
+ * IRQD_WAKEUP_ARMED            - Wakeup mode armed
  */
 enum {
         IRQD_TRIGGER_MASK               = 0xf,
@@ -186,6 +194,7 @@ enum {
         IRQD_IRQ_DISABLED               = (1 << 16),
         IRQD_IRQ_MASKED                 = (1 << 17),
         IRQD_IRQ_INPROGRESS             = (1 << 18),
+        IRQD_WAKEUP_ARMED               = (1 << 19),
 };
 
 static inline bool irqd_is_setaffinity_pending(struct irq_data *d)
@@ -257,6 +266,12 @@ static inline bool irqd_irq_inprogress(struct irq_data *d)
         return d->state_use_accessors & IRQD_IRQ_INPROGRESS;
 }
 
+static inline bool irqd_is_wakeup_armed(struct irq_data *d)
+{
+        return d->state_use_accessors & IRQD_WAKEUP_ARMED;
+}
+
+
 /*
  * Functions for chained handlers which can be enabled/disabled by the
  * standard disable_irq/enable_irq calls. Must be called with
@@ -307,6 +322,8 @@ static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
  *                              any other callback related to this irq
  * @irq_release_resources:      optional to release resources acquired with
  *                              irq_request_resources
+ * @irq_compose_msi_msg:        optional to compose message content for MSI
+ * @irq_write_msi_msg:  optional to write message content for MSI
  * @flags:              chip specific flags
  */
 struct irq_chip {
@@ -343,6 +360,9 @@ struct irq_chip {
         int             (*irq_request_resources)(struct irq_data *data);
         void            (*irq_release_resources)(struct irq_data *data);
 
+        void            (*irq_compose_msi_msg)(struct irq_data *data, struct msi_msg *msg);
+        void            (*irq_write_msi_msg)(struct irq_data *data, struct msi_msg *msg);
+
         unsigned long   flags;
 };
 
@@ -430,6 +450,18 @@ extern void handle_percpu_devid_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_nested_irq(unsigned int irq);
 
+extern int irq_chip_compose_msi_msg(struct irq_data *data, struct msi_msg *msg);
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+extern void irq_chip_ack_parent(struct irq_data *data);
+extern int irq_chip_retrigger_hierarchy(struct irq_data *data);
+extern void irq_chip_mask_parent(struct irq_data *data);
+extern void irq_chip_unmask_parent(struct irq_data *data);
+extern void irq_chip_eoi_parent(struct irq_data *data);
+extern int irq_chip_set_affinity_parent(struct irq_data *data,
+                                        const struct cpumask *dest,
+                                        bool force);
+#endif
+
 /* Handling of unhandled and spurious interrupts: */
 extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
                            irqreturn_t action_ret);
@@ -631,13 +663,6 @@ void arch_teardown_hwirq(unsigned int irq);
 void irq_init_desc(unsigned int irq);
 #endif
 
-#ifndef irq_reg_writel
-# define irq_reg_writel(val, addr)      writel(val, addr)
-#endif
-#ifndef irq_reg_readl
-# define irq_reg_readl(addr)            readl(addr)
-#endif
-
 /**
  * struct irq_chip_regs - register offsets for struct irq_gci
  * @enable:     Enable register offset to reg_base
@@ -684,6 +709,8 @@ struct irq_chip_type {
  * struct irq_chip_generic - Generic irq chip data structure
  * @lock:               Lock to protect register and cache data access
  * @reg_base:           Register base address (virtual)
+ * @reg_readl:          Alternate I/O accessor (defaults to readl if NULL)
+ * @reg_writel:         Alternate I/O accessor (defaults to writel if NULL)
  * @irq_base:           Interrupt base nr for this chip
  * @irq_cnt:            Number of interrupts handled by this chip
  * @mask_cache:         Cached mask register shared between all chip types
@@ -708,6 +735,8 @@ struct irq_chip_type {
 struct irq_chip_generic {
         raw_spinlock_t          lock;
         void __iomem            *reg_base;
+        u32                     (*reg_readl)(void __iomem *addr);
+        void                    (*reg_writel)(u32 val, void __iomem *addr);
         unsigned int            irq_base;
         unsigned int            irq_cnt;
         u32                     mask_cache;
@@ -732,12 +761,14 @@ struct irq_chip_generic {
  *                              the parent irq. Usually GPIO implementations
  * @IRQ_GC_MASK_CACHE_PER_TYPE: Mask cache is chip type private
  * @IRQ_GC_NO_MASK:             Do not calculate irq_data->mask
+ * @IRQ_GC_BE_IO:               Use big-endian register accesses (default: LE)
  */
 enum irq_gc_flags {
         IRQ_GC_INIT_MASK_CACHE          = 1 << 0,
         IRQ_GC_INIT_NESTED_LOCK         = 1 << 1,
         IRQ_GC_MASK_CACHE_PER_TYPE      = 1 << 2,
         IRQ_GC_NO_MASK                  = 1 << 3,
+        IRQ_GC_BE_IO                    = 1 << 4,
 };
 
 /*
@@ -813,4 +844,22 @@ static inline void irq_gc_lock(struct irq_chip_generic *gc) { }
 static inline void irq_gc_unlock(struct irq_chip_generic *gc) { }
 #endif
 
+static inline void irq_reg_writel(struct irq_chip_generic *gc,
+                                  u32 val, int reg_offset)
+{
+        if (gc->reg_writel)
+                gc->reg_writel(val, gc->reg_base + reg_offset);
+        else
+                writel(val, gc->reg_base + reg_offset);
+}
+
+static inline u32 irq_reg_readl(struct irq_chip_generic *gc,
+                                int reg_offset)
+{
+        if (gc->reg_readl)
+                return gc->reg_readl(gc->reg_base + reg_offset);
+        else
+                return readl(gc->reg_base + reg_offset);
+}
+
 #endif /* _LINUX_IRQ_H */
diff --git a/include/linux/irq_work.h b/include/linux/irq_work.h
index bf9422c3aefe..bf3fe719c7ce 100644
--- a/include/linux/irq_work.h
+++ b/include/linux/irq_work.h
@@ -39,9 +39,12 @@ bool irq_work_queue_on(struct irq_work *work, int cpu);
 #endif
 
 void irq_work_run(void);
+void irq_work_tick(void);
 void irq_work_sync(struct irq_work *work);
 
 #ifdef CONFIG_IRQ_WORK
+#include <asm/irq_work.h>
+
 bool irq_work_needs_cpu(void);
 #else
 static inline bool irq_work_needs_cpu(void) { return false; }
diff --git a/include/linux/irqchip/arm-gic-v3.h b/include/linux/irqchip/arm-gic-v3.h
index 03a4ea37ba86..1e8b0cf30792 100644
--- a/include/linux/irqchip/arm-gic-v3.h
+++ b/include/linux/irqchip/arm-gic-v3.h
@@ -49,6 +49,10 @@
 #define GICD_CTLR_ENABLE_G1A            (1U << 1)
 #define GICD_CTLR_ENABLE_G1             (1U << 0)
 
+#define GICD_TYPER_ID_BITS(typer)       ((((typer) >> 19) & 0x1f) + 1)
+#define GICD_TYPER_IRQS(typer)          ((((typer) & 0x1f) + 1) * 32)
+#define GICD_TYPER_LPIS                 (1U << 17)
+
 #define GICD_IROUTER_SPI_MODE_ONE       (0U << 31)
 #define GICD_IROUTER_SPI_MODE_ANY       (1U << 31)
 
@@ -76,9 +80,27 @@
 #define GICR_MOVALLR                    0x0110
 #define GICR_PIDR2                      GICD_PIDR2
 
+#define GICR_CTLR_ENABLE_LPIS           (1UL << 0)
+
+#define GICR_TYPER_CPU_NUMBER(r)        (((r) >> 8) & 0xffff)
+
 #define GICR_WAKER_ProcessorSleep       (1U << 1)
 #define GICR_WAKER_ChildrenAsleep       (1U << 2)
 
+#define GICR_PROPBASER_NonShareable     (0U << 10)
+#define GICR_PROPBASER_InnerShareable   (1U << 10)
+#define GICR_PROPBASER_OuterShareable   (2U << 10)
+#define GICR_PROPBASER_SHAREABILITY_MASK (3UL << 10)
+#define GICR_PROPBASER_nCnB             (0U << 7)
+#define GICR_PROPBASER_nC               (1U << 7)
+#define GICR_PROPBASER_RaWt             (2U << 7)
+#define GICR_PROPBASER_RaWb             (3U << 7)
+#define GICR_PROPBASER_WaWt             (4U << 7)
+#define GICR_PROPBASER_WaWb             (5U << 7)
+#define GICR_PROPBASER_RaWaWt           (6U << 7)
+#define GICR_PROPBASER_RaWaWb           (7U << 7)
+#define GICR_PROPBASER_IDBITS_MASK      (0x1f)
+
 /*
  * Re-Distributor registers, offsets from SGI_base
  */
@@ -91,9 +113,93 @@
 #define GICR_IPRIORITYR0                GICD_IPRIORITYR
 #define GICR_ICFGR0                     GICD_ICFGR
 
+#define GICR_TYPER_PLPIS                (1U << 0)
 #define GICR_TYPER_VLPIS                (1U << 1)
 #define GICR_TYPER_LAST                 (1U << 4)
 
+#define LPI_PROP_GROUP1                 (1 << 1)
+#define LPI_PROP_ENABLED                (1 << 0)
+
+/*
+ * ITS registers, offsets from ITS_base
+ */
+#define GITS_CTLR                       0x0000
+#define GITS_IIDR                       0x0004
+#define GITS_TYPER                      0x0008
+#define GITS_CBASER                     0x0080
+#define GITS_CWRITER                    0x0088
+#define GITS_CREADR                     0x0090
+#define GITS_BASER                      0x0100
+#define GITS_PIDR2                      GICR_PIDR2
+
+#define GITS_TRANSLATER                 0x10040
+
+#define GITS_TYPER_PTA                  (1UL << 19)
+
+#define GITS_CBASER_VALID               (1UL << 63)
+#define GITS_CBASER_nCnB                (0UL << 59)
+#define GITS_CBASER_nC                  (1UL << 59)
+#define GITS_CBASER_RaWt                (2UL << 59)
+#define GITS_CBASER_RaWb                (3UL << 59)
+#define GITS_CBASER_WaWt                (4UL << 59)
+#define GITS_CBASER_WaWb                (5UL << 59)
+#define GITS_CBASER_RaWaWt              (6UL << 59)
+#define GITS_CBASER_RaWaWb              (7UL << 59)
+#define GITS_CBASER_NonShareable        (0UL << 10)
+#define GITS_CBASER_InnerShareable      (1UL << 10)
+#define GITS_CBASER_OuterShareable      (2UL << 10)
+#define GITS_CBASER_SHAREABILITY_MASK   (3UL << 10)
+
+#define GITS_BASER_NR_REGS              8
+
+#define GITS_BASER_VALID                (1UL << 63)
+#define GITS_BASER_nCnB                 (0UL << 59)
+#define GITS_BASER_nC                   (1UL << 59)
+#define GITS_BASER_RaWt                 (2UL << 59)
+#define GITS_BASER_RaWb                 (3UL << 59)
+#define GITS_BASER_WaWt                 (4UL << 59)
+#define GITS_BASER_WaWb                 (5UL << 59)
+#define GITS_BASER_RaWaWt               (6UL << 59)
+#define GITS_BASER_RaWaWb               (7UL << 59)
+#define GITS_BASER_TYPE_SHIFT           (56)
+#define GITS_BASER_TYPE(r)              (((r) >> GITS_BASER_TYPE_SHIFT) & 7)
+#define GITS_BASER_ENTRY_SIZE_SHIFT     (48)
+#define GITS_BASER_ENTRY_SIZE(r)        ((((r) >> GITS_BASER_ENTRY_SIZE_SHIFT) & 0xff) + 1)
+#define GITS_BASER_NonShareable         (0UL << 10)
+#define GITS_BASER_InnerShareable       (1UL << 10)
+#define GITS_BASER_OuterShareable       (2UL << 10)
+#define GITS_BASER_SHAREABILITY_SHIFT   (10)
+#define GITS_BASER_SHAREABILITY_MASK    (3UL << GITS_BASER_SHAREABILITY_SHIFT)
+#define GITS_BASER_PAGE_SIZE_SHIFT      (8)
+#define GITS_BASER_PAGE_SIZE_4K         (0UL << GITS_BASER_PAGE_SIZE_SHIFT)
+#define GITS_BASER_PAGE_SIZE_16K        (1UL << GITS_BASER_PAGE_SIZE_SHIFT)
+#define GITS_BASER_PAGE_SIZE_64K        (2UL << GITS_BASER_PAGE_SIZE_SHIFT)
+#define GITS_BASER_PAGE_SIZE_MASK       (3UL << GITS_BASER_PAGE_SIZE_SHIFT)
+
+#define GITS_BASER_TYPE_NONE            0
+#define GITS_BASER_TYPE_DEVICE          1
+#define GITS_BASER_TYPE_VCPU            2
+#define GITS_BASER_TYPE_CPU             3
+#define GITS_BASER_TYPE_COLLECTION      4
+#define GITS_BASER_TYPE_RESERVED5       5
+#define GITS_BASER_TYPE_RESERVED6       6
+#define GITS_BASER_TYPE_RESERVED7       7
+
+/*
+ * ITS commands
+ */
+#define GITS_CMD_MAPD                   0x08
+#define GITS_CMD_MAPC                   0x09
+#define GITS_CMD_MAPVI                  0x0a
+#define GITS_CMD_MOVI                   0x01
+#define GITS_CMD_DISCARD                0x0f
+#define GITS_CMD_INV                    0x0c
+#define GITS_CMD_MOVALL                 0x0e
+#define GITS_CMD_INVALL                 0x0d
+#define GITS_CMD_INT                    0x03
+#define GITS_CMD_CLEAR                  0x04
+#define GITS_CMD_SYNC                   0x05
+
 /*
  * CPU interface registers
  */
@@ -189,12 +295,34 @@
 
 #include <linux/stringify.h>
 
+/*
+ * We need a value to serve as a irq-type for LPIs. Choose one that will
+ * hopefully pique the interest of the reviewer.
+ */
+#define GIC_IRQ_TYPE_LPI                0xa110c8ed
+
+struct rdists {
+        struct {
+                void __iomem    *rd_base;
+                struct page     *pend_page;
+                phys_addr_t     phys_base;
+        } __percpu              *rdist;
+        struct page             *prop_page;
+        int                     id_bits;
+        u64                     flags;
+};
+
 static inline void gic_write_eoir(u64 irq)
 {
         asm volatile("msr_s " __stringify(ICC_EOIR1_EL1) ", %0" : : "r" (irq));
         isb();
 }
 
+struct irq_domain;
+int its_cpu_init(void);
+int its_init(struct device_node *node, struct rdists *rdists,
+             struct irq_domain *domain);
+
 #endif
 
 #endif
diff --git a/include/linux/irqchip/arm-gic.h b/include/linux/irqchip/arm-gic.h
index 45e2d8c15bd2..71d706d5f169 100644
--- a/include/linux/irqchip/arm-gic.h
+++ b/include/linux/irqchip/arm-gic.h
@@ -21,7 +21,11 @@
 #define GIC_CPU_ACTIVEPRIO              0xd0
 #define GIC_CPU_IDENT                   0xfc
 
+#define GICC_ENABLE                     0x1
+#define GICC_INT_PRI_THRESHOLD          0xf0
 #define GICC_IAR_INT_ID_MASK            0x3ff
+#define GICC_INT_SPURIOUS               1023
+#define GICC_DIS_BYPASS_MASK            0x1e0
 
 #define GIC_DIST_CTRL                   0x000
 #define GIC_DIST_CTR                    0x004
@@ -39,6 +43,18 @@
 #define GIC_DIST_SGI_PENDING_CLEAR      0xf10
 #define GIC_DIST_SGI_PENDING_SET        0xf20
 
+#define GICD_ENABLE                     0x1
+#define GICD_DISABLE                    0x0
+#define GICD_INT_ACTLOW_LVLTRIG         0x0
+#define GICD_INT_EN_CLR_X32             0xffffffff
+#define GICD_INT_EN_SET_SGI             0x0000ffff
+#define GICD_INT_EN_CLR_PPI             0xffff0000
+#define GICD_INT_DEF_PRI                0xa0
+#define GICD_INT_DEF_PRI_X4             ((GICD_INT_DEF_PRI << 24) |\
+                                        (GICD_INT_DEF_PRI << 16) |\
+                                        (GICD_INT_DEF_PRI << 8) |\
+                                        GICD_INT_DEF_PRI)
+
 #define GICH_HCR                        0x0
 #define GICH_VTR                        0x4
 #define GICH_VMCR                       0x8
@@ -75,6 +91,8 @@
 
 #ifndef __ASSEMBLY__
 
+#include <linux/irqdomain.h>
+
 struct device_node;
 
 extern struct irq_chip gic_arch_extn;
@@ -90,6 +108,8 @@ static inline void gic_init(unsigned int nr, int start,
         gic_init_bases(nr, start, dist, cpu, 0, NULL);
 }
 
+int gicv2m_of_init(struct device_node *node, struct irq_domain *parent);
+
 void gic_send_sgi(unsigned int cpu_id, unsigned int irq);
 int gic_get_cpu_id(unsigned int cpu);
 void gic_migrate_target(unsigned int new_cpu_id);
diff --git a/include/linux/irqchip/irq-omap-intc.h b/include/linux/irqchip/irq-omap-intc.h
new file mode 100644
index 000000000000..e06b370cfc0d
--- /dev/null
+++ b/include/linux/irqchip/irq-omap-intc.h
@@ -0,0 +1,32 @@
+/**
+ * irq-omap-intc.h - INTC Idle Functions
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
+ *
+ * Author: Felipe Balbi <balbi@ti.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2  of
+ * the License 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 __INCLUDE_LINUX_IRQCHIP_IRQ_OMAP_INTC_H
+#define __INCLUDE_LINUX_IRQCHIP_IRQ_OMAP_INTC_H
+
+void omap2_init_irq(void);
+void omap3_init_irq(void);
+void ti81xx_init_irq(void);
+
+int omap_irq_pending(void);
+void omap_intc_save_context(void);
+void omap_intc_restore_context(void);
+void omap3_intc_suspend(void);
+void omap3_intc_prepare_idle(void);
+void omap3_intc_resume_idle(void);
+
+#endif /* __INCLUDE_LINUX_IRQCHIP_IRQ_OMAP_INTC_H */
diff --git a/include/linux/irqchip/mips-gic.h b/include/linux/irqchip/mips-gic.h
new file mode 100644
index 000000000000..420f77b34d02
--- /dev/null
+++ b/include/linux/irqchip/mips-gic.h
@@ -0,0 +1,249 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2000, 07 MIPS Technologies, Inc.
+ */
+#ifndef __LINUX_IRQCHIP_MIPS_GIC_H
+#define __LINUX_IRQCHIP_MIPS_GIC_H
+
+#include <linux/clocksource.h>
+
+#define GIC_MAX_INTRS                   256
+
+/* Constants */
+#define GIC_POL_POS                     1
+#define GIC_POL_NEG                     0
+#define GIC_TRIG_EDGE                   1
+#define GIC_TRIG_LEVEL                  0
+#define GIC_TRIG_DUAL_ENABLE            1
+#define GIC_TRIG_DUAL_DISABLE           0
+
+#define MSK(n) ((1 << (n)) - 1)
+
+/* Accessors */
+#define GIC_REG(segment, offset) (segment##_##SECTION_OFS + offset##_##OFS)
+
+/* GIC Address Space */
+#define SHARED_SECTION_OFS              0x0000
+#define SHARED_SECTION_SIZE             0x8000
+#define VPE_LOCAL_SECTION_OFS           0x8000
+#define VPE_LOCAL_SECTION_SIZE          0x4000
+#define VPE_OTHER_SECTION_OFS           0xc000
+#define VPE_OTHER_SECTION_SIZE          0x4000
+#define USM_VISIBLE_SECTION_OFS         0x10000
+#define USM_VISIBLE_SECTION_SIZE        0x10000
+
+/* Register Map for Shared Section */
+
+#define GIC_SH_CONFIG_OFS               0x0000
+
+/* Shared Global Counter */
+#define GIC_SH_COUNTER_31_00_OFS        0x0010
+#define GIC_SH_COUNTER_63_32_OFS        0x0014
+#define GIC_SH_REVISIONID_OFS           0x0020
+
+/* Convert an interrupt number to a byte offset/bit for multi-word registers */
+#define GIC_INTR_OFS(intr)              (((intr) / 32) * 4)
+#define GIC_INTR_BIT(intr)              ((intr) % 32)
+
+/* Polarity : Reset Value is always 0 */
+#define GIC_SH_SET_POLARITY_OFS         0x0100
+
+/* Triggering : Reset Value is always 0 */
+#define GIC_SH_SET_TRIGGER_OFS          0x0180
+
+/* Dual edge triggering : Reset Value is always 0 */
+#define GIC_SH_SET_DUAL_OFS             0x0200
+
+/* Set/Clear corresponding bit in Edge Detect Register */
+#define GIC_SH_WEDGE_OFS                0x0280
+
+/* Mask manipulation */
+#define GIC_SH_RMASK_OFS                0x0300
+#define GIC_SH_SMASK_OFS                0x0380
+
+/* Global Interrupt Mask Register (RO) - Bit Set == Interrupt enabled */
+#define GIC_SH_MASK_OFS                 0x0400
+
+/* Pending Global Interrupts (RO) */
+#define GIC_SH_PEND_OFS                 0x0480
+
+/* Maps Interrupt X to a Pin */
+#define GIC_SH_INTR_MAP_TO_PIN_BASE_OFS 0x0500
+#define GIC_SH_MAP_TO_PIN(intr)         (4 * (intr))
+
+/* Maps Interrupt X to a VPE */
+#define GIC_SH_INTR_MAP_TO_VPE_BASE_OFS 0x2000
+#define GIC_SH_MAP_TO_VPE_REG_OFF(intr, vpe) \
+        ((32 * (intr)) + (((vpe) / 32) * 4))
+#define GIC_SH_MAP_TO_VPE_REG_BIT(vpe)  (1 << ((vpe) % 32))
+
+/* Register Map for Local Section */
+#define GIC_VPE_CTL_OFS                 0x0000
+#define GIC_VPE_PEND_OFS                0x0004
+#define GIC_VPE_MASK_OFS                0x0008
+#define GIC_VPE_RMASK_OFS               0x000c
+#define GIC_VPE_SMASK_OFS               0x0010
+#define GIC_VPE_WD_MAP_OFS              0x0040
+#define GIC_VPE_COMPARE_MAP_OFS         0x0044
+#define GIC_VPE_TIMER_MAP_OFS           0x0048
+#define GIC_VPE_FDC_MAP_OFS             0x004c
+#define GIC_VPE_PERFCTR_MAP_OFS         0x0050
+#define GIC_VPE_SWINT0_MAP_OFS          0x0054
+#define GIC_VPE_SWINT1_MAP_OFS          0x0058
+#define GIC_VPE_OTHER_ADDR_OFS          0x0080
+#define GIC_VPE_WD_CONFIG0_OFS          0x0090
+#define GIC_VPE_WD_COUNT0_OFS           0x0094
+#define GIC_VPE_WD_INITIAL0_OFS         0x0098
+#define GIC_VPE_COMPARE_LO_OFS          0x00a0
+#define GIC_VPE_COMPARE_HI_OFS          0x00a4
+
+#define GIC_VPE_EIC_SHADOW_SET_BASE_OFS 0x0100
+#define GIC_VPE_EIC_SS(intr)            (4 * (intr))
+
+#define GIC_VPE_EIC_VEC_BASE_OFS        0x0800
+#define GIC_VPE_EIC_VEC(intr)           (4 * (intr))
+
+#define GIC_VPE_TENABLE_NMI_OFS         0x1000
+#define GIC_VPE_TENABLE_YQ_OFS          0x1004
+#define GIC_VPE_TENABLE_INT_31_0_OFS    0x1080
+#define GIC_VPE_TENABLE_INT_63_32_OFS   0x1084
+
+/* User Mode Visible Section Register Map */
+#define GIC_UMV_SH_COUNTER_31_00_OFS    0x0000
+#define GIC_UMV_SH_COUNTER_63_32_OFS    0x0004
+
+/* Masks */
+#define GIC_SH_CONFIG_COUNTSTOP_SHF     28
+#define GIC_SH_CONFIG_COUNTSTOP_MSK     (MSK(1) << GIC_SH_CONFIG_COUNTSTOP_SHF)
+
+#define GIC_SH_CONFIG_COUNTBITS_SHF     24
+#define GIC_SH_CONFIG_COUNTBITS_MSK     (MSK(4) << GIC_SH_CONFIG_COUNTBITS_SHF)
+
+#define GIC_SH_CONFIG_NUMINTRS_SHF      16
+#define GIC_SH_CONFIG_NUMINTRS_MSK      (MSK(8) << GIC_SH_CONFIG_NUMINTRS_SHF)
+
+#define GIC_SH_CONFIG_NUMVPES_SHF       0
+#define GIC_SH_CONFIG_NUMVPES_MSK       (MSK(8) << GIC_SH_CONFIG_NUMVPES_SHF)
+
+#define GIC_SH_WEDGE_SET(intr)          ((intr) | (0x1 << 31))
+#define GIC_SH_WEDGE_CLR(intr)          ((intr) & ~(0x1 << 31))
+
+#define GIC_MAP_TO_PIN_SHF              31
+#define GIC_MAP_TO_PIN_MSK              (MSK(1) << GIC_MAP_TO_PIN_SHF)
+#define GIC_MAP_TO_NMI_SHF              30
+#define GIC_MAP_TO_NMI_MSK              (MSK(1) << GIC_MAP_TO_NMI_SHF)
+#define GIC_MAP_TO_YQ_SHF               29
+#define GIC_MAP_TO_YQ_MSK               (MSK(1) << GIC_MAP_TO_YQ_SHF)
+#define GIC_MAP_SHF                     0
+#define GIC_MAP_MSK                     (MSK(6) << GIC_MAP_SHF)
+
+/* GIC_VPE_CTL Masks */
+#define GIC_VPE_CTL_FDC_RTBL_SHF        4
+#define GIC_VPE_CTL_FDC_RTBL_MSK        (MSK(1) << GIC_VPE_CTL_FDC_RTBL_SHF)
+#define GIC_VPE_CTL_SWINT_RTBL_SHF      3
+#define GIC_VPE_CTL_SWINT_RTBL_MSK      (MSK(1) << GIC_VPE_CTL_SWINT_RTBL_SHF)
+#define GIC_VPE_CTL_PERFCNT_RTBL_SHF    2
+#define GIC_VPE_CTL_PERFCNT_RTBL_MSK    (MSK(1) << GIC_VPE_CTL_PERFCNT_RTBL_SHF)
+#define GIC_VPE_CTL_TIMER_RTBL_SHF      1
+#define GIC_VPE_CTL_TIMER_RTBL_MSK      (MSK(1) << GIC_VPE_CTL_TIMER_RTBL_SHF)
+#define GIC_VPE_CTL_EIC_MODE_SHF        0
+#define GIC_VPE_CTL_EIC_MODE_MSK        (MSK(1) << GIC_VPE_CTL_EIC_MODE_SHF)
+
+/* GIC_VPE_PEND Masks */
+#define GIC_VPE_PEND_WD_SHF             0
+#define GIC_VPE_PEND_WD_MSK             (MSK(1) << GIC_VPE_PEND_WD_SHF)
+#define GIC_VPE_PEND_CMP_SHF            1
+#define GIC_VPE_PEND_CMP_MSK            (MSK(1) << GIC_VPE_PEND_CMP_SHF)
+#define GIC_VPE_PEND_TIMER_SHF          2
+#define GIC_VPE_PEND_TIMER_MSK          (MSK(1) << GIC_VPE_PEND_TIMER_SHF)
+#define GIC_VPE_PEND_PERFCOUNT_SHF      3
+#define GIC_VPE_PEND_PERFCOUNT_MSK      (MSK(1) << GIC_VPE_PEND_PERFCOUNT_SHF)
+#define GIC_VPE_PEND_SWINT0_SHF         4
+#define GIC_VPE_PEND_SWINT0_MSK         (MSK(1) << GIC_VPE_PEND_SWINT0_SHF)
+#define GIC_VPE_PEND_SWINT1_SHF         5
+#define GIC_VPE_PEND_SWINT1_MSK         (MSK(1) << GIC_VPE_PEND_SWINT1_SHF)
+
+/* GIC_VPE_RMASK Masks */
+#define GIC_VPE_RMASK_WD_SHF            0
+#define GIC_VPE_RMASK_WD_MSK            (MSK(1) << GIC_VPE_RMASK_WD_SHF)
+#define GIC_VPE_RMASK_CMP_SHF           1
+#define GIC_VPE_RMASK_CMP_MSK           (MSK(1) << GIC_VPE_RMASK_CMP_SHF)
+#define GIC_VPE_RMASK_TIMER_SHF         2
+#define GIC_VPE_RMASK_TIMER_MSK         (MSK(1) << GIC_VPE_RMASK_TIMER_SHF)
+#define GIC_VPE_RMASK_PERFCNT_SHF       3
+#define GIC_VPE_RMASK_PERFCNT_MSK       (MSK(1) << GIC_VPE_RMASK_PERFCNT_SHF)
+#define GIC_VPE_RMASK_SWINT0_SHF        4
+#define GIC_VPE_RMASK_SWINT0_MSK        (MSK(1) << GIC_VPE_RMASK_SWINT0_SHF)
+#define GIC_VPE_RMASK_SWINT1_SHF        5
+#define GIC_VPE_RMASK_SWINT1_MSK        (MSK(1) << GIC_VPE_RMASK_SWINT1_SHF)
+
+/* GIC_VPE_SMASK Masks */
+#define GIC_VPE_SMASK_WD_SHF            0
+#define GIC_VPE_SMASK_WD_MSK            (MSK(1) << GIC_VPE_SMASK_WD_SHF)
+#define GIC_VPE_SMASK_CMP_SHF           1
+#define GIC_VPE_SMASK_CMP_MSK           (MSK(1) << GIC_VPE_SMASK_CMP_SHF)
+#define GIC_VPE_SMASK_TIMER_SHF         2
+#define GIC_VPE_SMASK_TIMER_MSK         (MSK(1) << GIC_VPE_SMASK_TIMER_SHF)
+#define GIC_VPE_SMASK_PERFCNT_SHF       3
+#define GIC_VPE_SMASK_PERFCNT_MSK       (MSK(1) << GIC_VPE_SMASK_PERFCNT_SHF)
+#define GIC_VPE_SMASK_SWINT0_SHF        4
+#define GIC_VPE_SMASK_SWINT0_MSK        (MSK(1) << GIC_VPE_SMASK_SWINT0_SHF)
+#define GIC_VPE_SMASK_SWINT1_SHF        5
+#define GIC_VPE_SMASK_SWINT1_MSK        (MSK(1) << GIC_VPE_SMASK_SWINT1_SHF)
+
+/* GIC nomenclature for Core Interrupt Pins. */
+#define GIC_CPU_INT0            0 /* Core Interrupt 2 */
+#define GIC_CPU_INT1            1 /* .                */
+#define GIC_CPU_INT2            2 /* .                */
+#define GIC_CPU_INT3            3 /* .                */
+#define GIC_CPU_INT4            4 /* .                */
+#define GIC_CPU_INT5            5 /* Core Interrupt 7 */
+
+/* Add 2 to convert GIC CPU pin to core interrupt */
+#define GIC_CPU_PIN_OFFSET      2
+
+/* Add 2 to convert non-EIC hardware interrupt to EIC vector number. */
+#define GIC_CPU_TO_VEC_OFFSET   2
+
+/* Mapped interrupt to pin X, then GIC will generate the vector (X+1). */
+#define GIC_PIN_TO_VEC_OFFSET   1
+
+/* Local GIC interrupts. */
+#define GIC_LOCAL_INT_WD        0 /* GIC watchdog */
+#define GIC_LOCAL_INT_COMPARE   1 /* GIC count and compare timer */
+#define GIC_LOCAL_INT_TIMER     2 /* CPU timer interrupt */
+#define GIC_LOCAL_INT_PERFCTR   3 /* CPU performance counter */
+#define GIC_LOCAL_INT_SWINT0    4 /* CPU software interrupt 0 */
+#define GIC_LOCAL_INT_SWINT1    5 /* CPU software interrupt 1 */
+#define GIC_LOCAL_INT_FDC       6 /* CPU fast debug channel */
+#define GIC_NUM_LOCAL_INTRS     7
+
+/* Convert between local/shared IRQ number and GIC HW IRQ number. */
+#define GIC_LOCAL_HWIRQ_BASE    0
+#define GIC_LOCAL_TO_HWIRQ(x)   (GIC_LOCAL_HWIRQ_BASE + (x))
+#define GIC_HWIRQ_TO_LOCAL(x)   ((x) - GIC_LOCAL_HWIRQ_BASE)
+#define GIC_SHARED_HWIRQ_BASE   GIC_NUM_LOCAL_INTRS
+#define GIC_SHARED_TO_HWIRQ(x)  (GIC_SHARED_HWIRQ_BASE + (x))
+#define GIC_HWIRQ_TO_SHARED(x)  ((x) - GIC_SHARED_HWIRQ_BASE)
+
+extern unsigned int gic_present;
+
+extern void gic_init(unsigned long gic_base_addr,
+        unsigned long gic_addrspace_size, unsigned int cpu_vec,
+        unsigned int irqbase);
+extern void gic_clocksource_init(unsigned int);
+extern cycle_t gic_read_count(void);
+extern unsigned int gic_get_count_width(void);
+extern cycle_t gic_read_compare(void);
+extern void gic_write_compare(cycle_t cnt);
+extern void gic_write_cpu_compare(cycle_t cnt, int cpu);
+extern void gic_send_ipi(unsigned int intr);
+extern unsigned int plat_ipi_call_int_xlate(unsigned int);
+extern unsigned int plat_ipi_resched_int_xlate(unsigned int);
+extern unsigned int gic_get_timer_pending(void);
+extern int gic_get_c0_compare_int(void);
+extern int gic_get_c0_perfcount_int(void);
+#endif /* __LINUX_IRQCHIP_MIPS_GIC_H */
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index 472c021a2d4f..faf433af425e 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -12,6 +12,8 @@ struct irq_affinity_notify;
 struct proc_dir_entry;
 struct module;
 struct irq_desc;
+struct irq_domain;
+struct pt_regs;
 
 /**
  * struct irq_desc - interrupt descriptor
@@ -36,6 +38,11 @@ struct irq_desc;
  * @threads_oneshot:    bitfield to handle shared oneshot threads
  * @threads_active:     number of irqaction threads currently running
  * @wait_for_threads:   wait queue for sync_irq to wait for threaded handlers
+ * @nr_actions:         number of installed actions on this descriptor
+ * @no_suspend_depth:   number of irqactions on a irq descriptor with
+ *                      IRQF_NO_SUSPEND set
+ * @force_resume_depth: number of irqactions on a irq descriptor with
+ *                      IRQF_FORCE_RESUME set
  * @dir:                /proc/irq/ procfs entry
  * @name:               flow handler name for /proc/interrupts output
  */
@@ -68,6 +75,11 @@ struct irq_desc {
         unsigned long           threads_oneshot;
         atomic_t                threads_active;
         wait_queue_head_t       wait_for_threads;
+#ifdef CONFIG_PM_SLEEP
+        unsigned int            nr_actions;
+        unsigned int            no_suspend_depth;
+        unsigned int            force_resume_depth;
+#endif
 #ifdef CONFIG_PROC_FS
         struct proc_dir_entry   *dir;
 #endif
@@ -118,6 +130,23 @@ static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *de
 
 int generic_handle_irq(unsigned int irq);
 
+#ifdef CONFIG_HANDLE_DOMAIN_IRQ
+/*
+ * Convert a HW interrupt number to a logical one using a IRQ domain,
+ * and handle the result interrupt number. Return -EINVAL if
+ * conversion failed. Providing a NULL domain indicates that the
+ * conversion has already been done.
+ */
+int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
+                        bool lookup, struct pt_regs *regs);
+
+static inline int handle_domain_irq(struct irq_domain *domain,
+                                    unsigned int hwirq, struct pt_regs *regs)
+{
+        return __handle_domain_irq(domain, hwirq, true, regs);
+}
+#endif
+
 /* Test to see if a driver has successfully requested an irq */
 static inline int irq_has_action(unsigned int irq)
 {
diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index b0f9d16e48f6..676d7306a360 100644
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -33,11 +33,14 @@
 #define _LINUX_IRQDOMAIN_H
 
 #include <linux/types.h>
+#include <linux/irqhandler.h>
 #include <linux/radix-tree.h>
 
 struct device_node;
 struct irq_domain;
 struct of_device_id;
+struct irq_chip;
+struct irq_data;
 
 /* Number of irqs reserved for a legacy isa controller */
 #define NUM_ISA_INTERRUPTS      16
@@ -64,6 +67,16 @@ struct irq_domain_ops {
         int (*xlate)(struct irq_domain *d, struct device_node *node,
                      const u32 *intspec, unsigned int intsize,
                      unsigned long *out_hwirq, unsigned int *out_type);
+
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+        /* extended V2 interfaces to support hierarchy irq_domains */
+        int (*alloc)(struct irq_domain *d, unsigned int virq,
+                     unsigned int nr_irqs, void *arg);
+        void (*free)(struct irq_domain *d, unsigned int virq,
+                     unsigned int nr_irqs);
+        void (*activate)(struct irq_domain *d, struct irq_data *irq_data);
+        void (*deactivate)(struct irq_domain *d, struct irq_data *irq_data);
+#endif
 };
 
 extern struct irq_domain_ops irq_generic_chip_ops;
@@ -77,6 +90,7 @@ struct irq_domain_chip_generic;
  * @ops: pointer to irq_domain methods
  * @host_data: private data pointer for use by owner.  Not touched by irq_domain
  *             core code.
+ * @flags: host per irq_domain flags
  *
  * Optional elements
  * @of_node: Pointer to device tree nodes associated with the irq_domain. Used
@@ -84,6 +98,7 @@ struct irq_domain_chip_generic;
  * @gc: Pointer to a list of generic chips. There is a helper function for
  *      setting up one or more generic chips for interrupt controllers
  *      drivers using the generic chip library which uses this pointer.
+ * @parent: Pointer to parent irq_domain to support hierarchy irq_domains
  *
  * Revmap data, used internally by irq_domain
  * @revmap_direct_max_irq: The largest hwirq that can be set for controllers that
@@ -97,10 +112,14 @@ struct irq_domain {
         const char *name;
         const struct irq_domain_ops *ops;
         void *host_data;
+        unsigned int flags;
 
         /* Optional data */
         struct device_node *of_node;
         struct irq_domain_chip_generic *gc;
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+        struct irq_domain *parent;
+#endif
 
         /* reverse map data. The linear map gets appended to the irq_domain */
         irq_hw_number_t hwirq_max;
@@ -110,6 +129,22 @@ struct irq_domain {
         unsigned int linear_revmap[];
 };
 
+/* Irq domain flags */
+enum {
+        /* Irq domain is hierarchical */
+        IRQ_DOMAIN_FLAG_HIERARCHY       = (1 << 0),
+
+        /* Core calls alloc/free recursive through the domain hierarchy. */
+        IRQ_DOMAIN_FLAG_AUTO_RECURSIVE  = (1 << 1),
+
+        /*
+         * Flags starting from IRQ_DOMAIN_FLAG_NONCORE are reserved
+         * for implementation specific purposes and ignored by the
+         * core code.
+         */
+        IRQ_DOMAIN_FLAG_NONCORE         = (1 << 16),
+};
+
 #ifdef CONFIG_IRQ_DOMAIN
 struct irq_domain *__irq_domain_add(struct device_node *of_node, int size,
                                     irq_hw_number_t hwirq_max, int direct_max,
@@ -220,8 +255,74 @@ int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
                         const u32 *intspec, unsigned int intsize,
                         irq_hw_number_t *out_hwirq, unsigned int *out_type);
 
+/* V2 interfaces to support hierarchy IRQ domains. */
+extern struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
+                                                unsigned int virq);
+#ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+extern struct irq_domain *irq_domain_add_hierarchy(struct irq_domain *parent,
+                        unsigned int flags, unsigned int size,
+                        struct device_node *node,
+                        const struct irq_domain_ops *ops, void *host_data);
+extern int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
+                                   unsigned int nr_irqs, int node, void *arg,
+                                   bool realloc);
+extern void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs);
+extern void irq_domain_activate_irq(struct irq_data *irq_data);
+extern void irq_domain_deactivate_irq(struct irq_data *irq_data);
+
+static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
+                        unsigned int nr_irqs, int node, void *arg)
+{
+        return __irq_domain_alloc_irqs(domain, -1, nr_irqs, node, arg, false);
+}
+
+extern int irq_domain_set_hwirq_and_chip(struct irq_domain *domain,
+                                         unsigned int virq,
+                                         irq_hw_number_t hwirq,
+                                         struct irq_chip *chip,
+                                         void *chip_data);
+extern void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
+                                irq_hw_number_t hwirq, struct irq_chip *chip,
+                                void *chip_data, irq_flow_handler_t handler,
+                                void *handler_data, const char *handler_name);
+extern void irq_domain_reset_irq_data(struct irq_data *irq_data);
+extern void irq_domain_free_irqs_common(struct irq_domain *domain,
+                                        unsigned int virq,
+                                        unsigned int nr_irqs);
+extern void irq_domain_free_irqs_top(struct irq_domain *domain,
+                                     unsigned int virq, unsigned int nr_irqs);
+
+extern int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
+                                        unsigned int irq_base,
+                                        unsigned int nr_irqs, void *arg);
+
+extern void irq_domain_free_irqs_parent(struct irq_domain *domain,
+                                        unsigned int irq_base,
+                                        unsigned int nr_irqs);
+
+static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
+{
+        return domain->flags & IRQ_DOMAIN_FLAG_HIERARCHY;
+}
+#else   /* CONFIG_IRQ_DOMAIN_HIERARCHY */
+static inline void irq_domain_activate_irq(struct irq_data *data) { }
+static inline void irq_domain_deactivate_irq(struct irq_data *data) { }
+static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
+                        unsigned int nr_irqs, int node, void *arg)
+{
+        return -1;
+}
+
+static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
+{
+        return false;
+}
+#endif  /* CONFIG_IRQ_DOMAIN_HIERARCHY */
+
 #else /* CONFIG_IRQ_DOMAIN */
 static inline void irq_dispose_mapping(unsigned int virq) { }
+static inline void irq_domain_activate_irq(struct irq_data *data) { }
+static inline void irq_domain_deactivate_irq(struct irq_data *data) { }
 #endif /* !CONFIG_IRQ_DOMAIN */
 
 #endif /* _LINUX_IRQDOMAIN_H */
diff --git a/include/linux/irqhandler.h b/include/linux/irqhandler.h
new file mode 100644
index 000000000000..62d543004197
--- /dev/null
+++ b/include/linux/irqhandler.h
@@ -0,0 +1,14 @@
+#ifndef _LINUX_IRQHANDLER_H
+#define _LINUX_IRQHANDLER_H
+
+/*
+ * Interrupt flow handler typedefs are defined here to avoid circular
+ * include dependencies.
+ */
+
+struct irq_desc;
+struct irq_data;
+typedef void (*irq_flow_handler_t)(unsigned int irq, struct irq_desc *desc);
+typedef void (*irq_preflow_handler_t)(struct irq_data *data);
+
+#endif
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 0dae71e9971c..704b9a599b26 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1042,7 +1042,7 @@ void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
 extern void jbd2_journal_commit_transaction(journal_t *);
 
 /* Checkpoint list management */
-int __jbd2_journal_clean_checkpoint_list(journal_t *journal);
+void __jbd2_journal_clean_checkpoint_list(journal_t *journal);
 int __jbd2_journal_remove_checkpoint(struct journal_head *);
 void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *);
 
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 784304b222b3..98f923b6a0ea 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -8,28 +8,28 @@
  * Copyright (C) 2011-2012 Peter Zijlstra <pzijlstr@redhat.com>
  *
  * Jump labels provide an interface to generate dynamic branches using
- * self-modifying code. Assuming toolchain and architecture support the result
- * of a "if (static_key_false(&key))" statement is a unconditional branch (which
+ * self-modifying code. Assuming toolchain and architecture support, the result
+ * of a "if (static_key_false(&key))" statement is an unconditional branch (which
  * defaults to false - and the true block is placed out of line).
  *
  * However at runtime we can change the branch target using
  * static_key_slow_{inc,dec}(). These function as a 'reference' count on the key
- * object and for as long as there are references all branches referring to
+ * object, and for as long as there are references all branches referring to
  * that particular key will point to the (out of line) true block.
  *
- * Since this relies on modifying code the static_key_slow_{inc,dec}() functions
+ * Since this relies on modifying code, the static_key_slow_{inc,dec}() functions
  * must be considered absolute slow paths (machine wide synchronization etc.).
- * OTOH, since the affected branches are unconditional their runtime overhead
+ * OTOH, since the affected branches are unconditional, their runtime overhead
  * will be absolutely minimal, esp. in the default (off) case where the total
  * effect is a single NOP of appropriate size. The on case will patch in a jump
  * to the out-of-line block.
  *
- * When the control is directly exposed to userspace it is prudent to delay the
+ * When the control is directly exposed to userspace, it is prudent to delay the
  * decrement to avoid high frequency code modifications which can (and do)
  * cause significant performance degradation. Struct static_key_deferred and
  * static_key_slow_dec_deferred() provide for this.
  *
- * Lacking toolchain and or architecture support, it falls back to a simple
+ * Lacking toolchain and or architecture support, jump labels fall back to a simple
  * conditional branch.
  *
  * struct static_key my_key = STATIC_KEY_INIT_TRUE;
@@ -43,8 +43,7 @@
  *
  * Not initializing the key (static data is initialized to 0s anyway) is the
  * same as using STATIC_KEY_INIT_FALSE.
- *
-*/
+ */
 
 #include <linux/types.h>
 #include <linux/compiler.h>
diff --git a/include/linux/kcmp.h b/include/linux/kcmp.h
deleted file mode 100644
index 2dcd1b3aafc8..000000000000
--- a/include/linux/kcmp.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef _LINUX_KCMP_H
-#define _LINUX_KCMP_H
-
-/* Comparison type */
-enum kcmp_type {
-        KCMP_FILE,
-        KCMP_VM,
-        KCMP_FILES,
-        KCMP_FS,
-        KCMP_SIGHAND,
-        KCMP_IO,
-        KCMP_SYSVSEM,
-
-        KCMP_TYPES,
-};
-
-#endif /* _LINUX_KCMP_H */
diff --git a/include/linux/kdb.h b/include/linux/kdb.h
index 290db1269c4c..75ae2e2631fc 100644
--- a/include/linux/kdb.h
+++ b/include/linux/kdb.h
@@ -13,11 +13,54 @@
  * Copyright (C) 2009 Jason Wessel <jason.wessel@windriver.com>
  */
 
+/* Shifted versions of the command enable bits are be used if the command
+ * has no arguments (see kdb_check_flags). This allows commands, such as
+ * go, to have different permissions depending upon whether it is called
+ * with an argument.
+ */
+#define KDB_ENABLE_NO_ARGS_SHIFT 10
+
 typedef enum {
-        KDB_REPEAT_NONE = 0,    /* Do not repeat this command */
-        KDB_REPEAT_NO_ARGS,     /* Repeat the command without arguments */
-        KDB_REPEAT_WITH_ARGS,   /* Repeat the command including its arguments */
-} kdb_repeat_t;
+        KDB_ENABLE_ALL = (1 << 0), /* Enable everything */
+        KDB_ENABLE_MEM_READ = (1 << 1),
+        KDB_ENABLE_MEM_WRITE = (1 << 2),
+        KDB_ENABLE_REG_READ = (1 << 3),
+        KDB_ENABLE_REG_WRITE = (1 << 4),
+        KDB_ENABLE_INSPECT = (1 << 5),
+        KDB_ENABLE_FLOW_CTRL = (1 << 6),
+        KDB_ENABLE_SIGNAL = (1 << 7),
+        KDB_ENABLE_REBOOT = (1 << 8),
+        /* User exposed values stop here, all remaining flags are
+         * exclusively used to describe a commands behaviour.
+         */
+
+        KDB_ENABLE_ALWAYS_SAFE = (1 << 9),
+        KDB_ENABLE_MASK = (1 << KDB_ENABLE_NO_ARGS_SHIFT) - 1,
+
+        KDB_ENABLE_ALL_NO_ARGS = KDB_ENABLE_ALL << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_MEM_READ_NO_ARGS = KDB_ENABLE_MEM_READ
+                                      << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_MEM_WRITE_NO_ARGS = KDB_ENABLE_MEM_WRITE
+                                       << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_REG_READ_NO_ARGS = KDB_ENABLE_REG_READ
+                                      << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_REG_WRITE_NO_ARGS = KDB_ENABLE_REG_WRITE
+                                       << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_INSPECT_NO_ARGS = KDB_ENABLE_INSPECT
+                                     << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_FLOW_CTRL_NO_ARGS = KDB_ENABLE_FLOW_CTRL
+                                       << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_SIGNAL_NO_ARGS = KDB_ENABLE_SIGNAL
+                                    << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_REBOOT_NO_ARGS = KDB_ENABLE_REBOOT
+                                    << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_ALWAYS_SAFE_NO_ARGS = KDB_ENABLE_ALWAYS_SAFE
+                                         << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_MASK_NO_ARGS = KDB_ENABLE_MASK << KDB_ENABLE_NO_ARGS_SHIFT,
+
+        KDB_REPEAT_NO_ARGS = 0x40000000, /* Repeat the command w/o arguments */
+        KDB_REPEAT_WITH_ARGS = 0x80000000, /* Repeat the command with args */
+} kdb_cmdflags_t;
 
 typedef int (*kdb_func_t)(int, const char **);
 
@@ -62,6 +105,7 @@ extern atomic_t kdb_event;
 #define KDB_BADLENGTH   (-19)
 #define KDB_NOBP        (-20)
 #define KDB_BADADDR     (-21)
+#define KDB_NOPERM      (-22)
 
 /*
  * kdb_diemsg
@@ -146,17 +190,17 @@ static inline const char *kdb_walk_kallsyms(loff_t *pos)
 
 /* Dynamic kdb shell command registration */
 extern int kdb_register(char *, kdb_func_t, char *, char *, short);
-extern int kdb_register_repeat(char *, kdb_func_t, char *, char *,
-                               short, kdb_repeat_t);
+extern int kdb_register_flags(char *, kdb_func_t, char *, char *,
+                              short, kdb_cmdflags_t);
 extern int kdb_unregister(char *);
 #else /* ! CONFIG_KGDB_KDB */
 static inline __printf(1, 2) int kdb_printf(const char *fmt, ...) { return 0; }
 static inline void kdb_init(int level) {}
 static inline int kdb_register(char *cmd, kdb_func_t func, char *usage,
                                char *help, short minlen) { return 0; }
-static inline int kdb_register_repeat(char *cmd, kdb_func_t func, char *usage,
-                                      char *help, short minlen,
-                                      kdb_repeat_t repeat) { return 0; }
+static inline int kdb_register_flags(char *cmd, kdb_func_t func, char *usage,
+                                     char *help, short minlen,
+                                     kdb_cmdflags_t flags) { return 0; }
 static inline int kdb_unregister(char *cmd) { return 0; }
 #endif  /* CONFIG_KGDB_KDB */
 enum {
diff --git a/include/linux/kern_levels.h b/include/linux/kern_levels.h
index 866caaa9e2bb..c2ce155d83cc 100644
--- a/include/linux/kern_levels.h
+++ b/include/linux/kern_levels.h
@@ -22,4 +22,17 @@
  */
 #define KERN_CONT       ""
 
+/* integer equivalents of KERN_<LEVEL> */
+#define LOGLEVEL_SCHED          -2      /* Deferred messages from sched code
+                                         * are set to this special level */
+#define LOGLEVEL_DEFAULT        -1      /* default (or last) loglevel */
+#define LOGLEVEL_EMERG          0       /* system is unusable */
+#define LOGLEVEL_ALERT          1       /* action must be taken immediately */
+#define LOGLEVEL_CRIT           2       /* critical conditions */
+#define LOGLEVEL_ERR            3       /* error conditions */
+#define LOGLEVEL_WARNING        4       /* warning conditions */
+#define LOGLEVEL_NOTICE         5       /* normal but significant condition */
+#define LOGLEVEL_INFO           6       /* informational */
+#define LOGLEVEL_DEBUG          7       /* debug-level messages */
+
 #endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 95624bed87ef..5449d2f4a1ef 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -162,6 +162,7 @@ extern int _cond_resched(void);
 #endif
 
 #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
+  void ___might_sleep(const char *file, int line, int preempt_offset);
   void __might_sleep(const char *file, int line, int preempt_offset);
 /**
  * might_sleep - annotation for functions that can sleep
@@ -175,10 +176,14 @@ extern int _cond_resched(void);
  */
 # define might_sleep() \
         do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
+# define sched_annotate_sleep() __set_current_state(TASK_RUNNING)
 #else
+  static inline void ___might_sleep(const char *file, int line,
+                                   int preempt_offset) { }
   static inline void __might_sleep(const char *file, int line,
                                    int preempt_offset) { }
 # define might_sleep() do { might_resched(); } while (0)
+# define sched_annotate_sleep() do { } while (0)
 #endif
 
 #define might_sleep_if(cond) do { if (cond) might_sleep(); } while (0)
@@ -376,10 +381,6 @@ extern unsigned long simple_strtoul(const char *,char **,unsigned int);
 extern long simple_strtol(const char *,char **,unsigned int);
 extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
 extern long long simple_strtoll(const char *,char **,unsigned int);
-#define strict_strtoul  kstrtoul
-#define strict_strtol   kstrtol
-#define strict_strtoull kstrtoull
-#define strict_strtoll  kstrtoll
 
 extern int num_to_str(char *buf, int size, unsigned long long num);
 
@@ -407,6 +408,7 @@ int vsscanf(const char *, const char *, va_list);
 extern int get_option(char **str, int *pint);
 extern char *get_options(const char *str, int nints, int *ints);
 extern unsigned long long memparse(const char *ptr, char **retptr);
+extern bool parse_option_str(const char *str, const char *option);
 
 extern int core_kernel_text(unsigned long addr);
 extern int core_kernel_data(unsigned long addr);
@@ -414,9 +416,6 @@ extern int __kernel_text_address(unsigned long addr);
 extern int kernel_text_address(unsigned long addr);
 extern int func_ptr_is_kernel_text(void *ptr);
 
-struct pid;
-extern struct pid *session_of_pgrp(struct pid *pgrp);
-
 unsigned long int_sqrt(unsigned long);
 
 extern void bust_spinlocks(int yes);
@@ -425,6 +424,7 @@ extern int panic_timeout;
 extern int panic_on_oops;
 extern int panic_on_unrecovered_nmi;
 extern int panic_on_io_nmi;
+extern int panic_on_warn;
 extern int sysctl_panic_on_stackoverflow;
 /*
  * Only to be used by arch init code. If the user over-wrote the default
@@ -496,6 +496,7 @@ static inline char *hex_byte_pack_upper(char *buf, u8 byte)
 
 extern int hex_to_bin(char ch);
 extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
+extern char *bin2hex(char *dst, const void *src, size_t count);
 
 bool mac_pton(const char *s, u8 *mac);
 
@@ -715,23 +716,8 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
         (void) (&_max1 == &_max2);              \
         _max1 > _max2 ? _max1 : _max2; })
 
-#define min3(x, y, z) ({                        \
-        typeof(x) _min1 = (x);                  \
-        typeof(y) _min2 = (y);                  \
-        typeof(z) _min3 = (z);                  \
-        (void) (&_min1 == &_min2);              \
-        (void) (&_min1 == &_min3);              \
-        _min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) : \
-                (_min2 < _min3 ? _min2 : _min3); })
-
-#define max3(x, y, z) ({                        \
-        typeof(x) _max1 = (x);                  \
-        typeof(y) _max2 = (y);                  \
-        typeof(z) _max3 = (z);                  \
-        (void) (&_max1 == &_max2);              \
-        (void) (&_max1 == &_max3);              \
-        _max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) : \
-                (_max2 > _max3 ? _max2 : _max3); })
+#define min3(x, y, z) min((typeof(x))min(x, y), z)
+#define max3(x, y, z) max((typeof(x))max(x, y), z)
 
 /**
  * min_not_zero - return the minimum that is _not_ zero, unless both are zero
@@ -746,20 +732,13 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
 /**
  * clamp - return a value clamped to a given range with strict typechecking
  * @val: current value
- * @min: minimum allowable value
- * @max: maximum allowable value
+ * @lo: lowest allowable value
+ * @hi: highest allowable value
  *
- * This macro does strict typechecking of min/max to make sure they are of the
+ * This macro does strict typechecking of lo/hi to make sure they are of the
  * same type as val.  See the unnecessary pointer comparisons.
  */
-#define clamp(val, min, max) ({                 \
-        typeof(val) __val = (val);              \
-        typeof(min) __min = (min);              \
-        typeof(max) __max = (max);              \
-        (void) (&__val == &__min);              \
-        (void) (&__val == &__max);              \
-        __val = __val < __min ? __min: __val;   \
-        __val > __max ? __max: __val; })
+#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi)
 
 /*
  * ..and if you can't take the strict
@@ -781,36 +760,26 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
  * clamp_t - return a value clamped to a given range using a given type
  * @type: the type of variable to use
  * @val: current value
- * @min: minimum allowable value
- * @max: maximum allowable value
+ * @lo: minimum allowable value
+ * @hi: maximum allowable value
  *
  * This macro does no typechecking and uses temporary variables of type
  * 'type' to make all the comparisons.
  */
-#define clamp_t(type, val, min, max) ({         \
-        type __val = (val);                     \
-        type __min = (min);                     \
-        type __max = (max);                     \
-        __val = __val < __min ? __min: __val;   \
-        __val > __max ? __max: __val; })
+#define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi)
 
 /**
  * clamp_val - return a value clamped to a given range using val's type
  * @val: current value
- * @min: minimum allowable value
- * @max: maximum allowable value
+ * @lo: minimum allowable value
+ * @hi: maximum allowable value
  *
  * This macro does no typechecking and uses temporary variables of whatever
  * type the input argument 'val' is.  This is useful when val is an unsigned
  * type and min and max are literals that will otherwise be assigned a signed
  * integer type.
  */
-#define clamp_val(val, min, max) ({             \
-        typeof(val) __val = (val);              \
-        typeof(val) __min = (min);              \
-        typeof(val) __max = (max);              \
-        __val = __val < __min ? __min: __val;   \
-        __val > __max ? __max: __val; })
+#define clamp_val(val, lo, hi) clamp_t(typeof(val), val, lo, hi)
 
 
 /*
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index ecbc52f9ff77..25a822f6f000 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -44,8 +44,8 @@ DECLARE_PER_CPU(struct kernel_stat, kstat);
 DECLARE_PER_CPU(struct kernel_cpustat, kernel_cpustat);
 
 /* Must have preemption disabled for this to be meaningful. */
-#define kstat_this_cpu (&__get_cpu_var(kstat))
-#define kcpustat_this_cpu (&__get_cpu_var(kernel_cpustat))
+#define kstat_this_cpu this_cpu_ptr(&kstat)
+#define kcpustat_this_cpu this_cpu_ptr(&kernel_cpustat)
 #define kstat_cpu(cpu) per_cpu(kstat, cpu)
 #define kcpustat_cpu(cpu) per_cpu(kernel_cpustat, cpu)
 
@@ -68,6 +68,7 @@ static inline unsigned int kstat_softirqs_cpu(unsigned int irq, int cpu)
  * Number of interrupts per specific IRQ source, since bootup
  */
 extern unsigned int kstat_irqs(unsigned int irq);
+extern unsigned int kstat_irqs_usr(unsigned int irq);
 
 /*
  * Number of interrupts per cpu, since bootup
@@ -77,11 +78,6 @@ static inline unsigned int kstat_cpu_irqs_sum(unsigned int cpu)
         return kstat_cpu(cpu).irqs_sum;
 }
 
-/*
- * Lock/unlock the current runqueue - to extract task statistics:
- */
-extern unsigned long long task_delta_exec(struct task_struct *);
-
 extern void account_user_time(struct task_struct *, cputime_t, cputime_t);
 extern void account_system_time(struct task_struct *, int, cputime_t, cputime_t);
 extern void account_steal_time(cputime_t);
diff --git a/include/linux/kernelcapi.h b/include/linux/kernelcapi.h
index 9be37da93680..e985ba679c4a 100644
--- a/include/linux/kernelcapi.h
+++ b/include/linux/kernelcapi.h
@@ -41,7 +41,7 @@ u16 capi20_get_manufacturer(u32 contr, u8 buf[CAPI_MANUFACTURER_LEN]);
 u16 capi20_get_version(u32 contr, struct capi_version *verp);
 u16 capi20_get_serial(u32 contr, u8 serial[CAPI_SERIAL_LEN]);
 u16 capi20_get_profile(u32 contr, struct capi_profile *profp);
-int capi20_manufacturer(unsigned int cmd, void __user *data);
+int capi20_manufacturer(unsigned long cmd, void __user *data);
 
 #define CAPICTR_UP                      0
 #define CAPICTR_DOWN                    1
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index 30faf797c2c3..d4e01b358341 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -179,6 +179,7 @@ struct kernfs_open_file {
         struct mutex            mutex;
         int                     event;
         struct list_head        list;
+        char                    *prealloc_buf;
 
         size_t                  atomic_write_len;
         bool                    mmapped;
@@ -214,6 +215,13 @@ struct kernfs_ops {
          * larger ones are rejected with -E2BIG.
          */
         size_t atomic_write_len;
+        /*
+         * "prealloc" causes a buffer to be allocated at open for
+         * all read/write requests.  As ->seq_show uses seq_read()
+         * which does its own allocation, it is incompatible with
+         * ->prealloc.  Provide ->read and ->write with ->prealloc.
+         */
+        bool prealloc;
         ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
                          loff_t off);
 
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index 4b2a0e11cc5b..9d957b7ae095 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -178,6 +178,7 @@ struct kexec_buf {
         struct kimage *image;
         char *buffer;
         unsigned long bufsz;
+        unsigned long mem;
         unsigned long memsz;
         unsigned long buf_align;
         unsigned long buf_min;
diff --git a/include/linux/key-type.h b/include/linux/key-type.h
index 44792ee649de..ff9f1d394235 100644
--- a/include/linux/key-type.h
+++ b/include/linux/key-type.h
@@ -53,6 +53,24 @@ typedef int (*request_key_actor_t)(struct key_construction *key,
                                    const char *op, void *aux);
 
 /*
+ * Preparsed matching criterion.
+ */
+struct key_match_data {
+        /* Comparison function, defaults to exact description match, but can be
+         * overridden by type->match_preparse().  Should return true if a match
+         * is found and false if not.
+         */
+        bool (*cmp)(const struct key *key,
+                    const struct key_match_data *match_data);
+
+        const void      *raw_data;      /* Raw match data */
+        void            *preparsed;     /* For ->match_preparse() to stash stuff */
+        unsigned        lookup_type;    /* Type of lookup for this search. */
+#define KEYRING_SEARCH_LOOKUP_DIRECT    0x0000  /* Direct lookup by description. */
+#define KEYRING_SEARCH_LOOKUP_ITERATE   0x0001  /* Iterative search. */
+};
+
+/*
  * kernel managed key type definition
  */
 struct key_type {
@@ -65,11 +83,6 @@ struct key_type {
          */
         size_t def_datalen;
 
-        /* Default key search algorithm. */
-        unsigned def_lookup_type;
-#define KEYRING_SEARCH_LOOKUP_DIRECT    0x0000  /* Direct lookup by description. */
-#define KEYRING_SEARCH_LOOKUP_ITERATE   0x0001  /* Iterative search. */
-
         /* vet a description */
         int (*vet_description)(const char *description);
 
@@ -96,8 +109,15 @@ struct key_type {
          */
         int (*update)(struct key *key, struct key_preparsed_payload *prep);
 
-        /* match a key against a description */
-        int (*match)(const struct key *key, const void *desc);
+        /* Preparse the data supplied to ->match() (optional).  The
+         * data to be preparsed can be found in match_data->raw_data.
+         * The lookup type can also be set by this function.
+         */
+        int (*match_preparse)(struct key_match_data *match_data);
+
+        /* Free preparsed match data (optional).  This should be supplied it
+         * ->match_preparse() is supplied. */
+        void (*match_free)(struct key_match_data *match_data);
 
         /* clear some of the data from a key on revokation (optional)
          * - the key's semaphore will be write-locked by the caller
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index 554fde3a3927..473b43678ad1 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -722,7 +722,7 @@ __kfifo_uint_must_check_helper( \
 /**
  * kfifo_dma_out_finish - finish a DMA OUT operation
  * @fifo: address of the fifo to be used
- * @len: number of bytes transferrd
+ * @len: number of bytes transferred
  *
  * This macro finish a DMA OUT operation. The out counter will be updated by
  * the len parameter. No error checking will be done.
diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h
index 6b06d378f3df..e465bb15912d 100644
--- a/include/linux/kgdb.h
+++ b/include/linux/kgdb.h
@@ -283,7 +283,7 @@ struct kgdb_io {
 
 extern struct kgdb_arch         arch_kgdb_ops;
 
-extern unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs);
+extern unsigned long kgdb_arch_pc(int exception, struct pt_regs *regs);
 
 #ifdef CONFIG_SERIAL_KGDB_NMI
 extern int kgdb_register_nmi_console(void);
diff --git a/include/linux/khugepaged.h b/include/linux/khugepaged.h
index 6b394f0b5148..eeb307985715 100644
--- a/include/linux/khugepaged.h
+++ b/include/linux/khugepaged.h
@@ -6,7 +6,8 @@
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 extern int __khugepaged_enter(struct mm_struct *mm);
 extern void __khugepaged_exit(struct mm_struct *mm);
-extern int khugepaged_enter_vma_merge(struct vm_area_struct *vma);
+extern int khugepaged_enter_vma_merge(struct vm_area_struct *vma,
+                                      unsigned long vm_flags);
 
 #define khugepaged_enabled()                                           \
         (transparent_hugepage_flags &                                  \
@@ -35,13 +36,13 @@ static inline void khugepaged_exit(struct mm_struct *mm)
                 __khugepaged_exit(mm);
 }
 
-static inline int khugepaged_enter(struct vm_area_struct *vma)
+static inline int khugepaged_enter(struct vm_area_struct *vma,
+                                   unsigned long vm_flags)
 {
         if (!test_bit(MMF_VM_HUGEPAGE, &vma->vm_mm->flags))
                 if ((khugepaged_always() ||
-                     (khugepaged_req_madv() &&
-                      vma->vm_flags & VM_HUGEPAGE)) &&
-                    !(vma->vm_flags & VM_NOHUGEPAGE))
+                     (khugepaged_req_madv() && (vm_flags & VM_HUGEPAGE))) &&
+                    !(vm_flags & VM_NOHUGEPAGE))
                         if (__khugepaged_enter(vma->vm_mm))
                                 return -ENOMEM;
         return 0;
@@ -54,11 +55,13 @@ static inline int khugepaged_fork(struct mm_struct *mm, struct mm_struct *oldmm)
 static inline void khugepaged_exit(struct mm_struct *mm)
 {
 }
-static inline int khugepaged_enter(struct vm_area_struct *vma)
+static inline int khugepaged_enter(struct vm_area_struct *vma,
+                                   unsigned long vm_flags)
 {
         return 0;
 }
-static inline int khugepaged_enter_vma_merge(struct vm_area_struct *vma)
+static inline int khugepaged_enter_vma_merge(struct vm_area_struct *vma,
+                                             unsigned long vm_flags)
 {
         return 0;
 }
diff --git a/include/linux/kmemleak.h b/include/linux/kmemleak.h
index 057e95971014..e705467ddb47 100644
--- a/include/linux/kmemleak.h
+++ b/include/linux/kmemleak.h
@@ -21,6 +21,8 @@
 #ifndef __KMEMLEAK_H
 #define __KMEMLEAK_H
 
+#include <linux/slab.h>
+
 #ifdef CONFIG_DEBUG_KMEMLEAK
 
 extern void kmemleak_init(void) __ref;
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index f7296e57d614..5297f9fa0ef2 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -335,6 +335,7 @@ extern void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 extern int arch_prepare_kprobe_ftrace(struct kprobe *p);
 #endif
 
+int arch_check_ftrace_location(struct kprobe *p);
 
 /* Get the kprobe at this addr (if any) - called with preemption disabled */
 struct kprobe *get_kprobe(void *addr);
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index a4c33b34fe3f..26f106022c88 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -43,6 +43,7 @@
  * include/linux/kvm_h.
  */
 #define KVM_MEMSLOT_INVALID     (1UL << 16)
+#define KVM_MEMSLOT_INCOHERENT  (1UL << 17)
 
 /* Two fragments for cross MMIO pages. */
 #define KVM_MAX_MMIO_FRAGMENTS  2
@@ -136,12 +137,11 @@ static inline bool is_error_page(struct page *page)
 #define KVM_REQ_GLOBAL_CLOCK_UPDATE 22
 #define KVM_REQ_ENABLE_IBS        23
 #define KVM_REQ_DISABLE_IBS       24
+#define KVM_REQ_APIC_PAGE_RELOAD  25
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID             0
 #define KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID        1
 
-struct kvm;
-struct kvm_vcpu;
 extern struct kmem_cache *kvm_vcpu_cache;
 
 extern spinlock_t kvm_lock;
@@ -200,6 +200,17 @@ int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, unsigned long hva,
 int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu);
 #endif
 
+/*
+ * Carry out a gup that requires IO. Allow the mm to relinquish the mmap
+ * semaphore if the filemap/swap has to wait on a page lock. pagep == NULL
+ * controls whether we retry the gup one more time to completion in that case.
+ * Typically this is called after a FAULT_FLAG_RETRY_NOWAIT in the main tdp
+ * handler.
+ */
+int kvm_get_user_page_io(struct task_struct *tsk, struct mm_struct *mm,
+                         unsigned long addr, bool write_fault,
+                         struct page **pagep);
+
 enum {
         OUTSIDE_GUEST_MODE,
         IN_GUEST_MODE,
@@ -325,8 +336,6 @@ struct kvm_kernel_irq_routing_entry {
         struct hlist_node link;
 };
 
-struct kvm_irq_routing_table;
-
 #ifndef KVM_PRIVATE_MEM_SLOTS
 #define KVM_PRIVATE_MEM_SLOTS 0
 #endif
@@ -345,6 +354,8 @@ struct kvm_memslots {
         struct kvm_memory_slot memslots[KVM_MEM_SLOTS_NUM];
         /* The mapping table from slot id to the index in memslots[]. */
         short id_to_index[KVM_MEM_SLOTS_NUM];
+        atomic_t lru_slot;
+        int used_slots;
 };
 
 struct kvm {
@@ -387,7 +398,6 @@ struct kvm {
          * Update side is protected by irq_lock.
          */
         struct kvm_irq_routing_table __rcu *irq_routing;
-        struct hlist_head mask_notifier_list;
 #endif
 #ifdef CONFIG_HAVE_KVM_IRQFD
         struct hlist_head irq_ack_notifier_list;
@@ -439,6 +449,14 @@ void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
 int __must_check vcpu_load(struct kvm_vcpu *vcpu);
 void vcpu_put(struct kvm_vcpu *vcpu);
 
+#ifdef __KVM_HAVE_IOAPIC
+void kvm_vcpu_request_scan_ioapic(struct kvm *kvm);
+#else
+static inline void kvm_vcpu_request_scan_ioapic(struct kvm *kvm)
+{
+}
+#endif
+
 #ifdef CONFIG_HAVE_KVM_IRQFD
 int kvm_irqfd_init(void);
 void kvm_irqfd_exit(void);
@@ -528,6 +546,8 @@ struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
 unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
 unsigned long gfn_to_hva_prot(struct kvm *kvm, gfn_t gfn, bool *writable);
 unsigned long gfn_to_hva_memslot(struct kvm_memory_slot *slot, gfn_t gfn);
+unsigned long gfn_to_hva_memslot_prot(struct kvm_memory_slot *slot, gfn_t gfn,
+                                      bool *writable);
 void kvm_release_page_clean(struct page *page);
 void kvm_release_page_dirty(struct page *page);
 void kvm_set_page_accessed(struct page *page);
@@ -579,6 +599,7 @@ void kvm_flush_remote_tlbs(struct kvm *kvm);
 void kvm_reload_remote_mmus(struct kvm *kvm);
 void kvm_make_mclock_inprogress_request(struct kvm *kvm);
 void kvm_make_scan_ioapic_request(struct kvm *kvm);
+bool kvm_make_all_cpus_request(struct kvm *kvm, unsigned int req);
 
 long kvm_arch_dev_ioctl(struct file *filp,
                         unsigned int ioctl, unsigned long arg);
@@ -624,6 +645,8 @@ void kvm_arch_exit(void);
 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
 
+void kvm_arch_sched_in(struct kvm_vcpu *vcpu, int cpu);
+
 void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
@@ -632,8 +655,8 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu);
 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
 
-int kvm_arch_hardware_enable(void *garbage);
-void kvm_arch_hardware_disable(void *garbage);
+int kvm_arch_hardware_enable(void);
+void kvm_arch_hardware_disable(void);
 int kvm_arch_hardware_setup(void);
 void kvm_arch_hardware_unsetup(void);
 void kvm_arch_check_processor_compat(void *rtn);
@@ -690,7 +713,7 @@ void kvm_arch_sync_events(struct kvm *kvm);
 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu);
 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
 
-bool kvm_is_mmio_pfn(pfn_t pfn);
+bool kvm_is_reserved_pfn(pfn_t pfn);
 
 struct kvm_irq_ack_notifier {
         struct hlist_node link;
@@ -698,44 +721,6 @@ struct kvm_irq_ack_notifier {
         void (*irq_acked)(struct kvm_irq_ack_notifier *kian);
 };
 
-struct kvm_assigned_dev_kernel {
-        struct kvm_irq_ack_notifier ack_notifier;
-        struct list_head list;
-        int assigned_dev_id;
-        int host_segnr;
-        int host_busnr;
-        int host_devfn;
-        unsigned int entries_nr;
-        int host_irq;
-        bool host_irq_disabled;
-        bool pci_2_3;
-        struct msix_entry *host_msix_entries;
-        int guest_irq;
-        struct msix_entry *guest_msix_entries;
-        unsigned long irq_requested_type;
-        int irq_source_id;
-        int flags;
-        struct pci_dev *dev;
-        struct kvm *kvm;
-        spinlock_t intx_lock;
-        spinlock_t intx_mask_lock;
-        char irq_name[32];
-        struct pci_saved_state *pci_saved_state;
-};
-
-struct kvm_irq_mask_notifier {
-        void (*func)(struct kvm_irq_mask_notifier *kimn, bool masked);
-        int irq;
-        struct hlist_node link;
-};
-
-void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
-                                    struct kvm_irq_mask_notifier *kimn);
-void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
-                                      struct kvm_irq_mask_notifier *kimn);
-void kvm_fire_mask_notifiers(struct kvm *kvm, unsigned irqchip, unsigned pin,
-                             bool mask);
-
 int kvm_irq_map_gsi(struct kvm *kvm,
                     struct kvm_kernel_irq_routing_entry *entries, int gsi);
 int kvm_irq_map_chip_pin(struct kvm *kvm, unsigned irqchip, unsigned pin);
@@ -757,12 +742,6 @@ void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id);
 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
 int kvm_iommu_map_pages(struct kvm *kvm, struct kvm_memory_slot *slot);
 void kvm_iommu_unmap_pages(struct kvm *kvm, struct kvm_memory_slot *slot);
-int kvm_iommu_map_guest(struct kvm *kvm);
-int kvm_iommu_unmap_guest(struct kvm *kvm);
-int kvm_assign_device(struct kvm *kvm,
-                      struct kvm_assigned_dev_kernel *assigned_dev);
-int kvm_deassign_device(struct kvm *kvm,
-                        struct kvm_assigned_dev_kernel *assigned_dev);
 #else
 static inline int kvm_iommu_map_pages(struct kvm *kvm,
                                       struct kvm_memory_slot *slot)
@@ -774,11 +753,6 @@ static inline void kvm_iommu_unmap_pages(struct kvm *kvm,
                                          struct kvm_memory_slot *slot)
 {
 }
-
-static inline int kvm_iommu_unmap_guest(struct kvm *kvm)
-{
-        return 0;
-}
 #endif
 
 static inline void kvm_guest_enter(void)
@@ -819,12 +793,28 @@ static inline void kvm_guest_exit(void)
 static inline struct kvm_memory_slot *
 search_memslots(struct kvm_memslots *slots, gfn_t gfn)
 {
-        struct kvm_memory_slot *memslot;
+        int start = 0, end = slots->used_slots;
+        int slot = atomic_read(&slots->lru_slot);
+        struct kvm_memory_slot *memslots = slots->memslots;
+
+        if (gfn >= memslots[slot].base_gfn &&
+            gfn < memslots[slot].base_gfn + memslots[slot].npages)
+                return &memslots[slot];
+
+        while (start < end) {
+                slot = start + (end - start) / 2;
+
+                if (gfn >= memslots[slot].base_gfn)
+                        end = slot;
+                else
+                        start = slot + 1;
+        }
 
-        kvm_for_each_memslot(memslot, slots)
-                if (gfn >= memslot->base_gfn &&
-                      gfn < memslot->base_gfn + memslot->npages)
-                        return memslot;
+        if (gfn >= memslots[start].base_gfn &&
+            gfn < memslots[start].base_gfn + memslots[start].npages) {
+                atomic_set(&slots->lru_slot, start);
+                return &memslots[start];
+        }
 
         return NULL;
 }
@@ -998,25 +988,6 @@ static inline bool kvm_vcpu_compatible(struct kvm_vcpu *vcpu) { return true; }
 
 #endif
 
-#ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
-
-long kvm_vm_ioctl_assigned_device(struct kvm *kvm, unsigned ioctl,
-                                  unsigned long arg);
-
-void kvm_free_all_assigned_devices(struct kvm *kvm);
-
-#else
-
-static inline long kvm_vm_ioctl_assigned_device(struct kvm *kvm, unsigned ioctl,
-                                                unsigned long arg)
-{
-        return -ENOTTY;
-}
-
-static inline void kvm_free_all_assigned_devices(struct kvm *kvm) {}
-
-#endif
-
 static inline void kvm_make_request(int req, struct kvm_vcpu *vcpu)
 {
         set_bit(req, &vcpu->requests);
@@ -1034,8 +1005,6 @@ static inline bool kvm_check_request(int req, struct kvm_vcpu *vcpu)
 
 extern bool kvm_rebooting;
 
-struct kvm_device_ops;
-
 struct kvm_device {
         struct kvm_device_ops *ops;
         struct kvm *kvm;
@@ -1068,12 +1037,11 @@ struct kvm_device_ops {
 void kvm_device_get(struct kvm_device *dev);
 void kvm_device_put(struct kvm_device *dev);
 struct kvm_device *kvm_device_from_filp(struct file *filp);
+int kvm_register_device_ops(struct kvm_device_ops *ops, u32 type);
+void kvm_unregister_device_ops(u32 type);
 
 extern struct kvm_device_ops kvm_mpic_ops;
 extern struct kvm_device_ops kvm_xics_ops;
-extern struct kvm_device_ops kvm_vfio_ops;
-extern struct kvm_device_ops kvm_arm_vgic_v2_ops;
-extern struct kvm_device_ops kvm_flic_ops;
 
 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
 
diff --git a/include/linux/kvm_types.h b/include/linux/kvm_types.h
index b0bcce0ddc95..931da7e917cf 100644
--- a/include/linux/kvm_types.h
+++ b/include/linux/kvm_types.h
@@ -17,6 +17,20 @@
 #ifndef __KVM_TYPES_H__
 #define __KVM_TYPES_H__
 
+struct kvm;
+struct kvm_async_pf;
+struct kvm_device_ops;
+struct kvm_interrupt;
+struct kvm_irq_routing_table;
+struct kvm_memory_slot;
+struct kvm_one_reg;
+struct kvm_run;
+struct kvm_userspace_memory_region;
+struct kvm_vcpu;
+struct kvm_vcpu_init;
+
+enum kvm_mr_change;
+
 #include <asm/types.h>
 
 /*
@@ -40,33 +54,6 @@ typedef u64            hfn_t;
 
 typedef hfn_t pfn_t;
 
-union kvm_ioapic_redirect_entry {
-        u64 bits;
-        struct {
-                u8 vector;
-                u8 delivery_mode:3;
-                u8 dest_mode:1;
-                u8 delivery_status:1;
-                u8 polarity:1;
-                u8 remote_irr:1;
-                u8 trig_mode:1;
-                u8 mask:1;
-                u8 reserve:7;
-                u8 reserved[4];
-                u8 dest_id;
-        } fields;
-};
-
-struct kvm_lapic_irq {
-        u32 vector;
-        u32 delivery_mode;
-        u32 dest_mode;
-        u32 level;
-        u32 trig_mode;
-        u32 shorthand;
-        u32 dest_id;
-};
-
 struct gfn_to_hva_cache {
         u64 generation;
         gpa_t gpa;
diff --git a/include/linux/leds.h b/include/linux/leds.h
index e43686472197..cfceef32c9b3 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -13,8 +13,9 @@
 #define __LINUX_LEDS_H_INCLUDED
 
 #include <linux/list.h>
-#include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <linux/rwsem.h>
+#include <linux/spinlock.h>
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 
@@ -31,8 +32,8 @@ enum led_brightness {
 
 struct led_classdev {
         const char              *name;
-        int                      brightness;
-        int                      max_brightness;
+        enum led_brightness      brightness;
+        enum led_brightness      max_brightness;
         int                      flags;
 
         /* Lower 16 bits reflect status */
@@ -42,11 +43,20 @@ struct led_classdev {
 #define LED_BLINK_ONESHOT       (1 << 17)
 #define LED_BLINK_ONESHOT_STOP  (1 << 18)
 #define LED_BLINK_INVERT        (1 << 19)
+#define LED_SYSFS_DISABLE       (1 << 20)
+#define SET_BRIGHTNESS_ASYNC    (1 << 21)
+#define SET_BRIGHTNESS_SYNC     (1 << 22)
 
         /* Set LED brightness level */
         /* Must not sleep, use a workqueue if needed */
         void            (*brightness_set)(struct led_classdev *led_cdev,
                                           enum led_brightness brightness);
+        /*
+         * Set LED brightness level immediately - it can block the caller for
+         * the time required for accessing a LED device register.
+         */
+        int             (*brightness_set_sync)(struct led_classdev *led_cdev,
+                                        enum led_brightness brightness);
         /* Get LED brightness level */
         enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
 
@@ -85,6 +95,9 @@ struct led_classdev {
         /* true if activated - deactivate routine uses it to do cleanup */
         bool                    activated;
 #endif
+
+        /* Ensures consistent access to the LED Flash Class device */
+        struct mutex            led_access;
 };
 
 extern int led_classdev_register(struct device *parent,
@@ -140,6 +153,43 @@ extern void led_blink_set_oneshot(struct led_classdev *led_cdev,
  */
 extern void led_set_brightness(struct led_classdev *led_cdev,
                                enum led_brightness brightness);
+/**
+ * led_update_brightness - update LED brightness
+ * @led_cdev: the LED to query
+ *
+ * Get an LED's current brightness and update led_cdev->brightness
+ * member with the obtained value.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+extern int led_update_brightness(struct led_classdev *led_cdev);
+
+/**
+ * led_sysfs_disable - disable LED sysfs interface
+ * @led_cdev: the LED to set
+ *
+ * Disable the led_cdev's sysfs interface.
+ */
+extern void led_sysfs_disable(struct led_classdev *led_cdev);
+
+/**
+ * led_sysfs_enable - enable LED sysfs interface
+ * @led_cdev: the LED to set
+ *
+ * Enable the led_cdev's sysfs interface.
+ */
+extern void led_sysfs_enable(struct led_classdev *led_cdev);
+
+/**
+ * led_sysfs_is_disabled - check if LED sysfs interface is disabled
+ * @led_cdev: the LED to query
+ *
+ * Returns: true if the led_cdev's sysfs interface is disabled.
+ */
+static inline bool led_sysfs_is_disabled(struct led_classdev *led_cdev)
+{
+        return led_cdev->flags & LED_SYSFS_DISABLE;
+}
 
 /*
  * LED Triggers
@@ -251,6 +301,7 @@ struct gpio_led {
         unsigned        retain_state_suspended : 1;
         unsigned        default_state : 2;
         /* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
+        struct gpio_desc *gpiod;
 };
 #define LEDS_GPIO_DEFSTATE_OFF          0
 #define LEDS_GPIO_DEFSTATE_ON           1
@@ -263,7 +314,7 @@ struct gpio_led_platform_data {
 #define GPIO_LED_NO_BLINK_LOW   0       /* No blink GPIO state low */
 #define GPIO_LED_NO_BLINK_HIGH  1       /* No blink GPIO state high */
 #define GPIO_LED_BLINK          2       /* Please, blink */
-        int             (*gpio_blink_set)(unsigned gpio, int state,
+        int             (*gpio_blink_set)(struct gpio_desc *desc, int state,
                                         unsigned long *delay_on,
                                         unsigned long *delay_off);
 };
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 92abb497ab14..2d182413b1db 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -191,7 +191,8 @@ enum {
         ATA_DEV_PMP_UNSUP       = 6,    /* SATA port multiplier (unsupported) */
         ATA_DEV_SEMB            = 7,    /* SEMB */
         ATA_DEV_SEMB_UNSUP      = 8,    /* SEMB (unsupported) */
-        ATA_DEV_NONE            = 9,    /* no device */
+        ATA_DEV_ZAC             = 9,    /* ZAC device */
+        ATA_DEV_NONE            = 10,   /* no device */
 
         /* struct ata_link flags */
         ATA_LFLAG_NO_HRST       = (1 << 1), /* avoid hardreset */
@@ -1191,9 +1192,9 @@ extern void ata_scsi_unlock_native_capacity(struct scsi_device *sdev);
 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 extern void ata_scsi_slave_destroy(struct scsi_device *sdev);
 extern int ata_scsi_change_queue_depth(struct scsi_device *sdev,
-                                       int queue_depth, int reason);
+                                       int queue_depth);
 extern int __ata_change_queue_depth(struct ata_port *ap, struct scsi_device *sdev,
-                                    int queue_depth, int reason);
+                                    int queue_depth);
 extern struct ata_device *ata_dev_pair(struct ata_device *adev);
 extern int ata_do_set_mode(struct ata_link *link, struct ata_device **r_failed_dev);
 extern void ata_scsi_port_error_handler(struct Scsi_Host *host, struct ata_port *ap);
@@ -1404,14 +1405,14 @@ static inline int sata_srst_pmp(struct ata_link *link)
  * printk helpers
  */
 __printf(3, 4)
-int ata_port_printk(const struct ata_port *ap, const char *level,
-                    const char *fmt, ...);
+void ata_port_printk(const struct ata_port *ap, const char *level,
+                     const char *fmt, ...);
 __printf(3, 4)
-int ata_link_printk(const struct ata_link *link, const char *level,
-                    const char *fmt, ...);
+void ata_link_printk(const struct ata_link *link, const char *level,
+                     const char *fmt, ...);
 __printf(3, 4)
-int ata_dev_printk(const struct ata_device *dev, const char *level,
-                   const char *fmt, ...);
+void ata_dev_printk(const struct ata_device *dev, const char *level,
+                    const char *fmt, ...);
 
 #define ata_port_err(ap, fmt, ...)                              \
         ata_port_printk(ap, KERN_ERR, fmt, ##__VA_ARGS__)
@@ -1491,7 +1492,8 @@ static inline unsigned int ata_tag_internal(unsigned int tag)
 static inline unsigned int ata_class_enabled(unsigned int class)
 {
         return class == ATA_DEV_ATA || class == ATA_DEV_ATAPI ||
-                class == ATA_DEV_PMP || class == ATA_DEV_SEMB;
+                class == ATA_DEV_PMP || class == ATA_DEV_SEMB ||
+                class == ATA_DEV_ZAC;
 }
 
 static inline unsigned int ata_class_disabled(unsigned int class)
diff --git a/include/linux/list.h b/include/linux/list.h
index cbbb96fcead9..feb773c76ee0 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -5,6 +5,7 @@
 #include <linux/stddef.h>
 #include <linux/poison.h>
 #include <linux/const.h>
+#include <linux/kernel.h>
 
 /*
  * Simple doubly linked list implementation.
@@ -345,7 +346,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_entry - get the struct for this entry
  * @ptr:        the &struct list_head pointer.
  * @type:       the type of the struct this is embedded in.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  */
 #define list_entry(ptr, type, member) \
         container_of(ptr, type, member)
@@ -354,7 +355,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_first_entry - get the first element from a list
  * @ptr:        the list head to take the element from.
  * @type:       the type of the struct this is embedded in.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Note, that list is expected to be not empty.
  */
@@ -365,7 +366,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_last_entry - get the last element from a list
  * @ptr:        the list head to take the element from.
  * @type:       the type of the struct this is embedded in.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Note, that list is expected to be not empty.
  */
@@ -376,7 +377,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_first_entry_or_null - get the first element from a list
  * @ptr:        the list head to take the element from.
  * @type:       the type of the struct this is embedded in.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Note that if the list is empty, it returns NULL.
  */
@@ -386,7 +387,7 @@ static inline void list_splice_tail_init(struct list_head *list,
 /**
  * list_next_entry - get the next element in list
  * @pos:        the type * to cursor
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  */
 #define list_next_entry(pos, member) \
         list_entry((pos)->member.next, typeof(*(pos)), member)
@@ -394,7 +395,7 @@ static inline void list_splice_tail_init(struct list_head *list,
 /**
  * list_prev_entry - get the prev element in list
  * @pos:        the type * to cursor
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  */
 #define list_prev_entry(pos, member) \
         list_entry((pos)->member.prev, typeof(*(pos)), member)
@@ -440,7 +441,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_for_each_entry  -       iterate over list of given type
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  */
 #define list_for_each_entry(pos, head, member)                          \
         for (pos = list_first_entry(head, typeof(*pos), member);        \
@@ -451,7 +452,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_for_each_entry_reverse - iterate backwards over list of given type.
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  */
 #define list_for_each_entry_reverse(pos, head, member)                  \
         for (pos = list_last_entry(head, typeof(*pos), member);         \
@@ -462,7 +463,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
  * @pos:        the type * to use as a start point
  * @head:       the head of the list
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
  */
@@ -473,7 +474,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_for_each_entry_continue - continue iteration over list of given type
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Continue to iterate over list of given type, continuing after
  * the current position.
@@ -487,7 +488,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_for_each_entry_continue_reverse - iterate backwards from the given point
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Start to iterate over list of given type backwards, continuing after
  * the current position.
@@ -501,7 +502,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_for_each_entry_from - iterate over list of given type from the current point
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Iterate over list of given type, continuing from current position.
  */
@@ -514,7 +515,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  */
 #define list_for_each_entry_safe(pos, n, head, member)                  \
         for (pos = list_first_entry(head, typeof(*pos), member),        \
@@ -527,7 +528,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Iterate over list of given type, continuing after current point,
  * safe against removal of list entry.
@@ -543,7 +544,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Iterate over list of given type from current point, safe against
  * removal of list entry.
@@ -558,7 +559,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Iterate backwards over list of given type, safe against removal
  * of list entry.
@@ -573,7 +574,7 @@ static inline void list_splice_tail_init(struct list_head *list,
  * list_safe_reset_next - reset a stale list_for_each_entry_safe loop
  * @pos:        the loop cursor used in the list_for_each_entry_safe loop
  * @n:          temporary storage used in list_for_each_entry_safe
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * list_safe_reset_next is not safe to use in general if the list may be
  * modified concurrently (eg. the lock is dropped in the loop body). An
diff --git a/include/linux/lockd/debug.h b/include/linux/lockd/debug.h
index 257d3779f2ab..0ca8109934e4 100644
--- a/include/linux/lockd/debug.h
+++ b/include/linux/lockd/debug.h
@@ -17,12 +17,8 @@
  * Enable lockd debugging.
  * Requires RPC_DEBUG.
  */
-#ifdef RPC_DEBUG
-# define LOCKD_DEBUG            1
-#endif
-
 #undef ifdebug
-#if defined(RPC_DEBUG) && defined(LOCKD_DEBUG)
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 # define ifdebug(flag)          if (unlikely(nlm_debug & NLMDBG_##flag))
 #else
 # define ifdebug(flag)          if (0)
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 219d79627c05..ff82a32871b5 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -178,7 +178,6 @@ struct nlm_block {
         unsigned char           b_granted;      /* VFS granted lock */
         struct nlm_file *       b_file;         /* file in question */
         struct cache_req *      b_cache_req;    /* deferred request handling */
-        struct file_lock *      b_fl;           /* set for GETLK */
         struct cache_deferred_req * b_deferred_req;
         unsigned int            b_flags;        /* block flags */
 #define B_QUEUED                1       /* lock queued */
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 008388f920d7..74ab23176e9b 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -4,7 +4,7 @@
  *  Copyright (C) 2006,2007 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
  *  Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
  *
- * see Documentation/lockdep-design.txt for more details.
+ * see Documentation/locking/lockdep-design.txt for more details.
  */
 #ifndef __LINUX_LOCKDEP_H
 #define __LINUX_LOCKDEP_H
@@ -362,6 +362,10 @@ extern void lockdep_trace_alloc(gfp_t mask);
                 WARN_ON(debug_locks && !lockdep_is_held(l));    \
         } while (0)
 
+#define lockdep_assert_held_once(l)     do {                            \
+                WARN_ON_ONCE(debug_locks && !lockdep_is_held(l));       \
+        } while (0)
+
 #define lockdep_recursing(tsk)  ((tsk)->lockdep_recursion)
 
 #else /* !CONFIG_LOCKDEP */
@@ -412,6 +416,7 @@ struct lock_class_key { };
 #define lockdep_depth(tsk)      (0)
 
 #define lockdep_assert_held(l)                  do { (void)(l); } while (0)
+#define lockdep_assert_held_once(l)             do { (void)(l); } while (0)
 
 #define lockdep_recursing(tsk)                  (0)
 
@@ -505,6 +510,7 @@ static inline void print_irqtrace_events(struct task_struct *curr)
 
 #define lock_map_acquire(l)                     lock_acquire_exclusive(l, 0, 0, NULL, _THIS_IP_)
 #define lock_map_acquire_read(l)                lock_acquire_shared_recursive(l, 0, 0, NULL, _THIS_IP_)
+#define lock_map_acquire_tryread(l)             lock_acquire_shared_recursive(l, 0, 1, NULL, _THIS_IP_)
 #define lock_map_release(l)                     lock_release(l, 1, _THIS_IP_)
 
 #ifdef CONFIG_PROVE_LOCKING
diff --git a/include/linux/mailbox_client.h b/include/linux/mailbox_client.h
new file mode 100644
index 000000000000..1726ccbd8009
--- /dev/null
+++ b/include/linux/mailbox_client.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2013-2014 Linaro Ltd.
+ * Author: Jassi Brar <jassisinghbrar@gmail.com>
+ *
+ * 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 __MAILBOX_CLIENT_H
+#define __MAILBOX_CLIENT_H
+
+#include <linux/of.h>
+#include <linux/device.h>
+
+struct mbox_chan;
+
+/**
+ * struct mbox_client - User of a mailbox
+ * @dev:                The client device
+ * @tx_block:           If the mbox_send_message should block until data is
+ *                      transmitted.
+ * @tx_tout:            Max block period in ms before TX is assumed failure
+ * @knows_txdone:       If the client could run the TX state machine. Usually
+ *                      if the client receives some ACK packet for transmission.
+ *                      Unused if the controller already has TX_Done/RTR IRQ.
+ * @rx_callback:        Atomic callback to provide client the data received
+ * @tx_prepare:         Atomic callback to ask client to prepare the payload
+ *                      before initiating the transmission if required.
+ * @tx_done:            Atomic callback to tell client of data transmission
+ */
+struct mbox_client {
+        struct device *dev;
+        bool tx_block;
+        unsigned long tx_tout;
+        bool knows_txdone;
+
+        void (*rx_callback)(struct mbox_client *cl, void *mssg);
+        void (*tx_prepare)(struct mbox_client *cl, void *mssg);
+        void (*tx_done)(struct mbox_client *cl, void *mssg, int r);
+};
+
+struct mbox_chan *mbox_request_channel(struct mbox_client *cl, int index);
+int mbox_send_message(struct mbox_chan *chan, void *mssg);
+void mbox_client_txdone(struct mbox_chan *chan, int r); /* atomic */
+bool mbox_client_peek_data(struct mbox_chan *chan); /* atomic */
+void mbox_free_channel(struct mbox_chan *chan); /* may sleep */
+
+#endif /* __MAILBOX_CLIENT_H */
diff --git a/include/linux/mailbox_controller.h b/include/linux/mailbox_controller.h
new file mode 100644
index 000000000000..d4cf96f07cfc
--- /dev/null
+++ b/include/linux/mailbox_controller.h
@@ -0,0 +1,133 @@
+/*
+ * 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 __MAILBOX_CONTROLLER_H
+#define __MAILBOX_CONTROLLER_H
+
+#include <linux/of.h>
+#include <linux/types.h>
+#include <linux/timer.h>
+#include <linux/device.h>
+#include <linux/completion.h>
+
+struct mbox_chan;
+
+/**
+ * struct mbox_chan_ops - methods to control mailbox channels
+ * @send_data:  The API asks the MBOX controller driver, in atomic
+ *              context try to transmit a message on the bus. Returns 0 if
+ *              data is accepted for transmission, -EBUSY while rejecting
+ *              if the remote hasn't yet read the last data sent. Actual
+ *              transmission of data is reported by the controller via
+ *              mbox_chan_txdone (if it has some TX ACK irq). It must not
+ *              sleep.
+ * @startup:    Called when a client requests the chan. The controller
+ *              could ask clients for additional parameters of communication
+ *              to be provided via client's chan_data. This call may
+ *              block. After this call the Controller must forward any
+ *              data received on the chan by calling mbox_chan_received_data.
+ *              The controller may do stuff that need to sleep.
+ * @shutdown:   Called when a client relinquishes control of a chan.
+ *              This call may block too. The controller must not forward
+ *              any received data anymore.
+ *              The controller may do stuff that need to sleep.
+ * @last_tx_done: If the controller sets 'txdone_poll', the API calls
+ *                this to poll status of last TX. The controller must
+ *                give priority to IRQ method over polling and never
+ *                set both txdone_poll and txdone_irq. Only in polling
+ *                mode 'send_data' is expected to return -EBUSY.
+ *                The controller may do stuff that need to sleep/block.
+ *                Used only if txdone_poll:=true && txdone_irq:=false
+ * @peek_data: Atomic check for any received data. Return true if controller
+ *                has some data to push to the client. False otherwise.
+ */
+struct mbox_chan_ops {
+        int (*send_data)(struct mbox_chan *chan, void *data);
+        int (*startup)(struct mbox_chan *chan);
+        void (*shutdown)(struct mbox_chan *chan);
+        bool (*last_tx_done)(struct mbox_chan *chan);
+        bool (*peek_data)(struct mbox_chan *chan);
+};
+
+/**
+ * struct mbox_controller - Controller of a class of communication channels
+ * @dev:                Device backing this controller
+ * @ops:                Operators that work on each communication chan
+ * @chans:              Array of channels
+ * @num_chans:          Number of channels in the 'chans' array.
+ * @txdone_irq:         Indicates if the controller can report to API when
+ *                      the last transmitted data was read by the remote.
+ *                      Eg, if it has some TX ACK irq.
+ * @txdone_poll:        If the controller can read but not report the TX
+ *                      done. Ex, some register shows the TX status but
+ *                      no interrupt rises. Ignored if 'txdone_irq' is set.
+ * @txpoll_period:      If 'txdone_poll' is in effect, the API polls for
+ *                      last TX's status after these many millisecs
+ * @of_xlate:           Controller driver specific mapping of channel via DT
+ * @poll:               API private. Used to poll for TXDONE on all channels.
+ * @node:               API private. To hook into list of controllers.
+ */
+struct mbox_controller {
+        struct device *dev;
+        struct mbox_chan_ops *ops;
+        struct mbox_chan *chans;
+        int num_chans;
+        bool txdone_irq;
+        bool txdone_poll;
+        unsigned txpoll_period;
+        struct mbox_chan *(*of_xlate)(struct mbox_controller *mbox,
+                                      const struct of_phandle_args *sp);
+        /* Internal to API */
+        struct timer_list poll;
+        struct list_head node;
+};
+
+/*
+ * The length of circular buffer for queuing messages from a client.
+ * 'msg_count' tracks the number of buffered messages while 'msg_free'
+ * is the index where the next message would be buffered.
+ * We shouldn't need it too big because every transfer is interrupt
+ * triggered and if we have lots of data to transfer, the interrupt
+ * latencies are going to be the bottleneck, not the buffer length.
+ * Besides, mbox_send_message could be called from atomic context and
+ * the client could also queue another message from the notifier 'tx_done'
+ * of the last transfer done.
+ * REVISIT: If too many platforms see the "Try increasing MBOX_TX_QUEUE_LEN"
+ * print, it needs to be taken from config option or somesuch.
+ */
+#define MBOX_TX_QUEUE_LEN       20
+
+/**
+ * struct mbox_chan - s/w representation of a communication chan
+ * @mbox:               Pointer to the parent/provider of this channel
+ * @txdone_method:      Way to detect TXDone chosen by the API
+ * @cl:                 Pointer to the current owner of this channel
+ * @tx_complete:        Transmission completion
+ * @active_req:         Currently active request hook
+ * @msg_count:          No. of mssg currently queued
+ * @msg_free:           Index of next available mssg slot
+ * @msg_data:           Hook for data packet
+ * @lock:               Serialise access to the channel
+ * @con_priv:           Hook for controller driver to attach private data
+ */
+struct mbox_chan {
+        struct mbox_controller *mbox;
+        unsigned txdone_method;
+        struct mbox_client *cl;
+        struct completion tx_complete;
+        void *active_req;
+        unsigned msg_count, msg_free;
+        void *msg_data[MBOX_TX_QUEUE_LEN];
+        spinlock_t lock; /* Serialise access to the channel */
+        void *con_priv;
+};
+
+int mbox_controller_register(struct mbox_controller *mbox); /* can sleep */
+void mbox_controller_unregister(struct mbox_controller *mbox); /* can sleep */
+void mbox_chan_received_data(struct mbox_chan *chan, void *data); /* atomic */
+void mbox_chan_txdone(struct mbox_chan *chan, int r); /* atomic */
+
+#endif /* __MAILBOX_CONTROLLER_H */
diff --git a/include/linux/marvell_phy.h b/include/linux/marvell_phy.h
index 8e9a029e093d..e6982ac3200d 100644
--- a/include/linux/marvell_phy.h
+++ b/include/linux/marvell_phy.h
@@ -16,6 +16,7 @@
 #define MARVELL_PHY_ID_88E1318S         0x01410e90
 #define MARVELL_PHY_ID_88E1116R         0x01410e40
 #define MARVELL_PHY_ID_88E1510          0x01410dd0
+#define MARVELL_PHY_ID_88E3016          0x01410e60
 
 /* struct phy_device dev_flags definitions */
 #define MARVELL_PHY_M1145_FLAGS_RESISTANCE      0x00000001
diff --git a/include/linux/mbus.h b/include/linux/mbus.h
index 550c88fb0267..611b69fa8594 100644
--- a/include/linux/mbus.h
+++ b/include/linux/mbus.h
@@ -61,6 +61,7 @@ static inline const struct mbus_dram_target_info *mv_mbus_dram_info(void)
 }
 #endif
 
+int mvebu_mbus_save_cpu_target(u32 *store_addr);
 void mvebu_mbus_get_pcie_mem_aperture(struct resource *res);
 void mvebu_mbus_get_pcie_io_aperture(struct resource *res);
 int mvebu_mbus_add_window_remap_by_id(unsigned int target,
diff --git a/include/linux/mei_cl_bus.h b/include/linux/mei_cl_bus.h
index d14af7b722ef..164aad1f9f12 100644
--- a/include/linux/mei_cl_bus.h
+++ b/include/linux/mei_cl_bus.h
@@ -3,6 +3,7 @@
 
 #include <linux/device.h>
 #include <linux/uuid.h>
+#include <linux/mod_devicetable.h>
 
 struct mei_cl_device;
 
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index e0752d204d9e..7c95af8d552c 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -25,7 +25,6 @@
 #include <linux/jump_label.h>
 
 struct mem_cgroup;
-struct page_cgroup;
 struct page;
 struct mm_struct;
 struct kmem_cache;
@@ -68,10 +67,9 @@ void mem_cgroup_migrate(struct page *oldpage, struct page *newpage,
 struct lruvec *mem_cgroup_zone_lruvec(struct zone *, struct mem_cgroup *);
 struct lruvec *mem_cgroup_page_lruvec(struct page *, struct zone *);
 
-bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
-                                  struct mem_cgroup *memcg);
-bool task_in_mem_cgroup(struct task_struct *task,
-                        const struct mem_cgroup *memcg);
+bool mem_cgroup_is_descendant(struct mem_cgroup *memcg,
+                              struct mem_cgroup *root);
+bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg);
 
 extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
 extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
@@ -79,15 +77,16 @@ extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
 extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
 extern struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css);
 
-static inline
-bool mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *memcg)
+static inline bool mm_match_cgroup(struct mm_struct *mm,
+                                   struct mem_cgroup *memcg)
 {
         struct mem_cgroup *task_memcg;
-        bool match;
+        bool match = false;
 
         rcu_read_lock();
         task_memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
-        match = __mem_cgroup_same_or_subtree(memcg, task_memcg);
+        if (task_memcg)
+                match = mem_cgroup_is_descendant(task_memcg, memcg);
         rcu_read_unlock();
         return match;
 }
@@ -139,48 +138,23 @@ static inline bool mem_cgroup_disabled(void)
         return false;
 }
 
-void __mem_cgroup_begin_update_page_stat(struct page *page, bool *locked,
-                                         unsigned long *flags);
-
-extern atomic_t memcg_moving;
-
-static inline void mem_cgroup_begin_update_page_stat(struct page *page,
-                                        bool *locked, unsigned long *flags)
-{
-        if (mem_cgroup_disabled())
-                return;
-        rcu_read_lock();
-        *locked = false;
-        if (atomic_read(&memcg_moving))
-                __mem_cgroup_begin_update_page_stat(page, locked, flags);
-}
+struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page, bool *locked,
+                                              unsigned long *flags);
+void mem_cgroup_end_page_stat(struct mem_cgroup *memcg, bool *locked,
+                              unsigned long *flags);
+void mem_cgroup_update_page_stat(struct mem_cgroup *memcg,
+                                 enum mem_cgroup_stat_index idx, int val);
 
-void __mem_cgroup_end_update_page_stat(struct page *page,
-                                unsigned long *flags);
-static inline void mem_cgroup_end_update_page_stat(struct page *page,
-                                        bool *locked, unsigned long *flags)
-{
-        if (mem_cgroup_disabled())
-                return;
-        if (*locked)
-                __mem_cgroup_end_update_page_stat(page, flags);
-        rcu_read_unlock();
-}
-
-void mem_cgroup_update_page_stat(struct page *page,
-                                 enum mem_cgroup_stat_index idx,
-                                 int val);
-
-static inline void mem_cgroup_inc_page_stat(struct page *page,
+static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
                                             enum mem_cgroup_stat_index idx)
 {
-        mem_cgroup_update_page_stat(page, idx, 1);
+        mem_cgroup_update_page_stat(memcg, idx, 1);
 }
 
-static inline void mem_cgroup_dec_page_stat(struct page *page,
+static inline void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
                                             enum mem_cgroup_stat_index idx)
 {
-        mem_cgroup_update_page_stat(page, idx, -1);
+        mem_cgroup_update_page_stat(memcg, idx, -1);
 }
 
 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
@@ -199,10 +173,6 @@ static inline void mem_cgroup_count_vm_event(struct mm_struct *mm,
 void mem_cgroup_split_huge_fixup(struct page *head);
 #endif
 
-#ifdef CONFIG_DEBUG_VM
-bool mem_cgroup_bad_page_check(struct page *page);
-void mem_cgroup_print_bad_page(struct page *page);
-#endif
 #else /* CONFIG_MEMCG */
 struct mem_cgroup;
 
@@ -315,12 +285,13 @@ mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
 {
 }
 
-static inline void mem_cgroup_begin_update_page_stat(struct page *page,
+static inline struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page,
                                         bool *locked, unsigned long *flags)
 {
+        return NULL;
 }
 
-static inline void mem_cgroup_end_update_page_stat(struct page *page,
+static inline void mem_cgroup_end_page_stat(struct mem_cgroup *memcg,
                                         bool *locked, unsigned long *flags)
 {
 }
@@ -343,12 +314,12 @@ static inline bool mem_cgroup_oom_synchronize(bool wait)
         return false;
 }
 
-static inline void mem_cgroup_inc_page_stat(struct page *page,
+static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
                                             enum mem_cgroup_stat_index idx)
 {
 }
 
-static inline void mem_cgroup_dec_page_stat(struct page *page,
+static inline void mem_cgroup_dec_page_stat(struct mem_cgroup *memcg,
                                             enum mem_cgroup_stat_index idx)
 {
 }
@@ -371,19 +342,6 @@ void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
 }
 #endif /* CONFIG_MEMCG */
 
-#if !defined(CONFIG_MEMCG) || !defined(CONFIG_DEBUG_VM)
-static inline bool
-mem_cgroup_bad_page_check(struct page *page)
-{
-        return false;
-}
-
-static inline void
-mem_cgroup_print_bad_page(struct page *page)
-{
-}
-#endif
-
 enum {
         UNDER_LIMIT,
         SOFT_LIMIT,
@@ -440,15 +398,10 @@ void __memcg_kmem_uncharge_pages(struct page *page, int order);
 
 int memcg_cache_id(struct mem_cgroup *memcg);
 
-int memcg_alloc_cache_params(struct mem_cgroup *memcg, struct kmem_cache *s,
-                             struct kmem_cache *root_cache);
-void memcg_free_cache_params(struct kmem_cache *s);
-
-int memcg_update_cache_size(struct kmem_cache *s, int num_groups);
 void memcg_update_array_size(int num_groups);
 
-struct kmem_cache *
-__memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp);
+struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep);
+void __memcg_kmem_put_cache(struct kmem_cache *cachep);
 
 int __memcg_charge_slab(struct kmem_cache *cachep, gfp_t gfp, int order);
 void __memcg_uncharge_slab(struct kmem_cache *cachep, int order);
@@ -476,9 +429,8 @@ memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
         /*
          * __GFP_NOFAIL allocations will move on even if charging is not
          * possible. Therefore we don't even try, and have this allocation
-         * unaccounted. We could in theory charge it with
-         * res_counter_charge_nofail, but we hope those allocations are rare,
-         * and won't be worth the trouble.
+         * unaccounted. We could in theory charge it forcibly, but we hope
+         * those allocations are rare, and won't be worth the trouble.
          */
         if (gfp & __GFP_NOFAIL)
                 return true;
@@ -496,8 +448,6 @@ memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
  * memcg_kmem_uncharge_pages: uncharge pages from memcg
  * @page: pointer to struct page being freed
  * @order: allocation order.
- *
- * there is no need to specify memcg here, since it is embedded in page_cgroup
  */
 static inline void
 memcg_kmem_uncharge_pages(struct page *page, int order)
@@ -514,8 +464,7 @@ memcg_kmem_uncharge_pages(struct page *page, int order)
  *
  * Needs to be called after memcg_kmem_newpage_charge, regardless of success or
  * failure of the allocation. if @page is NULL, this function will revert the
- * charges. Otherwise, it will commit the memcg given by @memcg to the
- * corresponding page_cgroup.
+ * charges. Otherwise, it will commit @page to @memcg.
  */
 static inline void
 memcg_kmem_commit_charge(struct page *page, struct mem_cgroup *memcg, int order)
@@ -543,7 +492,13 @@ memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
         if (unlikely(fatal_signal_pending(current)))
                 return cachep;
 
-        return __memcg_kmem_get_cache(cachep, gfp);
+        return __memcg_kmem_get_cache(cachep);
+}
+
+static __always_inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
+{
+        if (memcg_kmem_enabled())
+                __memcg_kmem_put_cache(cachep);
 }
 #else
 #define for_each_memcg_cache_index(_idx)        \
@@ -574,21 +529,15 @@ static inline int memcg_cache_id(struct mem_cgroup *memcg)
         return -1;
 }
 
-static inline int memcg_alloc_cache_params(struct mem_cgroup *memcg,
-                struct kmem_cache *s, struct kmem_cache *root_cache)
-{
-        return 0;
-}
-
-static inline void memcg_free_cache_params(struct kmem_cache *s)
-{
-}
-
 static inline struct kmem_cache *
 memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
 {
         return cachep;
 }
+
+static inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
+{
+}
 #endif /* CONFIG_MEMCG_KMEM */
 #endif /* _LINUX_MEMCONTROL_H */
 
diff --git a/include/linux/memory.h b/include/linux/memory.h
index bb7384e3c3d8..8b8d8d12348e 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -35,7 +35,7 @@ struct memory_block {
 };
 
 int arch_get_memory_phys_device(unsigned long start_pfn);
-unsigned long __weak memory_block_size_bytes(void);
+unsigned long memory_block_size_bytes(void);
 
 /* These states are exposed to userspace as text strings in sysfs */
 #define MEM_ONLINE              (1<<0) /* exposed to userspace */
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index d9524c49d767..8f1a41951df9 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -84,6 +84,7 @@ extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
 extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
 /* VM interface that may be used by firmware interface */
 extern int online_pages(unsigned long, unsigned long, int);
+extern int test_pages_in_a_zone(unsigned long, unsigned long);
 extern void __offline_isolated_pages(unsigned long, unsigned long);
 
 typedef void (*online_page_callback_t)(struct page *page);
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index f230a978e6ba..3d385c81c153 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -134,9 +134,10 @@ void mpol_free_shared_policy(struct shared_policy *p);
 struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
                                             unsigned long idx);
 
-struct mempolicy *get_vma_policy(struct task_struct *tsk,
-                struct vm_area_struct *vma, unsigned long addr);
-bool vma_policy_mof(struct task_struct *task, struct vm_area_struct *vma);
+struct mempolicy *get_task_policy(struct task_struct *p);
+struct mempolicy *__get_vma_policy(struct vm_area_struct *vma,
+                unsigned long addr);
+bool vma_policy_mof(struct vm_area_struct *vma);
 
 extern void numa_default_policy(void);
 extern void numa_policy_init(void);
diff --git a/include/linux/mfd/abx500/ab8500-sysctrl.h b/include/linux/mfd/abx500/ab8500-sysctrl.h
index adba89d9c660..689312745b2f 100644
--- a/include/linux/mfd/abx500/ab8500-sysctrl.h
+++ b/include/linux/mfd/abx500/ab8500-sysctrl.h
@@ -12,7 +12,6 @@
 
 int ab8500_sysctrl_read(u16 reg, u8 *value);
 int ab8500_sysctrl_write(u16 reg, u8 mask, u8 value);
-void ab8500_restart(char mode, const char *cmd);
 
 #else
 
diff --git a/include/linux/mfd/arizona/core.h b/include/linux/mfd/arizona/core.h
index f34723f7663c..910e3aa1e965 100644
--- a/include/linux/mfd/arizona/core.h
+++ b/include/linux/mfd/arizona/core.h
@@ -141,6 +141,7 @@ struct arizona {
 
         uint16_t dac_comp_coeff;
         uint8_t dac_comp_enabled;
+        struct mutex dac_comp_lock;
 };
 
 int arizona_clk32k_enable(struct arizona *arizona);
diff --git a/include/linux/mfd/arizona/registers.h b/include/linux/mfd/arizona/registers.h
index dbd23c36de21..aacc10d7789c 100644
--- a/include/linux/mfd/arizona/registers.h
+++ b/include/linux/mfd/arizona/registers.h
@@ -27,6 +27,7 @@
 #define ARIZONA_WRITE_SEQUENCER_CTRL_0           0x16
 #define ARIZONA_WRITE_SEQUENCER_CTRL_1           0x17
 #define ARIZONA_WRITE_SEQUENCER_CTRL_2           0x18
+#define ARIZONA_WRITE_SEQUENCER_CTRL_3           0x19
 #define ARIZONA_WRITE_SEQUENCER_PROM             0x1A
 #define ARIZONA_TONE_GENERATOR_1                 0x20
 #define ARIZONA_TONE_GENERATOR_2                 0x21
@@ -70,7 +71,9 @@
 #define ARIZONA_SAMPLE_RATE_3_STATUS             0x10C
 #define ARIZONA_ASYNC_CLOCK_1                    0x112
 #define ARIZONA_ASYNC_SAMPLE_RATE_1              0x113
+#define ARIZONA_ASYNC_SAMPLE_RATE_2              0x114
 #define ARIZONA_ASYNC_SAMPLE_RATE_1_STATUS       0x11B
+#define ARIZONA_ASYNC_SAMPLE_RATE_2_STATUS       0x11C
 #define ARIZONA_OUTPUT_SYSTEM_CLOCK              0x149
 #define ARIZONA_OUTPUT_ASYNC_CLOCK               0x14A
 #define ARIZONA_RATE_ESTIMATOR_1                 0x152
@@ -122,6 +125,8 @@
 #define ARIZONA_MIC_BIAS_CTRL_1                  0x218
 #define ARIZONA_MIC_BIAS_CTRL_2                  0x219
 #define ARIZONA_MIC_BIAS_CTRL_3                  0x21A
+#define ARIZONA_HP_CTRL_1L                       0x225
+#define ARIZONA_HP_CTRL_1R                       0x226
 #define ARIZONA_ACCESSORY_DETECT_MODE_1          0x293
 #define ARIZONA_HEADPHONE_DETECT_1               0x29B
 #define ARIZONA_HEADPHONE_DETECT_2               0x29C
@@ -276,8 +281,16 @@
 #define ARIZONA_AIF2_FRAME_CTRL_2                0x548
 #define ARIZONA_AIF2_FRAME_CTRL_3                0x549
 #define ARIZONA_AIF2_FRAME_CTRL_4                0x54A
+#define ARIZONA_AIF2_FRAME_CTRL_5                0x54B
+#define ARIZONA_AIF2_FRAME_CTRL_6                0x54C
+#define ARIZONA_AIF2_FRAME_CTRL_7                0x54D
+#define ARIZONA_AIF2_FRAME_CTRL_8                0x54E
 #define ARIZONA_AIF2_FRAME_CTRL_11               0x551
 #define ARIZONA_AIF2_FRAME_CTRL_12               0x552
+#define ARIZONA_AIF2_FRAME_CTRL_13               0x553
+#define ARIZONA_AIF2_FRAME_CTRL_14               0x554
+#define ARIZONA_AIF2_FRAME_CTRL_15               0x555
+#define ARIZONA_AIF2_FRAME_CTRL_16               0x556
 #define ARIZONA_AIF2_TX_ENABLES                  0x559
 #define ARIZONA_AIF2_RX_ENABLES                  0x55A
 #define ARIZONA_AIF2_FORCE_WRITE                 0x55B
@@ -1664,16 +1677,30 @@
 /*
  * R275 (0x113) - Async sample rate 1
  */
-#define ARIZONA_ASYNC_SAMPLE_RATE_MASK           0x001F  /* ASYNC_SAMPLE_RATE - [4:0] */
-#define ARIZONA_ASYNC_SAMPLE_RATE_SHIFT               0  /* ASYNC_SAMPLE_RATE - [4:0] */
-#define ARIZONA_ASYNC_SAMPLE_RATE_WIDTH               5  /* ASYNC_SAMPLE_RATE - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_1_MASK         0x001F  /* ASYNC_SAMPLE_RATE_1 - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_1_SHIFT             0  /* ASYNC_SAMPLE_RATE_1 - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_1_WIDTH             5  /* ASYNC_SAMPLE_RATE_1 - [4:0] */
+
+/*
+ * R276 (0x114) - Async sample rate 2
+ */
+#define ARIZONA_ASYNC_SAMPLE_RATE_2_MASK         0x001F  /* ASYNC_SAMPLE_RATE_2 - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_2_SHIFT             0  /* ASYNC_SAMPLE_RATE_2 - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_2_WIDTH             5  /* ASYNC_SAMPLE_RATE_2 - [4:0] */
 
 /*
  * R283 (0x11B) - Async sample rate 1 status
  */
-#define ARIZONA_ASYNC_SAMPLE_RATE_STS_MASK       0x001F  /* ASYNC_SAMPLE_RATE_STS - [4:0] */
-#define ARIZONA_ASYNC_SAMPLE_RATE_STS_SHIFT           0  /* ASYNC_SAMPLE_RATE_STS - [4:0] */
-#define ARIZONA_ASYNC_SAMPLE_RATE_STS_WIDTH           5  /* ASYNC_SAMPLE_RATE_STS - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_1_STS_MASK     0x001F  /* ASYNC_SAMPLE_RATE_1_STS - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_1_STS_SHIFT         0  /* ASYNC_SAMPLE_RATE_1_STS - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_1_STS_WIDTH         5  /* ASYNC_SAMPLE_RATE_1_STS - [4:0] */
+
+/*
+ * R284 (0x11C) - Async sample rate 2 status
+ */
+#define ARIZONA_ASYNC_SAMPLE_RATE_2_STS_MASK     0x001F  /* ASYNC_SAMPLE_RATE_2_STS - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_2_STS_SHIFT         0  /* ASYNC_SAMPLE_RATE_2_STS - [4:0] */
+#define ARIZONA_ASYNC_SAMPLE_RATE_2_STS_WIDTH         5  /* ASYNC_SAMPLE_RATE_2_STS - [4:0] */
 
 /*
  * R329 (0x149) - Output system clock
@@ -2228,6 +2255,46 @@
 #define ARIZONA_MICB3_ENA_WIDTH                       1  /* MICB3_ENA */
 
 /*
+ * R549 (0x225) - HP Ctrl 1L
+ */
+#define ARIZONA_RMV_SHRT_HP1L                    0x4000  /* RMV_SHRT_HP1L */
+#define ARIZONA_RMV_SHRT_HP1L_MASK               0x4000  /* RMV_SHRT_HP1L */
+#define ARIZONA_RMV_SHRT_HP1L_SHIFT                  14  /* RMV_SHRT_HP1L */
+#define ARIZONA_RMV_SHRT_HP1L_WIDTH                   1  /* RMV_SHRT_HP1L */
+#define ARIZONA_HP1L_FLWR                        0x0004  /* HP1L_FLWR */
+#define ARIZONA_HP1L_FLWR_MASK                   0x0004  /* HP1L_FLWR */
+#define ARIZONA_HP1L_FLWR_SHIFT                       2  /* HP1L_FLWR */
+#define ARIZONA_HP1L_FLWR_WIDTH                       1  /* HP1L_FLWR */
+#define ARIZONA_HP1L_SHRTI                       0x0002  /* HP1L_SHRTI */
+#define ARIZONA_HP1L_SHRTI_MASK                  0x0002  /* HP1L_SHRTI */
+#define ARIZONA_HP1L_SHRTI_SHIFT                      1  /* HP1L_SHRTI */
+#define ARIZONA_HP1L_SHRTI_WIDTH                      1  /* HP1L_SHRTI */
+#define ARIZONA_HP1L_SHRTO                       0x0001  /* HP1L_SHRTO */
+#define ARIZONA_HP1L_SHRTO_MASK                  0x0001  /* HP1L_SHRTO */
+#define ARIZONA_HP1L_SHRTO_SHIFT                      0  /* HP1L_SHRTO */
+#define ARIZONA_HP1L_SHRTO_WIDTH                      1  /* HP1L_SHRTO */
+
+/*
+ * R550 (0x226) - HP Ctrl 1R
+ */
+#define ARIZONA_RMV_SHRT_HP1R                    0x4000  /* RMV_SHRT_HP1R */
+#define ARIZONA_RMV_SHRT_HP1R_MASK               0x4000  /* RMV_SHRT_HP1R */
+#define ARIZONA_RMV_SHRT_HP1R_SHIFT                  14  /* RMV_SHRT_HP1R */
+#define ARIZONA_RMV_SHRT_HP1R_WIDTH                   1  /* RMV_SHRT_HP1R */
+#define ARIZONA_HP1R_FLWR                        0x0004  /* HP1R_FLWR */
+#define ARIZONA_HP1R_FLWR_MASK                   0x0004  /* HP1R_FLWR */
+#define ARIZONA_HP1R_FLWR_SHIFT                       2  /* HP1R_FLWR */
+#define ARIZONA_HP1R_FLWR_WIDTH                       1  /* HP1R_FLWR */
+#define ARIZONA_HP1R_SHRTI                       0x0002  /* HP1R_SHRTI */
+#define ARIZONA_HP1R_SHRTI_MASK                  0x0002  /* HP1R_SHRTI */
+#define ARIZONA_HP1R_SHRTI_SHIFT                      1  /* HP1R_SHRTI */
+#define ARIZONA_HP1R_SHRTI_WIDTH                      1  /* HP1R_SHRTI */
+#define ARIZONA_HP1R_SHRTO                       0x0001  /* HP1R_SHRTO */
+#define ARIZONA_HP1R_SHRTO_MASK                  0x0001  /* HP1R_SHRTO */
+#define ARIZONA_HP1R_SHRTO_SHIFT                      0  /* HP1R_SHRTO */
+#define ARIZONA_HP1R_SHRTO_WIDTH                      1  /* HP1R_SHRTO */
+
+/*
  * R659 (0x293) - Accessory Detect Mode 1
  */
 #define ARIZONA_ACCDET_SRC                       0x2000  /* ACCDET_SRC */
diff --git a/include/linux/mfd/atmel-hlcdc.h b/include/linux/mfd/atmel-hlcdc.h
new file mode 100644
index 000000000000..1279ab1644b5
--- /dev/null
+++ b/include/linux/mfd/atmel-hlcdc.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2014 Free Electrons
+ * Copyright (C) 2014 Atmel
+ *
+ * Author: Boris BREZILLON <boris.brezillon@free-electrons.com>
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __LINUX_MFD_HLCDC_H
+#define __LINUX_MFD_HLCDC_H
+
+#include <linux/clk.h>
+#include <linux/regmap.h>
+
+#define ATMEL_HLCDC_CFG(i)              ((i) * 0x4)
+#define ATMEL_HLCDC_SIG_CFG             LCDCFG(5)
+#define ATMEL_HLCDC_HSPOL               BIT(0)
+#define ATMEL_HLCDC_VSPOL               BIT(1)
+#define ATMEL_HLCDC_VSPDLYS             BIT(2)
+#define ATMEL_HLCDC_VSPDLYE             BIT(3)
+#define ATMEL_HLCDC_DISPPOL             BIT(4)
+#define ATMEL_HLCDC_DITHER              BIT(6)
+#define ATMEL_HLCDC_DISPDLY             BIT(7)
+#define ATMEL_HLCDC_MODE_MASK           GENMASK(9, 8)
+#define ATMEL_HLCDC_PP                  BIT(10)
+#define ATMEL_HLCDC_VSPSU               BIT(12)
+#define ATMEL_HLCDC_VSPHO               BIT(13)
+#define ATMEL_HLCDC_GUARDTIME_MASK      GENMASK(20, 16)
+
+#define ATMEL_HLCDC_EN                  0x20
+#define ATMEL_HLCDC_DIS                 0x24
+#define ATMEL_HLCDC_SR                  0x28
+#define ATMEL_HLCDC_IER                 0x2c
+#define ATMEL_HLCDC_IDR                 0x30
+#define ATMEL_HLCDC_IMR                 0x34
+#define ATMEL_HLCDC_ISR                 0x38
+
+#define ATMEL_HLCDC_CLKPOL              BIT(0)
+#define ATMEL_HLCDC_CLKSEL              BIT(2)
+#define ATMEL_HLCDC_CLKPWMSEL           BIT(3)
+#define ATMEL_HLCDC_CGDIS(i)            BIT(8 + (i))
+#define ATMEL_HLCDC_CLKDIV_SHFT         16
+#define ATMEL_HLCDC_CLKDIV_MASK         GENMASK(23, 16)
+#define ATMEL_HLCDC_CLKDIV(div)         ((div - 2) << ATMEL_HLCDC_CLKDIV_SHFT)
+
+#define ATMEL_HLCDC_PIXEL_CLK           BIT(0)
+#define ATMEL_HLCDC_SYNC                BIT(1)
+#define ATMEL_HLCDC_DISP                BIT(2)
+#define ATMEL_HLCDC_PWM                 BIT(3)
+#define ATMEL_HLCDC_SIP                 BIT(4)
+
+#define ATMEL_HLCDC_SOF                 BIT(0)
+#define ATMEL_HLCDC_SYNCDIS             BIT(1)
+#define ATMEL_HLCDC_FIFOERR             BIT(4)
+#define ATMEL_HLCDC_LAYER_STATUS(x)     BIT((x) + 8)
+
+/**
+ * Structure shared by the MFD device and its subdevices.
+ *
+ * @regmap: register map used to access HLCDC IP registers
+ * @periph_clk: the hlcdc peripheral clock
+ * @sys_clk: the hlcdc system clock
+ * @slow_clk: the system slow clk
+ * @irq: the hlcdc irq
+ */
+struct atmel_hlcdc {
+        struct regmap *regmap;
+        struct clk *periph_clk;
+        struct clk *sys_clk;
+        struct clk *slow_clk;
+        int irq;
+};
+
+#endif /* __LINUX_MFD_HLCDC_H */
diff --git a/include/linux/mfd/axp20x.h b/include/linux/mfd/axp20x.h
index d0e31a2287ac..81589d176ae8 100644
--- a/include/linux/mfd/axp20x.h
+++ b/include/linux/mfd/axp20x.h
@@ -14,6 +14,8 @@
 enum {
         AXP202_ID = 0,
         AXP209_ID,
+        AXP288_ID,
+        NR_AXP20X_VARIANTS,
 };
 
 #define AXP20X_DATACACHE(m)             (0x04 + (m))
@@ -49,11 +51,13 @@ enum {
 #define AXP20X_IRQ3_EN                  0x42
 #define AXP20X_IRQ4_EN                  0x43
 #define AXP20X_IRQ5_EN                  0x44
+#define AXP20X_IRQ6_EN                  0x45
 #define AXP20X_IRQ1_STATE               0x48
 #define AXP20X_IRQ2_STATE               0x49
 #define AXP20X_IRQ3_STATE               0x4a
 #define AXP20X_IRQ4_STATE               0x4b
 #define AXP20X_IRQ5_STATE               0x4c
+#define AXP20X_IRQ6_STATE               0x4d
 
 /* ADC */
 #define AXP20X_ACIN_V_ADC_H             0x56
@@ -116,6 +120,15 @@ enum {
 #define AXP20X_CC_CTRL                  0xb8
 #define AXP20X_FG_RES                   0xb9
 
+/* AXP288 specific registers */
+#define AXP288_PMIC_ADC_H               0x56
+#define AXP288_PMIC_ADC_L               0x57
+#define AXP288_ADC_TS_PIN_CTRL          0x84
+
+#define AXP288_PMIC_ADC_EN              0x84
+#define AXP288_FG_TUNE5                 0xed
+
+
 /* Regulators IDs */
 enum {
         AXP20X_LDO1 = 0,
@@ -169,12 +182,58 @@ enum {
         AXP20X_IRQ_GPIO0_INPUT,
 };
 
+enum axp288_irqs {
+        AXP288_IRQ_VBUS_FALL     = 2,
+        AXP288_IRQ_VBUS_RISE,
+        AXP288_IRQ_OV,
+        AXP288_IRQ_FALLING_ALT,
+        AXP288_IRQ_RISING_ALT,
+        AXP288_IRQ_OV_ALT,
+        AXP288_IRQ_DONE          = 10,
+        AXP288_IRQ_CHARGING,
+        AXP288_IRQ_SAFE_QUIT,
+        AXP288_IRQ_SAFE_ENTER,
+        AXP288_IRQ_ABSENT,
+        AXP288_IRQ_APPEND,
+        AXP288_IRQ_QWBTU,
+        AXP288_IRQ_WBTU,
+        AXP288_IRQ_QWBTO,
+        AXP288_IRQ_WBTO,
+        AXP288_IRQ_QCBTU,
+        AXP288_IRQ_CBTU,
+        AXP288_IRQ_QCBTO,
+        AXP288_IRQ_CBTO,
+        AXP288_IRQ_WL2,
+        AXP288_IRQ_WL1,
+        AXP288_IRQ_GPADC,
+        AXP288_IRQ_OT            = 31,
+        AXP288_IRQ_GPIO0,
+        AXP288_IRQ_GPIO1,
+        AXP288_IRQ_POKO,
+        AXP288_IRQ_POKL,
+        AXP288_IRQ_POKS,
+        AXP288_IRQ_POKN,
+        AXP288_IRQ_POKP,
+        AXP288_IRQ_TIMER,
+        AXP288_IRQ_MV_CHNG,
+        AXP288_IRQ_BC_USB_CHNG,
+};
+
+#define AXP288_TS_ADC_H         0x58
+#define AXP288_TS_ADC_L         0x59
+#define AXP288_GP_ADC_H         0x5a
+#define AXP288_GP_ADC_L         0x5b
+
 struct axp20x_dev {
         struct device                   *dev;
         struct i2c_client               *i2c_client;
         struct regmap                   *regmap;
         struct regmap_irq_chip_data     *regmap_irqc;
         long                            variant;
+        int                             nr_cells;
+        struct mfd_cell                 *cells;
+        const struct regmap_config      *regmap_cfg;
+        const struct regmap_irq_chip    *regmap_irq_chip;
 };
 
 #endif /* __LINUX_MFD_AXP20X_H */
diff --git a/include/linux/mfd/core.h b/include/linux/mfd/core.h
index f543de91ce19..a76bc100bf97 100644
--- a/include/linux/mfd/core.h
+++ b/include/linux/mfd/core.h
@@ -44,6 +44,9 @@ struct mfd_cell {
          */
         const char              *of_compatible;
 
+        /* Matches ACPI PNP id, either _HID or _CID */
+        const char              *acpi_pnpid;
+
         /*
          * These resources can be specified relative to the parent device.
          * For accessing hardware you should use resources from the platform dev
@@ -108,6 +111,13 @@ extern int mfd_add_devices(struct device *parent, int id,
                            struct resource *mem_base,
                            int irq_base, struct irq_domain *irq_domain);
 
+static inline int mfd_add_hotplug_devices(struct device *parent,
+                const struct mfd_cell *cells, int n_devs)
+{
+        return mfd_add_devices(parent, PLATFORM_DEVID_AUTO, cells, n_devs,
+                        NULL, 0, NULL);
+}
+
 extern void mfd_remove_devices(struct device *parent);
 
 #endif
diff --git a/include/linux/mfd/cros_ec.h b/include/linux/mfd/cros_ec.h
index fcbe9d129a9d..0e166b92f5b4 100644
--- a/include/linux/mfd/cros_ec.h
+++ b/include/linux/mfd/cros_ec.h
@@ -62,10 +62,6 @@ struct cros_ec_command {
  * @dev: Device pointer
  * @was_wake_device: true if this device was set to wake the system from
  * sleep at the last suspend
- * @cmd_xfer: send command to EC and get response
- *     Returns the number of bytes received if the communication succeeded, but
- *     that doesn't mean the EC was happy with the command. The caller
- *     should check msg.result for the EC's result code.
  *
  * @priv: Private data
  * @irq: Interrupt to use
@@ -82,6 +78,10 @@ struct cros_ec_command {
  * @dout_size: size of dout buffer to allocate (zero to use static dout)
  * @parent: pointer to parent device (e.g. i2c or spi device)
  * @wake_enabled: true if this device can wake the system from sleep
+ * @cmd_xfer: send command to EC and get response
+ *     Returns the number of bytes received if the communication succeeded, but
+ *     that doesn't mean the EC was happy with the command. The caller
+ *     should check msg.result for the EC's result code.
  * @lock: one transaction at a time
  */
 struct cros_ec_device {
@@ -92,8 +92,6 @@ struct cros_ec_device {
         struct device *dev;
         bool was_wake_device;
         struct class *cros_class;
-        int (*cmd_xfer)(struct cros_ec_device *ec,
-                        struct cros_ec_command *msg);
 
         /* These are used to implement the platform-specific interface */
         void *priv;
@@ -104,6 +102,8 @@ struct cros_ec_device {
         int dout_size;
         struct device *parent;
         bool wake_enabled;
+        int (*cmd_xfer)(struct cros_ec_device *ec,
+                        struct cros_ec_command *msg);
         struct mutex lock;
 };
 
@@ -153,6 +153,18 @@ int cros_ec_check_result(struct cros_ec_device *ec_dev,
                          struct cros_ec_command *msg);
 
 /**
+ * cros_ec_cmd_xfer - Send a command to the ChromeOS EC
+ *
+ * Call this to send a command to the ChromeOS EC.  This should be used
+ * instead of calling the EC's cmd_xfer() callback directly.
+ *
+ * @ec_dev: EC device
+ * @msg: Message to write
+ */
+int cros_ec_cmd_xfer(struct cros_ec_device *ec_dev,
+                     struct cros_ec_command *msg);
+
+/**
  * cros_ec_remove - Remove a ChromeOS EC
  *
  * Call this to deregister a ChromeOS EC, then clean up any private data.
diff --git a/include/linux/mfd/cros_ec_commands.h b/include/linux/mfd/cros_ec_commands.h
index 7853a6410d14..a49cd41feea7 100644
--- a/include/linux/mfd/cros_ec_commands.h
+++ b/include/linux/mfd/cros_ec_commands.h
@@ -1928,9 +1928,6 @@ struct ec_response_power_info {
 
 #define EC_CMD_I2C_PASSTHRU 0x9e
 
-/* Slave address is 10 (not 7) bit */
-#define EC_I2C_FLAG_10BIT       (1 << 16)
-
 /* Read data; if not present, message is a write */
 #define EC_I2C_FLAG_READ        (1 << 15)
 
diff --git a/include/linux/mfd/da9052/da9052.h b/include/linux/mfd/da9052/da9052.h
index bba65f51a0b5..c18a4c19d6fc 100644
--- a/include/linux/mfd/da9052/da9052.h
+++ b/include/linux/mfd/da9052/da9052.h
@@ -211,7 +211,7 @@ static inline int da9052_reg_update(struct da9052 *da9052, unsigned char reg,
 int da9052_device_init(struct da9052 *da9052, u8 chip_id);
 void da9052_device_exit(struct da9052 *da9052);
 
-extern struct regmap_config da9052_regmap_config;
+extern const struct regmap_config da9052_regmap_config;
 
 int da9052_irq_init(struct da9052 *da9052);
 int da9052_irq_exit(struct da9052 *da9052);
diff --git a/include/linux/mfd/davinci_voicecodec.h b/include/linux/mfd/davinci_voicecodec.h
index 5166935ce66d..8e1cdbef3dad 100644
--- a/include/linux/mfd/davinci_voicecodec.h
+++ b/include/linux/mfd/davinci_voicecodec.h
@@ -21,7 +21,7 @@
  */
 
 #ifndef __LINUX_MFD_DAVINCI_VOICECODEC_H_
-#define __LINUX_MFD_DAVINIC_VOICECODEC_H_
+#define __LINUX_MFD_DAVINCI_VOICECODEC_H_
 
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
@@ -99,12 +99,6 @@ struct davinci_vcif {
         dma_addr_t dma_rx_addr;
 };
 
-struct cq93vc {
-        struct platform_device *pdev;
-        struct snd_soc_codec *codec;
-        u32 sysclk;
-};
-
 struct davinci_vc;
 
 struct davinci_vc {
@@ -122,7 +116,6 @@ struct davinci_vc {
 
         /* Client devices */
         struct davinci_vcif davinci_vcif;
-        struct cq93vc cq93vc;
 };
 
 #endif
diff --git a/include/linux/mfd/dln2.h b/include/linux/mfd/dln2.h
new file mode 100644
index 000000000000..004b24576da8
--- /dev/null
+++ b/include/linux/mfd/dln2.h
@@ -0,0 +1,103 @@
+#ifndef __LINUX_USB_DLN2_H
+#define __LINUX_USB_DLN2_H
+
+#define DLN2_CMD(cmd, id)               ((cmd) | ((id) << 8))
+
+struct dln2_platform_data {
+        u16 handle;             /* sub-driver handle (internally used only) */
+        u8 port;                /* I2C/SPI port */
+};
+
+/**
+ * dln2_event_cb_t - event callback function signature
+ *
+ * @pdev - the sub-device that registered this callback
+ * @echo - the echo header field received in the message
+ * @data - the data payload
+ * @len  - the data payload length
+ *
+ * The callback function is called in interrupt context and the data payload is
+ * only valid during the call. If the user needs later access of the data, it
+ * must copy it.
+ */
+
+typedef void (*dln2_event_cb_t)(struct platform_device *pdev, u16 echo,
+                                const void *data, int len);
+
+/**
+ * dl2n_register_event_cb - register a callback function for an event
+ *
+ * @pdev - the sub-device that registers the callback
+ * @event - the event for which to register a callback
+ * @event_cb - the callback function
+ *
+ * @return 0 in case of success, negative value in case of error
+ */
+int dln2_register_event_cb(struct platform_device *pdev, u16 event,
+                           dln2_event_cb_t event_cb);
+
+/**
+ * dln2_unregister_event_cb - unregister the callback function for an event
+ *
+ * @pdev - the sub-device that registered the callback
+ * @event - the event for which to register a callback
+ */
+void dln2_unregister_event_cb(struct platform_device *pdev, u16 event);
+
+/**
+ * dln2_transfer - issue a DLN2 command and wait for a response and the
+ * associated data
+ *
+ * @pdev - the sub-device which is issuing this transfer
+ * @cmd - the command to be sent to the device
+ * @obuf - the buffer to be sent to the device; it can be NULL if the user
+ *      doesn't need to transmit data with this command
+ * @obuf_len - the size of the buffer to be sent to the device
+ * @ibuf - any data associated with the response will be copied here; it can be
+ *      NULL if the user doesn't need the response data
+ * @ibuf_len - must be initialized to the input buffer size; it will be modified
+ *      to indicate the actual data transferred;
+ *
+ * @return 0 for success, negative value for errors
+ */
+int dln2_transfer(struct platform_device *pdev, u16 cmd,
+                  const void *obuf, unsigned obuf_len,
+                  void *ibuf, unsigned *ibuf_len);
+
+/**
+ * dln2_transfer_rx - variant of @dln2_transfer() where TX buffer is not needed
+ *
+ * @pdev - the sub-device which is issuing this transfer
+ * @cmd - the command to be sent to the device
+ * @ibuf - any data associated with the response will be copied here; it can be
+ *      NULL if the user doesn't need the response data
+ * @ibuf_len - must be initialized to the input buffer size; it will be modified
+ *      to indicate the actual data transferred;
+ *
+ * @return 0 for success, negative value for errors
+ */
+
+static inline int dln2_transfer_rx(struct platform_device *pdev, u16 cmd,
+                                   void *ibuf, unsigned *ibuf_len)
+{
+        return dln2_transfer(pdev, cmd, NULL, 0, ibuf, ibuf_len);
+}
+
+/**
+ * dln2_transfer_tx - variant of @dln2_transfer() where RX buffer is not needed
+ *
+ * @pdev - the sub-device which is issuing this transfer
+ * @cmd - the command to be sent to the device
+ * @obuf - the buffer to be sent to the device; it can be NULL if the
+ *      user doesn't need to transmit data with this command
+ * @obuf_len - the size of the buffer to be sent to the device
+ *
+ * @return 0 for success, negative value for errors
+ */
+static inline int dln2_transfer_tx(struct platform_device *pdev, u16 cmd,
+                                   const void *obuf, unsigned obuf_len)
+{
+        return dln2_transfer(pdev, cmd, obuf, obuf_len, NULL, NULL);
+}
+
+#endif
diff --git a/include/linux/mfd/hi6421-pmic.h b/include/linux/mfd/hi6421-pmic.h
new file mode 100644
index 000000000000..587273e35acf
--- /dev/null
+++ b/include/linux/mfd/hi6421-pmic.h
@@ -0,0 +1,41 @@
+/*
+ * Header file for device driver Hi6421 PMIC
+ *
+ * Copyright (c) <2011-2014> HiSilicon Technologies Co., Ltd.
+ *              http://www.hisilicon.com
+ * Copyright (c) <2013-2014> Linaro Ltd.
+ *              http://www.linaro.org
+ *
+ * Author: Guodong Xu <guodong.xu@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 __HI6421_PMIC_H
+#define __HI6421_PMIC_H
+
+/* Hi6421 registers are mapped to memory bus in 4 bytes stride */
+#define HI6421_REG_TO_BUS_ADDR(x)       (x << 2)
+
+/* Hi6421 maximum register number */
+#define HI6421_REG_MAX                  0xFF
+
+/* Hi6421 OCP (over current protection) and DEB (debounce) control register */
+#define HI6421_OCP_DEB_CTRL_REG         HI6421_REG_TO_BUS_ADDR(0x51)
+#define HI6421_OCP_DEB_SEL_MASK         0x0C
+#define HI6421_OCP_DEB_SEL_8MS          0x00
+#define HI6421_OCP_DEB_SEL_16MS         0x04
+#define HI6421_OCP_DEB_SEL_32MS         0x08
+#define HI6421_OCP_DEB_SEL_64MS         0x0C
+#define HI6421_OCP_EN_DEBOUNCE_MASK     0x02
+#define HI6421_OCP_EN_DEBOUNCE_ENABLE   0x02
+#define HI6421_OCP_AUTO_STOP_MASK       0x01
+#define HI6421_OCP_AUTO_STOP_ENABLE     0x01
+
+struct hi6421_pmic {
+        struct regmap           *regmap;
+};
+
+#endif          /* __HI6421_PMIC_H */
diff --git a/include/linux/mfd/max14577-private.h b/include/linux/mfd/max14577-private.h
index 499253604026..f01c1fae4d84 100644
--- a/include/linux/mfd/max14577-private.h
+++ b/include/linux/mfd/max14577-private.h
@@ -72,15 +72,33 @@ enum max14577_muic_reg {
         MAX14577_MUIC_REG_END,
 };
 
+/*
+ * Combined charger types for max14577 and max77836.
+ *
+ * On max14577 three lower bits map to STATUS2/CHGTYP field.
+ * However the max77836 has different two last values of STATUS2/CHGTYP.
+ * To indicate the difference enum has two additional values for max77836.
+ * These values are just a register value bitwise OR with 0x8.
+ */
 enum max14577_muic_charger_type {
-        MAX14577_CHARGER_TYPE_NONE = 0,
-        MAX14577_CHARGER_TYPE_USB,
-        MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT,
-        MAX14577_CHARGER_TYPE_DEDICATED_CHG,
-        MAX14577_CHARGER_TYPE_SPECIAL_500MA,
-        MAX14577_CHARGER_TYPE_SPECIAL_1A,
-        MAX14577_CHARGER_TYPE_RESERVED,
-        MAX14577_CHARGER_TYPE_DEAD_BATTERY = 7,
+        MAX14577_CHARGER_TYPE_NONE              = 0x0,
+        MAX14577_CHARGER_TYPE_USB               = 0x1,
+        MAX14577_CHARGER_TYPE_DOWNSTREAM_PORT   = 0x2,
+        MAX14577_CHARGER_TYPE_DEDICATED_CHG     = 0x3,
+        MAX14577_CHARGER_TYPE_SPECIAL_500MA     = 0x4,
+        /* Special 1A or 2A charger */
+        MAX14577_CHARGER_TYPE_SPECIAL_1A        = 0x5,
+        /* max14577: reserved, used on max77836 */
+        MAX14577_CHARGER_TYPE_RESERVED          = 0x6,
+        /* max14577: dead-battery charing with maximum current 100mA */
+        MAX14577_CHARGER_TYPE_DEAD_BATTERY      = 0x7,
+        /*
+         * max77836: special charger (bias on D+/D-),
+         * matches register value of 0x6
+         */
+        MAX77836_CHARGER_TYPE_SPECIAL_BIAS      = 0xe,
+        /* max77836: reserved, register value 0x7 */
+        MAX77836_CHARGER_TYPE_RESERVED          = 0xf,
 };
 
 /* MAX14577 interrupts */
@@ -121,13 +139,15 @@ enum max14577_muic_charger_type {
 #define STATUS2_CHGTYP_SHIFT            0
 #define STATUS2_CHGDETRUN_SHIFT         3
 #define STATUS2_DCDTMR_SHIFT            4
-#define STATUS2_DBCHG_SHIFT             5
+#define MAX14577_STATUS2_DBCHG_SHIFT    5
+#define MAX77836_STATUS2_DXOVP_SHIFT    5
 #define STATUS2_VBVOLT_SHIFT            6
 #define MAX77836_STATUS2_VIDRM_SHIFT    7
 #define STATUS2_CHGTYP_MASK             (0x7 << STATUS2_CHGTYP_SHIFT)
 #define STATUS2_CHGDETRUN_MASK          BIT(STATUS2_CHGDETRUN_SHIFT)
 #define STATUS2_DCDTMR_MASK             BIT(STATUS2_DCDTMR_SHIFT)
-#define STATUS2_DBCHG_MASK              BIT(STATUS2_DBCHG_SHIFT)
+#define MAX14577_STATUS2_DBCHG_MASK     BIT(MAX14577_STATUS2_DBCHG_SHIFT)
+#define MAX77836_STATUS2_DXOVP_MASK     BIT(MAX77836_STATUS2_DXOVP_SHIFT)
 #define STATUS2_VBVOLT_MASK             BIT(STATUS2_VBVOLT_SHIFT)
 #define MAX77836_STATUS2_VIDRM_MASK     BIT(MAX77836_STATUS2_VIDRM_SHIFT)
 
@@ -177,9 +197,11 @@ enum max14577_muic_charger_type {
 #define CTRL3_JIGSET_SHIFT              0
 #define CTRL3_BOOTSET_SHIFT             2
 #define CTRL3_ADCDBSET_SHIFT            4
+#define CTRL3_WBTH_SHIFT                6
 #define CTRL3_JIGSET_MASK               (0x3 << CTRL3_JIGSET_SHIFT)
 #define CTRL3_BOOTSET_MASK              (0x3 << CTRL3_BOOTSET_SHIFT)
 #define CTRL3_ADCDBSET_MASK             (0x3 << CTRL3_ADCDBSET_SHIFT)
+#define CTRL3_WBTH_MASK                 (0x3 << CTRL3_WBTH_SHIFT)
 
 /* Slave addr = 0x4A: Charger */
 enum max14577_charger_reg {
@@ -210,16 +232,20 @@ enum max14577_charger_reg {
 #define CDETCTRL1_CHGTYPMAN_SHIFT       1
 #define CDETCTRL1_DCDEN_SHIFT           2
 #define CDETCTRL1_DCD2SCT_SHIFT         3
-#define CDETCTRL1_DCHKTM_SHIFT          4
-#define CDETCTRL1_DBEXIT_SHIFT          5
+#define MAX14577_CDETCTRL1_DCHKTM_SHIFT 4
+#define MAX77836_CDETCTRL1_CDLY_SHIFT   4
+#define MAX14577_CDETCTRL1_DBEXIT_SHIFT 5
+#define MAX77836_CDETCTRL1_DCDCPL_SHIFT 5
 #define CDETCTRL1_DBIDLE_SHIFT          6
 #define CDETCTRL1_CDPDET_SHIFT          7
 #define CDETCTRL1_CHGDETEN_MASK         BIT(CDETCTRL1_CHGDETEN_SHIFT)
 #define CDETCTRL1_CHGTYPMAN_MASK        BIT(CDETCTRL1_CHGTYPMAN_SHIFT)
 #define CDETCTRL1_DCDEN_MASK            BIT(CDETCTRL1_DCDEN_SHIFT)
 #define CDETCTRL1_DCD2SCT_MASK          BIT(CDETCTRL1_DCD2SCT_SHIFT)
-#define CDETCTRL1_DCHKTM_MASK           BIT(CDETCTRL1_DCHKTM_SHIFT)
-#define CDETCTRL1_DBEXIT_MASK           BIT(CDETCTRL1_DBEXIT_SHIFT)
+#define MAX14577_CDETCTRL1_DCHKTM_MASK  BIT(MAX14577_CDETCTRL1_DCHKTM_SHIFT)
+#define MAX77836_CDETCTRL1_CDDLY_MASK   BIT(MAX77836_CDETCTRL1_CDDLY_SHIFT)
+#define MAX14577_CDETCTRL1_DBEXIT_MASK  BIT(MAX14577_CDETCTRL1_DBEXIT_SHIFT)
+#define MAX77836_CDETCTRL1_DCDCPL_MASK  BIT(MAX77836_CDETCTRL1_DCDCPL_SHIFT)
 #define CDETCTRL1_DBIDLE_MASK           BIT(CDETCTRL1_DBIDLE_SHIFT)
 #define CDETCTRL1_CDPDET_MASK           BIT(CDETCTRL1_CDPDET_SHIFT)
 
@@ -255,17 +281,36 @@ enum max14577_charger_reg {
 #define CHGCTRL7_OTPCGHCVS_SHIFT        0
 #define CHGCTRL7_OTPCGHCVS_MASK         (0x3 << CHGCTRL7_OTPCGHCVS_SHIFT)
 
-/* MAX14577 regulator current limits (as in CHGCTRL4 register), uA */
-#define MAX14577_REGULATOR_CURRENT_LIMIT_MIN             90000
-#define MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_START     200000
-#define MAX14577_REGULATOR_CURRENT_LIMIT_HIGH_STEP       50000
-#define MAX14577_REGULATOR_CURRENT_LIMIT_MAX            950000
-
-/* MAX77836 regulator current limits (as in CHGCTRL4 register), uA */
-#define MAX77836_REGULATOR_CURRENT_LIMIT_MIN             45000
-#define MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_START     100000
-#define MAX77836_REGULATOR_CURRENT_LIMIT_HIGH_STEP       25000
-#define MAX77836_REGULATOR_CURRENT_LIMIT_MAX            475000
+/* MAX14577 charger current limits (as in CHGCTRL4 register), uA */
+#define MAX14577_CHARGER_CURRENT_LIMIT_MIN               90000U
+#define MAX14577_CHARGER_CURRENT_LIMIT_HIGH_START       200000U
+#define MAX14577_CHARGER_CURRENT_LIMIT_HIGH_STEP         50000U
+#define MAX14577_CHARGER_CURRENT_LIMIT_MAX              950000U
+
+/* MAX77836 charger current limits (as in CHGCTRL4 register), uA */
+#define MAX77836_CHARGER_CURRENT_LIMIT_MIN               45000U
+#define MAX77836_CHARGER_CURRENT_LIMIT_HIGH_START       100000U
+#define MAX77836_CHARGER_CURRENT_LIMIT_HIGH_STEP         25000U
+#define MAX77836_CHARGER_CURRENT_LIMIT_MAX              475000U
+
+/*
+ * MAX14577 charger End-Of-Charge current limits
+ * (as in CHGCTRL5 register), uA
+ */
+#define MAX14577_CHARGER_EOC_CURRENT_LIMIT_MIN          50000U
+#define MAX14577_CHARGER_EOC_CURRENT_LIMIT_STEP         10000U
+#define MAX14577_CHARGER_EOC_CURRENT_LIMIT_MAX          200000U
+
+/*
+ * MAX14577/MAX77836 Battery Constant Voltage
+ * (as in CHGCTRL3 register), uV
+ */
+#define MAXIM_CHARGER_CONSTANT_VOLTAGE_MIN              4000000U
+#define MAXIM_CHARGER_CONSTANT_VOLTAGE_STEP             20000U
+#define MAXIM_CHARGER_CONSTANT_VOLTAGE_MAX              4350000U
+
+/* Default value for fast charge timer, in hours */
+#define MAXIM_CHARGER_FAST_CHARGE_TIMER_DEFAULT         5
 
 /* MAX14577 regulator SFOUT LDO voltage, fixed, uV */
 #define MAX14577_REGULATOR_SAFEOUT_VOLTAGE              4900000
diff --git a/include/linux/mfd/max14577.h b/include/linux/mfd/max14577.h
index c83fbed1c7b6..ccfaf952c31b 100644
--- a/include/linux/mfd/max14577.h
+++ b/include/linux/mfd/max14577.h
@@ -54,6 +54,13 @@ struct max14577_regulator_platform_data {
         struct device_node *of_node;
 };
 
+struct max14577_charger_platform_data {
+        u32 constant_uvolt;
+        u32 fast_charge_uamp;
+        u32 eoc_uamp;
+        u32 ovp_uvolt;
+};
+
 /*
  * MAX14577 MFD platform data
  */
@@ -74,4 +81,27 @@ struct max14577_platform_data {
         struct max14577_regulator_platform_data *regulators;
 };
 
+/*
+ * Valid limits of current for max14577 and max77836 chargers.
+ * They must correspond to MBCICHWRCL and MBCICHWRCH fields in CHGCTRL4
+ * register for given chipset.
+ */
+struct maxim_charger_current {
+        /* Minimal current, set in CHGCTRL4/MBCICHWRCL, uA */
+        unsigned int min;
+        /*
+         * Minimal current when high setting is active,
+         * set in CHGCTRL4/MBCICHWRCH, uA
+         */
+        unsigned int high_start;
+        /* Value of one step in high setting, uA */
+        unsigned int high_step;
+        /* Maximum current of high setting, uA */
+        unsigned int max;
+};
+
+extern const struct maxim_charger_current maxim_charger_currents[];
+extern int maxim_charger_calc_reg_current(const struct maxim_charger_current *limits,
+                unsigned int min_ua, unsigned int max_ua, u8 *dst);
+
 #endif /* __MAX14577_H__ */
diff --git a/include/linux/mfd/max77686.h b/include/linux/mfd/max77686.h
index 7e6dc4b2b795..553f7d09258a 100644
--- a/include/linux/mfd/max77686.h
+++ b/include/linux/mfd/max77686.h
@@ -131,13 +131,6 @@ enum max77686_opmode {
         MAX77686_OPMODE_STANDBY,
 };
 
-enum max77802_opmode {
-        MAX77802_OPMODE_OFF,
-        MAX77802_OPMODE_STANDBY,
-        MAX77802_OPMODE_LP,
-        MAX77802_OPMODE_NORMAL,
-};
-
 struct max77686_opmode_data {
         int id;
         int mode;
diff --git a/include/linux/mfd/max77693-private.h b/include/linux/mfd/max77693-private.h
index d0e578fd7053..08dae01258b9 100644
--- a/include/linux/mfd/max77693-private.h
+++ b/include/linux/mfd/max77693-private.h
@@ -26,7 +26,6 @@
 
 #include <linux/i2c.h>
 
-#define MAX77693_NUM_IRQ_MUIC_REGS      3
 #define MAX77693_REG_INVALID            (0xff)
 
 /* Slave addr = 0xCC: PMIC, Charger, Flash LED */
@@ -46,7 +45,7 @@ enum max77693_pmic_reg {
         MAX77693_LED_REG_VOUT_FLASH2                    = 0x0C,
         MAX77693_LED_REG_FLASH_INT                      = 0x0E,
         MAX77693_LED_REG_FLASH_INT_MASK                 = 0x0F,
-        MAX77693_LED_REG_FLASH_INT_STATUS               = 0x10,
+        MAX77693_LED_REG_FLASH_STATUS                   = 0x10,
 
         MAX77693_PMIC_REG_PMIC_ID1                      = 0x20,
         MAX77693_PMIC_REG_PMIC_ID2                      = 0x21,
@@ -85,6 +84,65 @@ enum max77693_pmic_reg {
         MAX77693_PMIC_REG_END,
 };
 
+/* MAX77693 ITORCH register */
+#define TORCH_IOUT1_SHIFT       0
+#define TORCH_IOUT2_SHIFT       4
+#define TORCH_IOUT_MIN          15625
+#define TORCH_IOUT_MAX          250000
+#define TORCH_IOUT_STEP         15625
+
+/* MAX77693 IFLASH1 and IFLASH2 registers */
+#define FLASH_IOUT_MIN          15625
+#define FLASH_IOUT_MAX_1LED     1000000
+#define FLASH_IOUT_MAX_2LEDS    625000
+#define FLASH_IOUT_STEP         15625
+
+/* MAX77693 TORCH_TIMER register */
+#define TORCH_TMR_NO_TIMER      0x40
+#define TORCH_TIMEOUT_MIN       262000
+#define TORCH_TIMEOUT_MAX       15728000
+
+/* MAX77693 FLASH_TIMER register */
+#define FLASH_TMR_LEVEL         0x80
+#define FLASH_TIMEOUT_MIN       62500
+#define FLASH_TIMEOUT_MAX       1000000
+#define FLASH_TIMEOUT_STEP      62500
+
+/* MAX77693 FLASH_EN register */
+#define FLASH_EN_OFF            0x0
+#define FLASH_EN_FLASH          0x1
+#define FLASH_EN_TORCH          0x2
+#define FLASH_EN_ON             0x3
+#define FLASH_EN_SHIFT(x)       (6 - ((x) - 1) * 2)
+#define TORCH_EN_SHIFT(x)       (2 - ((x) - 1) * 2)
+
+/* MAX77693 MAX_FLASH1 register */
+#define MAX_FLASH1_MAX_FL_EN    0x80
+#define MAX_FLASH1_VSYS_MIN     2400
+#define MAX_FLASH1_VSYS_MAX     3400
+#define MAX_FLASH1_VSYS_STEP    33
+
+/* MAX77693 VOUT_CNTL register */
+#define FLASH_BOOST_FIXED       0x04
+#define FLASH_BOOST_LEDNUM_2    0x80
+
+/* MAX77693 VOUT_FLASH1 register */
+#define FLASH_VOUT_MIN          3300
+#define FLASH_VOUT_MAX          5500
+#define FLASH_VOUT_STEP         25
+#define FLASH_VOUT_RMIN         0x0c
+
+/* MAX77693 FLASH_STATUS register */
+#define FLASH_STATUS_FLASH_ON   BIT(3)
+#define FLASH_STATUS_TORCH_ON   BIT(2)
+
+/* MAX77693 FLASH_INT register */
+#define FLASH_INT_FLED2_OPEN    BIT(0)
+#define FLASH_INT_FLED2_SHORT   BIT(1)
+#define FLASH_INT_FLED1_OPEN    BIT(2)
+#define FLASH_INT_FLED1_SHORT   BIT(3)
+#define FLASH_INT_OVER_CURRENT  BIT(4)
+
 /* MAX77693 CHG_CNFG_00 register */
 #define CHG_CNFG_00_CHG_MASK            0x1
 #define CHG_CNFG_00_BUCK_MASK           0x4
@@ -271,6 +329,13 @@ enum max77693_irq_source {
         MAX77693_IRQ_GROUP_NR,
 };
 
+#define SRC_IRQ_CHARGER                 BIT(0)
+#define SRC_IRQ_TOP                     BIT(1)
+#define SRC_IRQ_FLASH                   BIT(2)
+#define SRC_IRQ_MUIC                    BIT(3)
+#define SRC_IRQ_ALL                     (SRC_IRQ_CHARGER | SRC_IRQ_TOP \
+                                                | SRC_IRQ_FLASH | SRC_IRQ_MUIC)
+
 #define LED_IRQ_FLED2_OPEN              BIT(0)
 #define LED_IRQ_FLED2_SHORT             BIT(1)
 #define LED_IRQ_FLED1_OPEN              BIT(2)
diff --git a/include/linux/mfd/max77693.h b/include/linux/mfd/max77693.h
index 3f3dc45f93ee..f0b6585cd874 100644
--- a/include/linux/mfd/max77693.h
+++ b/include/linux/mfd/max77693.h
@@ -63,6 +63,45 @@ struct max77693_muic_platform_data {
         int path_uart;
 };
 
+/* MAX77693 led flash */
+
+/* triggers */
+enum max77693_led_trigger {
+        MAX77693_LED_TRIG_OFF,
+        MAX77693_LED_TRIG_FLASH,
+        MAX77693_LED_TRIG_TORCH,
+        MAX77693_LED_TRIG_EXT,
+        MAX77693_LED_TRIG_SOFT,
+};
+
+/* trigger types */
+enum max77693_led_trigger_type {
+        MAX77693_LED_TRIG_TYPE_EDGE,
+        MAX77693_LED_TRIG_TYPE_LEVEL,
+};
+
+/* boost modes */
+enum max77693_led_boost_mode {
+        MAX77693_LED_BOOST_NONE,
+        MAX77693_LED_BOOST_ADAPTIVE,
+        MAX77693_LED_BOOST_FIXED,
+};
+
+struct max77693_led_platform_data {
+        u32 fleds[2];
+        u32 iout_torch[2];
+        u32 iout_flash[2];
+        u32 trigger[2];
+        u32 trigger_type[2];
+        u32 num_leds;
+        u32 boost_mode;
+        u32 flash_timeout;
+        u32 boost_vout;
+        u32 low_vsys;
+};
+
+/* MAX77693 */
+
 struct max77693_platform_data {
         /* regulator data */
         struct max77693_regulator_data *regulators;
@@ -70,5 +109,6 @@ struct max77693_platform_data {
 
         /* muic data */
         struct max77693_muic_platform_data *muic_data;
+        struct max77693_led_platform_data *led_data;
 };
 #endif  /* __LINUX_MFD_MAX77693_H */
diff --git a/include/linux/mfd/rk808.h b/include/linux/mfd/rk808.h
new file mode 100644
index 000000000000..fb09312d854b
--- /dev/null
+++ b/include/linux/mfd/rk808.h
@@ -0,0 +1,196 @@
+/*
+ * rk808.h for Rockchip RK808
+ *
+ * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
+ *
+ * Author: Chris Zhong <zyw@rock-chips.com>
+ * Author: Zhang Qing <zhangqing@rock-chips.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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_REGULATOR_rk808_H
+#define __LINUX_REGULATOR_rk808_H
+
+#include <linux/regulator/machine.h>
+#include <linux/regmap.h>
+
+/*
+ * rk808 Global Register Map.
+ */
+
+#define RK808_DCDC1     0 /* (0+RK808_START) */
+#define RK808_LDO1      4 /* (4+RK808_START) */
+#define RK808_NUM_REGULATORS   14
+
+enum rk808_reg {
+        RK808_ID_DCDC1,
+        RK808_ID_DCDC2,
+        RK808_ID_DCDC3,
+        RK808_ID_DCDC4,
+        RK808_ID_LDO1,
+        RK808_ID_LDO2,
+        RK808_ID_LDO3,
+        RK808_ID_LDO4,
+        RK808_ID_LDO5,
+        RK808_ID_LDO6,
+        RK808_ID_LDO7,
+        RK808_ID_LDO8,
+        RK808_ID_SWITCH1,
+        RK808_ID_SWITCH2,
+};
+
+#define RK808_SECONDS_REG       0x00
+#define RK808_MINUTES_REG       0x01
+#define RK808_HOURS_REG         0x02
+#define RK808_DAYS_REG          0x03
+#define RK808_MONTHS_REG        0x04
+#define RK808_YEARS_REG         0x05
+#define RK808_WEEKS_REG         0x06
+#define RK808_ALARM_SECONDS_REG 0x08
+#define RK808_ALARM_MINUTES_REG 0x09
+#define RK808_ALARM_HOURS_REG   0x0a
+#define RK808_ALARM_DAYS_REG    0x0b
+#define RK808_ALARM_MONTHS_REG  0x0c
+#define RK808_ALARM_YEARS_REG   0x0d
+#define RK808_RTC_CTRL_REG      0x10
+#define RK808_RTC_STATUS_REG    0x11
+#define RK808_RTC_INT_REG       0x12
+#define RK808_RTC_COMP_LSB_REG  0x13
+#define RK808_RTC_COMP_MSB_REG  0x14
+#define RK808_CLK32OUT_REG      0x20
+#define RK808_VB_MON_REG        0x21
+#define RK808_THERMAL_REG       0x22
+#define RK808_DCDC_EN_REG       0x23
+#define RK808_LDO_EN_REG        0x24
+#define RK808_SLEEP_SET_OFF_REG1        0x25
+#define RK808_SLEEP_SET_OFF_REG2        0x26
+#define RK808_DCDC_UV_STS_REG   0x27
+#define RK808_DCDC_UV_ACT_REG   0x28
+#define RK808_LDO_UV_STS_REG    0x29
+#define RK808_LDO_UV_ACT_REG    0x2a
+#define RK808_DCDC_PG_REG       0x2b
+#define RK808_LDO_PG_REG        0x2c
+#define RK808_VOUT_MON_TDB_REG  0x2d
+#define RK808_BUCK1_CONFIG_REG          0x2e
+#define RK808_BUCK1_ON_VSEL_REG         0x2f
+#define RK808_BUCK1_SLP_VSEL_REG        0x30
+#define RK808_BUCK1_DVS_VSEL_REG        0x31
+#define RK808_BUCK2_CONFIG_REG          0x32
+#define RK808_BUCK2_ON_VSEL_REG         0x33
+#define RK808_BUCK2_SLP_VSEL_REG        0x34
+#define RK808_BUCK2_DVS_VSEL_REG        0x35
+#define RK808_BUCK3_CONFIG_REG          0x36
+#define RK808_BUCK4_CONFIG_REG          0x37
+#define RK808_BUCK4_ON_VSEL_REG         0x38
+#define RK808_BUCK4_SLP_VSEL_REG        0x39
+#define RK808_BOOST_CONFIG_REG          0x3a
+#define RK808_LDO1_ON_VSEL_REG          0x3b
+#define RK808_LDO1_SLP_VSEL_REG         0x3c
+#define RK808_LDO2_ON_VSEL_REG          0x3d
+#define RK808_LDO2_SLP_VSEL_REG         0x3e
+#define RK808_LDO3_ON_VSEL_REG          0x3f
+#define RK808_LDO3_SLP_VSEL_REG         0x40
+#define RK808_LDO4_ON_VSEL_REG          0x41
+#define RK808_LDO4_SLP_VSEL_REG         0x42
+#define RK808_LDO5_ON_VSEL_REG          0x43
+#define RK808_LDO5_SLP_VSEL_REG         0x44
+#define RK808_LDO6_ON_VSEL_REG          0x45
+#define RK808_LDO6_SLP_VSEL_REG         0x46
+#define RK808_LDO7_ON_VSEL_REG          0x47
+#define RK808_LDO7_SLP_VSEL_REG         0x48
+#define RK808_LDO8_ON_VSEL_REG          0x49
+#define RK808_LDO8_SLP_VSEL_REG         0x4a
+#define RK808_DEVCTRL_REG       0x4b
+#define RK808_INT_STS_REG1      0x4c
+#define RK808_INT_STS_MSK_REG1  0x4d
+#define RK808_INT_STS_REG2      0x4e
+#define RK808_INT_STS_MSK_REG2  0x4f
+#define RK808_IO_POL_REG        0x50
+
+/* IRQ Definitions */
+#define RK808_IRQ_VOUT_LO       0
+#define RK808_IRQ_VB_LO         1
+#define RK808_IRQ_PWRON         2
+#define RK808_IRQ_PWRON_LP      3
+#define RK808_IRQ_HOTDIE        4
+#define RK808_IRQ_RTC_ALARM     5
+#define RK808_IRQ_RTC_PERIOD    6
+#define RK808_IRQ_PLUG_IN_INT   7
+#define RK808_IRQ_PLUG_OUT_INT  8
+#define RK808_NUM_IRQ           9
+
+#define RK808_IRQ_VOUT_LO_MSK           BIT(0)
+#define RK808_IRQ_VB_LO_MSK             BIT(1)
+#define RK808_IRQ_PWRON_MSK             BIT(2)
+#define RK808_IRQ_PWRON_LP_MSK          BIT(3)
+#define RK808_IRQ_HOTDIE_MSK            BIT(4)
+#define RK808_IRQ_RTC_ALARM_MSK         BIT(5)
+#define RK808_IRQ_RTC_PERIOD_MSK        BIT(6)
+#define RK808_IRQ_PLUG_IN_INT_MSK       BIT(0)
+#define RK808_IRQ_PLUG_OUT_INT_MSK      BIT(1)
+
+#define RK808_VBAT_LOW_2V8      0x00
+#define RK808_VBAT_LOW_2V9      0x01
+#define RK808_VBAT_LOW_3V0      0x02
+#define RK808_VBAT_LOW_3V1      0x03
+#define RK808_VBAT_LOW_3V2      0x04
+#define RK808_VBAT_LOW_3V3      0x05
+#define RK808_VBAT_LOW_3V4      0x06
+#define RK808_VBAT_LOW_3V5      0x07
+#define VBAT_LOW_VOL_MASK       (0x07 << 0)
+#define EN_VABT_LOW_SHUT_DOWN   (0x00 << 4)
+#define EN_VBAT_LOW_IRQ         (0x1 << 4)
+#define VBAT_LOW_ACT_MASK       (0x1 << 4)
+
+#define BUCK_ILMIN_MASK         (7 << 0)
+#define BOOST_ILMIN_MASK        (7 << 0)
+#define BUCK1_RATE_MASK         (3 << 3)
+#define BUCK2_RATE_MASK         (3 << 3)
+#define MASK_ALL        0xff
+
+#define SWITCH2_EN      BIT(6)
+#define SWITCH1_EN      BIT(5)
+#define DEV_OFF_RST     BIT(3)
+
+#define VB_LO_ACT               BIT(4)
+#define VB_LO_SEL_3500MV        (7 << 0)
+
+#define VOUT_LO_INT     BIT(0)
+#define CLK32KOUT2_EN   BIT(0)
+
+enum {
+        BUCK_ILMIN_50MA,
+        BUCK_ILMIN_100MA,
+        BUCK_ILMIN_150MA,
+        BUCK_ILMIN_200MA,
+        BUCK_ILMIN_250MA,
+        BUCK_ILMIN_300MA,
+        BUCK_ILMIN_350MA,
+        BUCK_ILMIN_400MA,
+};
+
+enum {
+        BOOST_ILMIN_75MA,
+        BOOST_ILMIN_100MA,
+        BOOST_ILMIN_125MA,
+        BOOST_ILMIN_150MA,
+        BOOST_ILMIN_175MA,
+        BOOST_ILMIN_200MA,
+        BOOST_ILMIN_225MA,
+        BOOST_ILMIN_250MA,
+};
+
+struct rk808 {
+        struct i2c_client *i2c;
+        struct regmap_irq_chip_data *irq_data;
+        struct regmap *regmap;
+};
+#endif /* __LINUX_REGULATOR_rk808_H */
diff --git a/include/linux/mfd/rn5t618.h b/include/linux/mfd/rn5t618.h
new file mode 100644
index 000000000000..c72d5344f3b3
--- /dev/null
+++ b/include/linux/mfd/rn5t618.h
@@ -0,0 +1,228 @@
+/*
+ * MFD core driver for Ricoh RN5T618 PMIC
+ *
+ * Copyright (C) 2014 Beniamino Galvani <b.galvani@gmail.com>
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __LINUX_MFD_RN5T618_H
+#define __LINUX_MFD_RN5T618_H
+
+#include <linux/regmap.h>
+
+#define RN5T618_LSIVER                  0x00
+#define RN5T618_OTPVER                  0x01
+#define RN5T618_IODAC                   0x02
+#define RN5T618_VINDAC                  0x03
+#define RN5T618_CPUCNT                  0x06
+#define RN5T618_PSWR                    0x07
+#define RN5T618_PONHIS                  0x09
+#define RN5T618_POFFHIS                 0x0a
+#define RN5T618_WATCHDOG                0x0b
+#define RN5T618_WATCHDOGCNT             0x0c
+#define RN5T618_PWRFUNC                 0x0d
+#define RN5T618_SLPCNT                  0x0e
+#define RN5T618_REPCNT                  0x0f
+#define RN5T618_PWRONTIMSET             0x10
+#define RN5T618_NOETIMSETCNT            0x11
+#define RN5T618_PWRIREN                 0x12
+#define RN5T618_PWRIRQ                  0x13
+#define RN5T618_PWRMON                  0x14
+#define RN5T618_PWRIRSEL                0x15
+#define RN5T618_DC1_SLOT                0x16
+#define RN5T618_DC2_SLOT                0x17
+#define RN5T618_DC3_SLOT                0x18
+#define RN5T618_LDO1_SLOT               0x1b
+#define RN5T618_LDO2_SLOT               0x1c
+#define RN5T618_LDO3_SLOT               0x1d
+#define RN5T618_LDO4_SLOT               0x1e
+#define RN5T618_LDO5_SLOT               0x1f
+#define RN5T618_PSO0_SLOT               0x25
+#define RN5T618_PSO1_SLOT               0x26
+#define RN5T618_PSO2_SLOT               0x27
+#define RN5T618_PSO3_SLOT               0x28
+#define RN5T618_LDORTC1_SLOT            0x2a
+#define RN5T618_DC1CTL                  0x2c
+#define RN5T618_DC1CTL2                 0x2d
+#define RN5T618_DC2CTL                  0x2e
+#define RN5T618_DC2CTL2                 0x2f
+#define RN5T618_DC3CTL                  0x30
+#define RN5T618_DC3CTL2                 0x31
+#define RN5T618_DC1DAC                  0x36
+#define RN5T618_DC2DAC                  0x37
+#define RN5T618_DC3DAC                  0x38
+#define RN5T618_DC1DAC_SLP              0x3b
+#define RN5T618_DC2DAC_SLP              0x3c
+#define RN5T618_DC3DAC_SLP              0x3d
+#define RN5T618_DCIREN                  0x40
+#define RN5T618_DCIRQ                   0x41
+#define RN5T618_DCIRMON                 0x42
+#define RN5T618_LDOEN1                  0x44
+#define RN5T618_LDOEN2                  0x45
+#define RN5T618_LDODIS                  0x46
+#define RN5T618_LDO1DAC                 0x4c
+#define RN5T618_LDO2DAC                 0x4d
+#define RN5T618_LDO3DAC                 0x4e
+#define RN5T618_LDO4DAC                 0x4f
+#define RN5T618_LDO5DAC                 0x50
+#define RN5T618_LDORTCDAC               0x56
+#define RN5T618_LDORTC2DAC              0x57
+#define RN5T618_LDO1DAC_SLP             0x58
+#define RN5T618_LDO2DAC_SLP             0x59
+#define RN5T618_LDO3DAC_SLP             0x5a
+#define RN5T618_LDO4DAC_SLP             0x5b
+#define RN5T618_LDO5DAC_SLP             0x5c
+#define RN5T618_ADCCNT1                 0x64
+#define RN5T618_ADCCNT2                 0x65
+#define RN5T618_ADCCNT3                 0x66
+#define RN5T618_ILIMDATAH               0x68
+#define RN5T618_ILIMDATAL               0x69
+#define RN5T618_VBATDATAH               0x6a
+#define RN5T618_VBATDATAL               0x6b
+#define RN5T618_VADPDATAH               0x6c
+#define RN5T618_VADPDATAL               0x6d
+#define RN5T618_VUSBDATAH               0x6e
+#define RN5T618_VUSBDATAL               0x6f
+#define RN5T618_VSYSDATAH               0x70
+#define RN5T618_VSYSDATAL               0x71
+#define RN5T618_VTHMDATAH               0x72
+#define RN5T618_VTHMDATAL               0x73
+#define RN5T618_AIN1DATAH               0x74
+#define RN5T618_AIN1DATAL               0x75
+#define RN5T618_AIN0DATAH               0x76
+#define RN5T618_AIN0DATAL               0x77
+#define RN5T618_ILIMTHL                 0x78
+#define RN5T618_ILIMTHH                 0x79
+#define RN5T618_VBATTHL                 0x7a
+#define RN5T618_VBATTHH                 0x7b
+#define RN5T618_VADPTHL                 0x7c
+#define RN5T618_VADPTHH                 0x7d
+#define RN5T618_VUSBTHL                 0x7e
+#define RN5T618_VUSBTHH                 0x7f
+#define RN5T618_VSYSTHL                 0x80
+#define RN5T618_VSYSTHH                 0x81
+#define RN5T618_VTHMTHL                 0x82
+#define RN5T618_VTHMTHH                 0x83
+#define RN5T618_AIN1THL                 0x84
+#define RN5T618_AIN1THH                 0x85
+#define RN5T618_AIN0THL                 0x86
+#define RN5T618_AIN0THH                 0x87
+#define RN5T618_EN_ADCIR1               0x88
+#define RN5T618_EN_ADCIR2               0x89
+#define RN5T618_EN_ADCIR3               0x8a
+#define RN5T618_IR_ADC1                 0x8c
+#define RN5T618_IR_ADC2                 0x8d
+#define RN5T618_IR_ADC3                 0x8e
+#define RN5T618_IOSEL                   0x90
+#define RN5T618_IOOUT                   0x91
+#define RN5T618_GPEDGE1                 0x92
+#define RN5T618_GPEDGE2                 0x93
+#define RN5T618_EN_GPIR                 0x94
+#define RN5T618_IR_GPR                  0x95
+#define RN5T618_IR_GPF                  0x96
+#define RN5T618_MON_IOIN                0x97
+#define RN5T618_GPLED_FUNC              0x98
+#define RN5T618_INTPOL                  0x9c
+#define RN5T618_INTEN                   0x9d
+#define RN5T618_INTMON                  0x9e
+#define RN5T618_PREVINDAC               0xb0
+#define RN5T618_BATDAC                  0xb1
+#define RN5T618_CHGCTL1                 0xb3
+#define RN5T618_CHGCTL2                 0xb4
+#define RN5T618_VSYSSET                 0xb5
+#define RN5T618_REGISET1                0xb6
+#define RN5T618_REGISET2                0xb7
+#define RN5T618_CHGISET                 0xb8
+#define RN5T618_TIMSET                  0xb9
+#define RN5T618_BATSET1                 0xba
+#define RN5T618_BATSET2                 0xbb
+#define RN5T618_DIESET                  0xbc
+#define RN5T618_CHGSTATE                0xbd
+#define RN5T618_CHGCTRL_IRFMASK         0xbe
+#define RN5T618_CHGSTAT_IRFMASK1        0xbf
+#define RN5T618_CHGSTAT_IRFMASK2        0xc0
+#define RN5T618_CHGERR_IRFMASK          0xc1
+#define RN5T618_CHGCTRL_IRR             0xc2
+#define RN5T618_CHGSTAT_IRR1            0xc3
+#define RN5T618_CHGSTAT_IRR2            0xc4
+#define RN5T618_CHGERR_IRR              0xc5
+#define RN5T618_CHGCTRL_MONI            0xc6
+#define RN5T618_CHGSTAT_MONI1           0xc7
+#define RN5T618_CHGSTAT_MONI2           0xc8
+#define RN5T618_CHGERR_MONI             0xc9
+#define RN5T618_CHGCTRL_DETMOD1         0xca
+#define RN5T618_CHGCTRL_DETMOD2         0xcb
+#define RN5T618_CHGSTAT_DETMOD1         0xcc
+#define RN5T618_CHGSTAT_DETMOD2         0xcd
+#define RN5T618_CHGSTAT_DETMOD3         0xce
+#define RN5T618_CHGERR_DETMOD1          0xcf
+#define RN5T618_CHGERR_DETMOD2          0xd0
+#define RN5T618_CHGOSCCTL               0xd4
+#define RN5T618_CHGOSCSCORESET1         0xd5
+#define RN5T618_CHGOSCSCORESET2         0xd6
+#define RN5T618_CHGOSCSCORESET3         0xd7
+#define RN5T618_CHGOSCFREQSET1          0xd8
+#define RN5T618_CHGOSCFREQSET2          0xd9
+#define RN5T618_CONTROL                 0xe0
+#define RN5T618_SOC                     0xe1
+#define RN5T618_RE_CAP_H                0xe2
+#define RN5T618_RE_CAP_L                0xe3
+#define RN5T618_FA_CAP_H                0xe4
+#define RN5T618_FA_CAP_L                0xe5
+#define RN5T618_AGE                     0xe6
+#define RN5T618_TT_EMPTY_H              0xe7
+#define RN5T618_TT_EMPTY_L              0xe8
+#define RN5T618_TT_FULL_H               0xe9
+#define RN5T618_TT_FULL_L               0xea
+#define RN5T618_VOLTAGE_1               0xeb
+#define RN5T618_VOLTAGE_0               0xec
+#define RN5T618_TEMP_1                  0xed
+#define RN5T618_TEMP_0                  0xee
+#define RN5T618_CC_CTRL                 0xef
+#define RN5T618_CC_COUNT2               0xf0
+#define RN5T618_CC_COUNT1               0xf1
+#define RN5T618_CC_COUNT0               0xf2
+#define RN5T618_CC_SUMREG3              0xf3
+#define RN5T618_CC_SUMREG2              0xf4
+#define RN5T618_CC_SUMREG1              0xf5
+#define RN5T618_CC_SUMREG0              0xf6
+#define RN5T618_CC_OFFREG1              0xf7
+#define RN5T618_CC_OFFREG0              0xf8
+#define RN5T618_CC_GAINREG1             0xf9
+#define RN5T618_CC_GAINREG0             0xfa
+#define RN5T618_CC_AVEREG1              0xfb
+#define RN5T618_CC_AVEREG0              0xfc
+#define RN5T618_MAX_REG                 0xfc
+
+#define RN5T618_REPCNT_REPWRON          BIT(0)
+#define RN5T618_SLPCNT_SWPWROFF         BIT(0)
+#define RN5T618_WATCHDOG_WDOGEN         BIT(2)
+#define RN5T618_WATCHDOG_WDOGTIM_M      (BIT(0) | BIT(1))
+#define RN5T618_WATCHDOG_WDOGTIM_S      0
+#define RN5T618_PWRIRQ_IR_WDOG          BIT(6)
+
+enum {
+        RN5T618_DCDC1,
+        RN5T618_DCDC2,
+        RN5T618_DCDC3,
+        RN5T618_LDO1,
+        RN5T618_LDO2,
+        RN5T618_LDO3,
+        RN5T618_LDO4,
+        RN5T618_LDO5,
+        RN5T618_LDORTC1,
+        RN5T618_LDORTC2,
+        RN5T618_REG_NUM,
+};
+
+struct rn5t618 {
+        struct regmap *regmap;
+};
+
+#endif /* __LINUX_MFD_RN5T618_H */
diff --git a/include/linux/mfd/rtsx_pci.h b/include/linux/mfd/rtsx_pci.h
index 74346d5e7899..0c12628e91c6 100644
--- a/include/linux/mfd/rtsx_pci.h
+++ b/include/linux/mfd/rtsx_pci.h
@@ -558,6 +558,7 @@
 #define SD_SAMPLE_POINT_CTL             0xFDA7
 #define SD_PUSH_POINT_CTL               0xFDA8
 #define SD_CMD0                         0xFDA9
+#define   SD_CMD_START                  0x40
 #define SD_CMD1                         0xFDAA
 #define SD_CMD2                         0xFDAB
 #define SD_CMD3                         0xFDAC
@@ -707,6 +708,14 @@
 #define PM_CTRL1                        0xFF44
 #define PM_CTRL2                        0xFF45
 #define PM_CTRL3                        0xFF46
+#define   SDIO_SEND_PME_EN              0x80
+#define   FORCE_RC_MODE_ON              0x40
+#define   FORCE_RX50_LINK_ON            0x20
+#define   D3_DELINK_MODE_EN             0x10
+#define   USE_PESRTB_CTL_DELINK         0x08
+#define   DELAY_PIN_WAKE                0x04
+#define   RESET_PIN_WAKE                0x02
+#define   PM_WAKE_EN                    0x01
 #define PM_CTRL4                        0xFF47
 
 /* Memory mapping */
@@ -752,6 +761,14 @@
 #define PHY_DUM_REG                     0x1F
 
 #define LCTLR                           0x80
+#define   LCTLR_EXT_SYNC                0x80
+#define   LCTLR_COMMON_CLOCK_CFG        0x40
+#define   LCTLR_RETRAIN_LINK            0x20
+#define   LCTLR_LINK_DISABLE            0x10
+#define   LCTLR_RCB                     0x08
+#define   LCTLR_RESERVED                0x04
+#define   LCTLR_ASPM_CTL_MASK           0x03
+
 #define PCR_SETTING_REG1                0x724
 #define PCR_SETTING_REG2                0x814
 #define PCR_SETTING_REG3                0x747
@@ -967,4 +984,24 @@ static inline u8 *rtsx_pci_get_cmd_data(struct rtsx_pcr *pcr)
         return (u8 *)(pcr->host_cmds_ptr);
 }
 
+static inline int rtsx_pci_update_cfg_byte(struct rtsx_pcr *pcr, int addr,
+                u8 mask, u8 append)
+{
+        int err;
+        u8 val;
+
+        err = pci_read_config_byte(pcr->pci, addr, &val);
+        if (err < 0)
+                return err;
+        return pci_write_config_byte(pcr->pci, addr, (val & mask) | append);
+}
+
+static inline void rtsx_pci_write_be32(struct rtsx_pcr *pcr, u16 reg, u32 val)
+{
+        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, reg,     0xFF, val >> 24);
+        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, reg + 1, 0xFF, val >> 16);
+        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, reg + 2, 0xFF, val >> 8);
+        rtsx_pci_add_cmd(pcr, WRITE_REG_CMD, reg + 3, 0xFF, val);
+}
+
 #endif
diff --git a/include/linux/mfd/samsung/core.h b/include/linux/mfd/samsung/core.h
index b5f73de81aad..3fdb7cfbffb3 100644
--- a/include/linux/mfd/samsung/core.h
+++ b/include/linux/mfd/samsung/core.h
@@ -14,12 +14,35 @@
 #ifndef __LINUX_MFD_SEC_CORE_H
 #define __LINUX_MFD_SEC_CORE_H
 
+/* Macros to represent minimum voltages for LDO/BUCK */
+#define MIN_3000_MV             3000000
+#define MIN_2500_MV             2500000
+#define MIN_2000_MV             2000000
+#define MIN_1800_MV             1800000
+#define MIN_1500_MV             1500000
+#define MIN_1400_MV             1400000
+#define MIN_1000_MV             1000000
+
+#define MIN_900_MV              900000
+#define MIN_850_MV              850000
+#define MIN_800_MV              800000
+#define MIN_750_MV              750000
+#define MIN_600_MV              600000
+#define MIN_500_MV              500000
+
+/* Macros to represent steps for LDO/BUCK */
+#define STEP_50_MV              50000
+#define STEP_25_MV              25000
+#define STEP_12_5_MV            12500
+#define STEP_6_25_MV            6250
+
 enum sec_device_type {
         S5M8751X,
         S5M8763X,
         S5M8767X,
         S2MPA01,
         S2MPS11X,
+        S2MPS13X,
         S2MPS14X,
         S2MPU02,
 };
diff --git a/include/linux/mfd/samsung/s2mpa01.h b/include/linux/mfd/samsung/s2mpa01.h
index fbc63bc0d6a2..2766108bca2f 100644
--- a/include/linux/mfd/samsung/s2mpa01.h
+++ b/include/linux/mfd/samsung/s2mpa01.h
@@ -155,18 +155,6 @@ enum s2mpa01_regulators {
         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)
diff --git a/include/linux/mfd/samsung/s2mps11.h b/include/linux/mfd/samsung/s2mps11.h
index b3ddf98dec37..7981a9d77d3f 100644
--- a/include/linux/mfd/samsung/s2mps11.h
+++ b/include/linux/mfd/samsung/s2mps11.h
@@ -171,15 +171,6 @@ enum s2mps11_regulators {
         S2MPS11_REGULATOR_MAX,
 };
 
-#define S2MPS11_BUCK_MIN1       600000
-#define S2MPS11_BUCK_MIN2       750000
-#define S2MPS11_BUCK_MIN3       3000000
-#define S2MPS11_LDO_MIN 800000
-#define S2MPS11_BUCK_STEP1      6250
-#define S2MPS11_BUCK_STEP2      12500
-#define S2MPS11_BUCK_STEP3      25000
-#define S2MPS11_LDO_STEP1       50000
-#define S2MPS11_LDO_STEP2       25000
 #define S2MPS11_LDO_VSEL_MASK   0x3F
 #define S2MPS11_BUCK_VSEL_MASK  0xFF
 #define S2MPS11_ENABLE_MASK     (0x03 << S2MPS11_ENABLE_SHIFT)
diff --git a/include/linux/mfd/samsung/s2mps13.h b/include/linux/mfd/samsung/s2mps13.h
new file mode 100644
index 000000000000..ce5dda8958fe
--- /dev/null
+++ b/include/linux/mfd/samsung/s2mps13.h
@@ -0,0 +1,186 @@
+/*
+ * s2mps13.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_S2MPS13_H
+#define __LINUX_MFD_S2MPS13_H
+
+/* S2MPS13 registers */
+enum s2mps13_reg {
+        S2MPS13_REG_ID,
+        S2MPS13_REG_INT1,
+        S2MPS13_REG_INT2,
+        S2MPS13_REG_INT3,
+        S2MPS13_REG_INT1M,
+        S2MPS13_REG_INT2M,
+        S2MPS13_REG_INT3M,
+        S2MPS13_REG_ST1,
+        S2MPS13_REG_ST2,
+        S2MPS13_REG_PWRONSRC,
+        S2MPS13_REG_OFFSRC,
+        S2MPS13_REG_BU_CHG,
+        S2MPS13_REG_RTCCTRL,
+        S2MPS13_REG_CTRL1,
+        S2MPS13_REG_CTRL2,
+        S2MPS13_REG_RSVD1,
+        S2MPS13_REG_RSVD2,
+        S2MPS13_REG_RSVD3,
+        S2MPS13_REG_RSVD4,
+        S2MPS13_REG_RSVD5,
+        S2MPS13_REG_RSVD6,
+        S2MPS13_REG_CTRL3,
+        S2MPS13_REG_RSVD7,
+        S2MPS13_REG_RSVD8,
+        S2MPS13_REG_WRSTBI,
+        S2MPS13_REG_B1CTRL,
+        S2MPS13_REG_B1OUT,
+        S2MPS13_REG_B2CTRL,
+        S2MPS13_REG_B2OUT,
+        S2MPS13_REG_B3CTRL,
+        S2MPS13_REG_B3OUT,
+        S2MPS13_REG_B4CTRL,
+        S2MPS13_REG_B4OUT,
+        S2MPS13_REG_B5CTRL,
+        S2MPS13_REG_B5OUT,
+        S2MPS13_REG_B6CTRL,
+        S2MPS13_REG_B6OUT,
+        S2MPS13_REG_B7CTRL,
+        S2MPS13_REG_B7OUT,
+        S2MPS13_REG_B8CTRL,
+        S2MPS13_REG_B8OUT,
+        S2MPS13_REG_B9CTRL,
+        S2MPS13_REG_B9OUT,
+        S2MPS13_REG_B10CTRL,
+        S2MPS13_REG_B10OUT,
+        S2MPS13_REG_BB1CTRL,
+        S2MPS13_REG_BB1OUT,
+        S2MPS13_REG_BUCK_RAMP1,
+        S2MPS13_REG_BUCK_RAMP2,
+        S2MPS13_REG_LDO_DVS1,
+        S2MPS13_REG_LDO_DVS2,
+        S2MPS13_REG_LDO_DVS3,
+        S2MPS13_REG_B6OUT2,
+        S2MPS13_REG_L1CTRL,
+        S2MPS13_REG_L2CTRL,
+        S2MPS13_REG_L3CTRL,
+        S2MPS13_REG_L4CTRL,
+        S2MPS13_REG_L5CTRL,
+        S2MPS13_REG_L6CTRL,
+        S2MPS13_REG_L7CTRL,
+        S2MPS13_REG_L8CTRL,
+        S2MPS13_REG_L9CTRL,
+        S2MPS13_REG_L10CTRL,
+        S2MPS13_REG_L11CTRL,
+        S2MPS13_REG_L12CTRL,
+        S2MPS13_REG_L13CTRL,
+        S2MPS13_REG_L14CTRL,
+        S2MPS13_REG_L15CTRL,
+        S2MPS13_REG_L16CTRL,
+        S2MPS13_REG_L17CTRL,
+        S2MPS13_REG_L18CTRL,
+        S2MPS13_REG_L19CTRL,
+        S2MPS13_REG_L20CTRL,
+        S2MPS13_REG_L21CTRL,
+        S2MPS13_REG_L22CTRL,
+        S2MPS13_REG_L23CTRL,
+        S2MPS13_REG_L24CTRL,
+        S2MPS13_REG_L25CTRL,
+        S2MPS13_REG_L26CTRL,
+        S2MPS13_REG_L27CTRL,
+        S2MPS13_REG_L28CTRL,
+        S2MPS13_REG_L30CTRL,
+        S2MPS13_REG_L31CTRL,
+        S2MPS13_REG_L32CTRL,
+        S2MPS13_REG_L33CTRL,
+        S2MPS13_REG_L34CTRL,
+        S2MPS13_REG_L35CTRL,
+        S2MPS13_REG_L36CTRL,
+        S2MPS13_REG_L37CTRL,
+        S2MPS13_REG_L38CTRL,
+        S2MPS13_REG_L39CTRL,
+        S2MPS13_REG_L40CTRL,
+        S2MPS13_REG_LDODSCH1,
+        S2MPS13_REG_LDODSCH2,
+        S2MPS13_REG_LDODSCH3,
+        S2MPS13_REG_LDODSCH4,
+        S2MPS13_REG_LDODSCH5,
+};
+
+/*  regulator ids */
+enum s2mps13_regulators {
+        S2MPS13_LDO1,
+        S2MPS13_LDO2,
+        S2MPS13_LDO3,
+        S2MPS13_LDO4,
+        S2MPS13_LDO5,
+        S2MPS13_LDO6,
+        S2MPS13_LDO7,
+        S2MPS13_LDO8,
+        S2MPS13_LDO9,
+        S2MPS13_LDO10,
+        S2MPS13_LDO11,
+        S2MPS13_LDO12,
+        S2MPS13_LDO13,
+        S2MPS13_LDO14,
+        S2MPS13_LDO15,
+        S2MPS13_LDO16,
+        S2MPS13_LDO17,
+        S2MPS13_LDO18,
+        S2MPS13_LDO19,
+        S2MPS13_LDO20,
+        S2MPS13_LDO21,
+        S2MPS13_LDO22,
+        S2MPS13_LDO23,
+        S2MPS13_LDO24,
+        S2MPS13_LDO25,
+        S2MPS13_LDO26,
+        S2MPS13_LDO27,
+        S2MPS13_LDO28,
+        S2MPS13_LDO29,
+        S2MPS13_LDO30,
+        S2MPS13_LDO31,
+        S2MPS13_LDO32,
+        S2MPS13_LDO33,
+        S2MPS13_LDO34,
+        S2MPS13_LDO35,
+        S2MPS13_LDO36,
+        S2MPS13_LDO37,
+        S2MPS13_LDO38,
+        S2MPS13_LDO39,
+        S2MPS13_LDO40,
+        S2MPS13_BUCK1,
+        S2MPS13_BUCK2,
+        S2MPS13_BUCK3,
+        S2MPS13_BUCK4,
+        S2MPS13_BUCK5,
+        S2MPS13_BUCK6,
+        S2MPS13_BUCK7,
+        S2MPS13_BUCK8,
+        S2MPS13_BUCK9,
+        S2MPS13_BUCK10,
+
+        S2MPS13_REGULATOR_MAX,
+};
+
+/*
+ * 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 S2MPS13_BUCK_RAMP_DELAY         12500
+
+#endif /*  __LINUX_MFD_S2MPS13_H */
diff --git a/include/linux/mfd/samsung/s2mps14.h b/include/linux/mfd/samsung/s2mps14.h
index 900cd7a04314..c92f4782afb5 100644
--- a/include/linux/mfd/samsung/s2mps14.h
+++ b/include/linux/mfd/samsung/s2mps14.h
@@ -123,10 +123,6 @@ enum s2mps14_regulators {
 };
 
 /* 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
 /*
@@ -136,12 +132,6 @@ enum s2mps14_regulators {
  */
 #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)
diff --git a/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h b/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h
index ff44374a1a4e..c877cad61a13 100644
--- a/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h
+++ b/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h
@@ -395,4 +395,43 @@
 #define IMX6SL_GPR1_FEC_CLOCK_MUX1_SEL_MASK    (0x3 << 17)
 #define IMX6SL_GPR1_FEC_CLOCK_MUX2_SEL_MASK    (0x1 << 14)
 
+/* For imx6sx iomux gpr register field define */
+#define IMX6SX_GPR1_VDEC_SW_RST_MASK                    (0x1 << 20)
+#define IMX6SX_GPR1_VDEC_SW_RST_RESET                   (0x1 << 20)
+#define IMX6SX_GPR1_VDEC_SW_RST_RELEASE                 (0x0 << 20)
+#define IMX6SX_GPR1_VADC_SW_RST_MASK                    (0x1 << 19)
+#define IMX6SX_GPR1_VADC_SW_RST_RESET                   (0x1 << 19)
+#define IMX6SX_GPR1_VADC_SW_RST_RELEASE                 (0x0 << 19)
+#define IMX6SX_GPR1_FEC_CLOCK_MUX_SEL_MASK              (0x3 << 13)
+#define IMX6SX_GPR1_FEC_CLOCK_PAD_DIR_MASK              (0x3 << 17)
+#define IMX6SX_GPR1_FEC_CLOCK_MUX_SEL_EXT               (0x3 << 13)
+
+#define IMX6SX_GPR4_FEC_ENET1_STOP_REQ                  (0x1 << 3)
+#define IMX6SX_GPR4_FEC_ENET2_STOP_REQ                  (0x1 << 4)
+
+#define IMX6SX_GPR5_DISP_MUX_LDB_CTRL_MASK              (0x1 << 3)
+#define IMX6SX_GPR5_DISP_MUX_LDB_CTRL_LCDIF1            (0x0 << 3)
+#define IMX6SX_GPR5_DISP_MUX_LDB_CTRL_LCDIF2            (0x1 << 3)
+
+#define IMX6SX_GPR5_CSI2_MUX_CTRL_MASK                  (0x3 << 27)
+#define IMX6SX_GPR5_CSI2_MUX_CTRL_EXT_PIN               (0x0 << 27)
+#define IMX6SX_GPR5_CSI2_MUX_CTRL_CVD                   (0x1 << 27)
+#define IMX6SX_GPR5_CSI2_MUX_CTRL_VDAC_TO_CSI           (0x2 << 27)
+#define IMX6SX_GPR5_CSI2_MUX_CTRL_GND                   (0x3 << 27)
+#define IMX6SX_GPR5_VADC_TO_CSI_CAPTURE_EN_MASK         (0x1 << 26)
+#define IMX6SX_GPR5_VADC_TO_CSI_CAPTURE_EN_ENABLE       (0x1 << 26)
+#define IMX6SX_GPR5_VADC_TO_CSI_CAPTURE_EN_DISABLE      (0x0 << 26)
+#define IMX6SX_GPR5_CSI1_MUX_CTRL_MASK                  (0x3 << 4)
+#define IMX6SX_GPR5_CSI1_MUX_CTRL_EXT_PIN               (0x0 << 4)
+#define IMX6SX_GPR5_CSI1_MUX_CTRL_CVD                   (0x1 << 4)
+#define IMX6SX_GPR5_CSI1_MUX_CTRL_VDAC_TO_CSI           (0x2 << 4)
+#define IMX6SX_GPR5_CSI1_MUX_CTRL_GND                   (0x3 << 4)
+
+#define IMX6SX_GPR5_DISP_MUX_DCIC2_LCDIF2               (0x0 << 2)
+#define IMX6SX_GPR5_DISP_MUX_DCIC2_LVDS                 (0x1 << 2)
+#define IMX6SX_GPR5_DISP_MUX_DCIC2_MASK                 (0x1 << 2)
+#define IMX6SX_GPR5_DISP_MUX_DCIC1_LCDIF1               (0x0 << 1)
+#define IMX6SX_GPR5_DISP_MUX_DCIC1_LVDS                 (0x1 << 1)
+#define IMX6SX_GPR5_DISP_MUX_DCIC1_MASK                 (0x1 << 1)
+
 #endif /* __LINUX_IMX6Q_IOMUXC_GPR_H */
diff --git a/include/linux/mfd/tc3589x.h b/include/linux/mfd/tc3589x.h
index e6088c2e2092..e1c12d84c26a 100644
--- a/include/linux/mfd/tc3589x.h
+++ b/include/linux/mfd/tc3589x.h
@@ -164,13 +164,10 @@ struct tc3589x_keypad_platform_data {
 
 /**
  * struct tc3589x_gpio_platform_data - TC3589x GPIO platform data
- * @gpio_base: first gpio number assigned to TC3589x.  A maximum of
- *             %TC3589x_NR_GPIOS GPIOs will be allocated.
  * @setup: callback for board-specific initialization
  * @remove: callback for board-specific teardown
  */
 struct tc3589x_gpio_platform_data {
-        int gpio_base;
         void (*setup)(struct tc3589x *tc3589x, unsigned gpio_base);
         void (*remove)(struct tc3589x *tc3589x, unsigned gpio_base);
 };
@@ -178,18 +175,13 @@ struct tc3589x_gpio_platform_data {
 /**
  * struct tc3589x_platform_data - TC3589x platform data
  * @block: bitmask of blocks to enable (use TC3589x_BLOCK_*)
- * @irq_base: base IRQ number.  %TC3589x_NR_IRQS irqs will be used.
  * @gpio: GPIO-specific platform data
  * @keypad: keypad-specific platform data
  */
 struct tc3589x_platform_data {
         unsigned int block;
-        int irq_base;
         struct tc3589x_gpio_platform_data *gpio;
         const struct tc3589x_keypad_platform_data *keypad;
 };
 
-#define TC3589x_NR_GPIOS        24
-#define TC3589x_NR_IRQS         TC3589x_INT_GPIO(TC3589x_NR_GPIOS)
-
 #endif
diff --git a/include/linux/mfd/ti_am335x_tscadc.h b/include/linux/mfd/ti_am335x_tscadc.h
index fb96c84dada5..e2e70053470e 100644
--- a/include/linux/mfd/ti_am335x_tscadc.h
+++ b/include/linux/mfd/ti_am335x_tscadc.h
@@ -155,6 +155,7 @@ struct ti_tscadc_dev {
         void __iomem *tscadc_base;
         int irq;
         int used_cells; /* 1-2 */
+        int tsc_wires;
         int tsc_cell;   /* -1 if not used */
         int adc_cell;   /* -1 if not used */
         struct mfd_cell cells[TSCADC_CELLS];
diff --git a/include/linux/mfd/ti_ssp.h b/include/linux/mfd/ti_ssp.h
deleted file mode 100644
index dbb4b43bd20e..000000000000
--- a/include/linux/mfd/ti_ssp.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Sequencer Serial Port (SSP) driver for Texas Instruments' SoCs
- *
- * Copyright (C) 2010 Texas Instruments Inc
- *
- * 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 __TI_SSP_H__
-#define __TI_SSP_H__
-
-struct ti_ssp_dev_data {
-        const char      *dev_name;
-        void            *pdata;
-        size_t          pdata_size;
-};
-
-struct ti_ssp_data {
-        unsigned long           out_clock;
-        struct ti_ssp_dev_data  dev_data[2];
-};
-
-struct ti_ssp_spi_data {
-        unsigned long   iosel;
-        int             num_cs;
-        void            (*select)(int cs);
-};
-
-/*
- * Sequencer port IO pin configuration bits.  These do not correlate 1-1 with
- * the hardware.  The iosel field in the port data combines iosel1 and iosel2,
- * and is therefore not a direct map to register space.  It is best to use the
- * macros below to construct iosel values.
- *
- * least significant 16 bits --> iosel1
- * most significant 16 bits  --> iosel2
- */
-
-#define SSP_IN                  0x0000
-#define SSP_DATA                0x0001
-#define SSP_CLOCK               0x0002
-#define SSP_CHIPSEL             0x0003
-#define SSP_OUT                 0x0004
-#define SSP_PIN_SEL(pin, v)     ((v) << ((pin) * 3))
-#define SSP_PIN_MASK(pin)       SSP_PIN_SEL(pin, 0x7)
-#define SSP_INPUT_SEL(pin)      ((pin) << 16)
-
-/* Sequencer port config bits */
-#define SSP_EARLY_DIN           BIT(8)
-#define SSP_DELAY_DOUT          BIT(9)
-
-/* Sequence map definitions */
-#define SSP_CLK_HIGH            BIT(0)
-#define SSP_CLK_LOW             0
-#define SSP_DATA_HIGH           BIT(1)
-#define SSP_DATA_LOW            0
-#define SSP_CS_HIGH             BIT(2)
-#define SSP_CS_LOW              0
-#define SSP_OUT_MODE            BIT(3)
-#define SSP_IN_MODE             0
-#define SSP_DATA_REG            BIT(4)
-#define SSP_ADDR_REG            0
-
-#define SSP_OPCODE_DIRECT       ((0x0) << 5)
-#define SSP_OPCODE_TOGGLE       ((0x1) << 5)
-#define SSP_OPCODE_SHIFT        ((0x2) << 5)
-#define SSP_OPCODE_BRANCH0      ((0x4) << 5)
-#define SSP_OPCODE_BRANCH1      ((0x5) << 5)
-#define SSP_OPCODE_BRANCH       ((0x6) << 5)
-#define SSP_OPCODE_STOP         ((0x7) << 5)
-#define SSP_BRANCH(addr)        ((addr) << 8)
-#define SSP_COUNT(cycles)       ((cycles) << 8)
-
-int ti_ssp_raw_read(struct device *dev);
-int ti_ssp_raw_write(struct device *dev, u32 val);
-int ti_ssp_load(struct device *dev, int offs, u32* prog, int len);
-int ti_ssp_run(struct device *dev, u32 pc, u32 input, u32 *output);
-int ti_ssp_set_mode(struct device *dev, int mode);
-int ti_ssp_set_iosel(struct device *dev, u32 iosel);
-
-#endif /* __TI_SSP_H__ */
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 8f6f2e91e7ae..57388171610d 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -5,6 +5,7 @@
 #include <linux/fb.h>
 #include <linux/io.h>
 #include <linux/jiffies.h>
+#include <linux/mmc/card.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 
@@ -83,6 +84,27 @@
  */
 #define TMIO_MMC_HAVE_HIGH_REG          (1 << 6)
 
+/*
+ * Some controllers have CMD12 automatically
+ * issue/non-issue register
+ */
+#define TMIO_MMC_HAVE_CMD12_CTRL        (1 << 7)
+
+/*
+ * Some controllers needs to set 1 on SDIO status reserved bits
+ */
+#define TMIO_MMC_SDIO_STATUS_QUIRK      (1 << 8)
+
+/*
+ * Some controllers have DMA enable/disable register
+ */
+#define TMIO_MMC_HAVE_CTL_DMA_REG       (1 << 9)
+
+/*
+ * Some controllers allows to set SDx actual clock
+ */
+#define TMIO_MMC_CLK_ACTUAL             (1 << 10)
+
 int tmio_core_mmc_enable(void __iomem *cnf, int shift, unsigned long base);
 int tmio_core_mmc_resume(void __iomem *cnf, int shift, unsigned long base);
 void tmio_core_mmc_pwr(void __iomem *cnf, int shift, int state);
@@ -96,6 +118,7 @@ struct tmio_mmc_dma {
         int slave_id_tx;
         int slave_id_rx;
         int alignment_shift;
+        dma_addr_t dma_rx_offset;
         bool (*filter)(struct dma_chan *chan, void *arg);
 };
 
@@ -120,6 +143,8 @@ struct tmio_mmc_data {
         /* clock management callbacks */
         int (*clk_enable)(struct platform_device *pdev, unsigned int *f);
         void (*clk_disable)(struct platform_device *pdev);
+        int (*multi_io_quirk)(struct mmc_card *card,
+                              unsigned int direction, int blk_size);
 };
 
 /*
diff --git a/include/linux/mfd/tps65217.h b/include/linux/mfd/tps65217.h
index 95d6938737fd..ac7fba44d7e4 100644
--- a/include/linux/mfd/tps65217.h
+++ b/include/linux/mfd/tps65217.h
@@ -60,6 +60,8 @@
 #define TPS65217_REG_SEQ5               0X1D
 #define TPS65217_REG_SEQ6               0X1E
 
+#define TPS65217_REG_MAX                TPS65217_REG_SEQ6
+
 /* Register field definitions */
 #define TPS65217_CHIPID_CHIP_MASK       0xF0
 #define TPS65217_CHIPID_REV_MASK        0x0F
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index a2901c414664..fab9b32ace8e 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -13,18 +13,9 @@ typedef void free_page_t(struct page *page, unsigned long private);
  * Return values from addresss_space_operations.migratepage():
  * - negative errno on page migration failure;
  * - zero on page migration success;
- *
- * The balloon page migration introduces this special case where a 'distinct'
- * return code is used to flag a successful page migration to unmap_and_move().
- * This approach is necessary because page migration can race against balloon
- * deflation procedure, and for such case we could introduce a nasty page leak
- * if a successfully migrated balloon page gets released concurrently with
- * migration's unmap_and_move() wrap-up steps.
  */
 #define MIGRATEPAGE_SUCCESS             0
-#define MIGRATEPAGE_BALLOON_SUCCESS     1 /* special ret code for balloon page
-                                           * sucessful migration case.
-                                           */
+
 enum migrate_reason {
         MR_COMPACTION,
         MR_MEMORY_FAILURE,
@@ -45,9 +36,6 @@ extern int migrate_pages(struct list_head *l, new_page_t new, free_page_t free,
 
 extern int migrate_prep(void);
 extern int migrate_prep_local(void);
-extern int migrate_vmas(struct mm_struct *mm,
-                const nodemask_t *from, const nodemask_t *to,
-                unsigned long flags);
 extern void migrate_page_copy(struct page *newpage, struct page *page);
 extern int migrate_huge_page_move_mapping(struct address_space *mapping,
                                   struct page *newpage, struct page *page);
@@ -66,13 +54,6 @@ static inline int migrate_pages(struct list_head *l, new_page_t new,
 static inline int migrate_prep(void) { return -ENOSYS; }
 static inline int migrate_prep_local(void) { return -ENOSYS; }
 
-static inline int migrate_vmas(struct mm_struct *mm,
-                const nodemask_t *from, const nodemask_t *to,
-                unsigned long flags)
-{
-        return -ENOSYS;
-}
-
 static inline void migrate_page_copy(struct page *newpage,
                                      struct page *page) {}
 
@@ -82,9 +63,6 @@ static inline int migrate_huge_page_move_mapping(struct address_space *mapping,
         return -ENOSYS;
 }
 
-/* Possible settings for the migrate_page() method in address_operations */
-#define migrate_page NULL
-
 #endif /* CONFIG_MIGRATION */
 
 #ifdef CONFIG_NUMA_BALANCING
diff --git a/include/linux/mlx4/cmd.h b/include/linux/mlx4/cmd.h
index 379c02648ab3..64d25941b329 100644
--- a/include/linux/mlx4/cmd.h
+++ b/include/linux/mlx4/cmd.h
@@ -67,6 +67,8 @@ enum {
         MLX4_CMD_MAP_ICM_AUX     = 0xffc,
         MLX4_CMD_UNMAP_ICM_AUX   = 0xffb,
         MLX4_CMD_SET_ICM_SIZE    = 0xffd,
+        MLX4_CMD_ACCESS_REG      = 0x3b,
+
         /*master notify fw on finish for slave's flr*/
         MLX4_CMD_INFORM_FLR_DONE = 0x5b,
         MLX4_CMD_GET_OP_REQ      = 0x59,
@@ -197,6 +199,33 @@ enum {
         MLX4_CMD_NATIVE
 };
 
+/*
+ * MLX4_RX_CSUM_MODE_VAL_NON_TCP_UDP -
+ * Receive checksum value is reported in CQE also for non TCP/UDP packets.
+ *
+ * MLX4_RX_CSUM_MODE_L4 -
+ * L4_CSUM bit in CQE, which indicates whether or not L4 checksum
+ * was validated correctly, is supported.
+ *
+ * MLX4_RX_CSUM_MODE_IP_OK_IP_NON_TCP_UDP -
+ * IP_OK CQE's field is supported also for non TCP/UDP IP packets.
+ *
+ * MLX4_RX_CSUM_MODE_MULTI_VLAN -
+ * Receive Checksum offload is supported for packets with more than 2 vlan headers.
+ */
+enum mlx4_rx_csum_mode {
+        MLX4_RX_CSUM_MODE_VAL_NON_TCP_UDP               = 1UL << 0,
+        MLX4_RX_CSUM_MODE_L4                            = 1UL << 1,
+        MLX4_RX_CSUM_MODE_IP_OK_IP_NON_TCP_UDP          = 1UL << 2,
+        MLX4_RX_CSUM_MODE_MULTI_VLAN                    = 1UL << 3
+};
+
+struct mlx4_config_dev_params {
+        u16     vxlan_udp_dport;
+        u8      rx_csum_flags_port_1;
+        u8      rx_csum_flags_port_2;
+};
+
 struct mlx4_dev;
 
 struct mlx4_cmd_mailbox {
@@ -248,6 +277,8 @@ int mlx4_set_vf_vlan(struct mlx4_dev *dev, int port, int vf, u16 vlan, u8 qos);
 int mlx4_set_vf_spoofchk(struct mlx4_dev *dev, int port, int vf, bool setting);
 int mlx4_get_vf_config(struct mlx4_dev *dev, int port, int vf, struct ifla_vf_info *ivf);
 int mlx4_set_vf_link_state(struct mlx4_dev *dev, int port, int vf, int link_state);
+int mlx4_config_dev_retrieval(struct mlx4_dev *dev,
+                              struct mlx4_config_dev_params *params);
 /*
  * mlx4_get_slave_default_vlan -
  * return true if VST ( default vlan)
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index a5b7d7cfcedf..25c791e295fd 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -38,6 +38,7 @@
 #include <linux/completion.h>
 #include <linux/radix-tree.h>
 #include <linux/cpu_rmap.h>
+#include <linux/crash_dump.h>
 
 #include <linux/atomic.h>
 
@@ -94,7 +95,7 @@ enum {
 
 enum {
         MLX4_MAX_NUM_PF         = 16,
-        MLX4_MAX_NUM_VF         = 64,
+        MLX4_MAX_NUM_VF         = 126,
         MLX4_MAX_NUM_VF_P_PORT  = 64,
         MLX4_MFUNC_MAX          = 80,
         MLX4_MAX_EQ_NUM         = 1024,
@@ -116,6 +117,14 @@ enum {
         MLX4_STEERING_MODE_DEVICE_MANAGED
 };
 
+enum {
+        MLX4_STEERING_DMFS_A0_DEFAULT,
+        MLX4_STEERING_DMFS_A0_DYNAMIC,
+        MLX4_STEERING_DMFS_A0_STATIC,
+        MLX4_STEERING_DMFS_A0_DISABLE,
+        MLX4_STEERING_DMFS_A0_NOT_SUPPORTED
+};
+
 static inline const char *mlx4_steering_mode_str(int steering_mode)
 {
         switch (steering_mode) {
@@ -184,19 +193,49 @@ enum {
         MLX4_DEV_CAP_FLAG2_DMFS_IPOIB           = 1LL <<  9,
         MLX4_DEV_CAP_FLAG2_VXLAN_OFFLOADS       = 1LL <<  10,
         MLX4_DEV_CAP_FLAG2_MAD_DEMUX            = 1LL <<  11,
+        MLX4_DEV_CAP_FLAG2_CQE_STRIDE           = 1LL <<  12,
+        MLX4_DEV_CAP_FLAG2_EQE_STRIDE           = 1LL <<  13,
+        MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL        = 1LL <<  14,
+        MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP    = 1LL <<  15,
+        MLX4_DEV_CAP_FLAG2_CONFIG_DEV           = 1LL <<  16,
+        MLX4_DEV_CAP_FLAG2_SYS_EQS              = 1LL <<  17,
+        MLX4_DEV_CAP_FLAG2_80_VFS               = 1LL <<  18,
+        MLX4_DEV_CAP_FLAG2_FS_A0                = 1LL <<  19
+};
+
+enum {
+        MLX4_QUERY_FUNC_FLAGS_BF_RES_QP         = 1LL << 0,
+        MLX4_QUERY_FUNC_FLAGS_A0_RES_QP         = 1LL << 1
+};
+
+/* bit enums for an 8-bit flags field indicating special use
+ * QPs which require special handling in qp_reserve_range.
+ * Currently, this only includes QPs used by the ETH interface,
+ * where we expect to use blueflame.  These QPs must not have
+ * bits 6 and 7 set in their qp number.
+ *
+ * This enum may use only bits 0..7.
+ */
+enum {
+        MLX4_RESERVE_A0_QP      = 1 << 6,
+        MLX4_RESERVE_ETH_BF_QP  = 1 << 7,
 };
 
 enum {
         MLX4_DEV_CAP_64B_EQE_ENABLED    = 1LL << 0,
-        MLX4_DEV_CAP_64B_CQE_ENABLED    = 1LL << 1
+        MLX4_DEV_CAP_64B_CQE_ENABLED    = 1LL << 1,
+        MLX4_DEV_CAP_CQE_STRIDE_ENABLED = 1LL << 2,
+        MLX4_DEV_CAP_EQE_STRIDE_ENABLED = 1LL << 3
 };
 
 enum {
-        MLX4_USER_DEV_CAP_64B_CQE       = 1L << 0
+        MLX4_USER_DEV_CAP_LARGE_CQE     = 1L << 0
 };
 
 enum {
-        MLX4_FUNC_CAP_64B_EQE_CQE       = 1L << 0
+        MLX4_FUNC_CAP_64B_EQE_CQE       = 1L << 0,
+        MLX4_FUNC_CAP_EQE_CQE_STRIDE    = 1L << 1,
+        MLX4_FUNC_CAP_DMFS_A0_STATIC    = 1L << 2
 };
 
 
@@ -322,6 +361,8 @@ enum {
 
 enum mlx4_qp_region {
         MLX4_QP_REGION_FW = 0,
+        MLX4_QP_REGION_RSS_RAW_ETH,
+        MLX4_QP_REGION_BOTTOM = MLX4_QP_REGION_RSS_RAW_ETH,
         MLX4_QP_REGION_ETH_ADDR,
         MLX4_QP_REGION_FC_ADDR,
         MLX4_QP_REGION_FC_EXCH,
@@ -373,6 +414,13 @@ enum {
 #define MSTR_SM_CHANGE_MASK (MLX4_EQ_PORT_INFO_MSTR_SM_SL_CHANGE_MASK | \
                              MLX4_EQ_PORT_INFO_MSTR_SM_LID_CHANGE_MASK)
 
+enum mlx4_module_id {
+        MLX4_MODULE_ID_SFP              = 0x3,
+        MLX4_MODULE_ID_QSFP             = 0xC,
+        MLX4_MODULE_ID_QSFP_PLUS        = 0xD,
+        MLX4_MODULE_ID_QSFP28           = 0x11,
+};
+
 static inline u64 mlx4_fw_ver(u64 major, u64 minor, u64 subminor)
 {
         return (major << 32) | (minor << 16) | subminor;
@@ -427,6 +475,7 @@ struct mlx4_caps {
         int                     num_cqs;
         int                     max_cqes;
         int                     reserved_cqs;
+        int                     num_sys_eqs;
         int                     num_eqs;
         int                     reserved_eqs;
         int                     num_comp_vectors;
@@ -443,6 +492,7 @@ struct mlx4_caps {
         int                     reserved_mcgs;
         int                     num_qp_per_mgm;
         int                     steering_mode;
+        int                     dmfs_high_steer_mode;
         int                     fs_log_max_ucast_qp_range_size;
         int                     num_pds;
         int                     reserved_pds;
@@ -481,6 +531,10 @@ struct mlx4_caps {
         u16                     hca_core_clock;
         u64                     phys_port_id[MLX4_MAX_PORTS + 1];
         int                     tunnel_offload_mode;
+        u8                      rx_checksum_flags_port[MLX4_MAX_PORTS + 1];
+        u8                      alloc_res_qp_mask;
+        u32                     dmfs_high_rate_qpn_base;
+        u32                     dmfs_high_rate_qpn_range;
 };
 
 struct mlx4_buf_list {
@@ -577,7 +631,7 @@ struct mlx4_uar {
 };
 
 struct mlx4_bf {
-        unsigned long           offset;
+        unsigned int            offset;
         int                     buf_size;
         struct mlx4_uar        *uar;
         void __iomem           *reg;
@@ -601,6 +655,11 @@ struct mlx4_cq {
 
         atomic_t                refcount;
         struct completion       free;
+        struct {
+                struct list_head list;
+                void (*comp)(struct mlx4_cq *);
+                void            *priv;
+        } tasklet_ctx;
 };
 
 struct mlx4_qp {
@@ -701,6 +760,7 @@ struct mlx4_dev {
         u64                     regid_promisc_array[MLX4_MAX_PORTS + 1];
         u64                     regid_allmulti_array[MLX4_MAX_PORTS + 1];
         struct mlx4_vf_dev     *dev_vfs;
+        int                     nvfs[MLX4_MAX_PORTS + 1];
 };
 
 struct mlx4_eqe {
@@ -792,6 +852,26 @@ struct mlx4_init_port_param {
         u64                     si_guid;
 };
 
+#define MAD_IFC_DATA_SZ 192
+/* MAD IFC Mailbox */
+struct mlx4_mad_ifc {
+        u8      base_version;
+        u8      mgmt_class;
+        u8      class_version;
+        u8      method;
+        __be16  status;
+        __be16  class_specific;
+        __be64  tid;
+        __be16  attr_id;
+        __be16  resv;
+        __be32  attr_mod;
+        __be64  mkey;
+        __be16  dr_slid;
+        __be16  dr_dlid;
+        u8      reserved[28];
+        u8      data[MAD_IFC_DATA_SZ];
+} __packed;
+
 #define mlx4_foreach_port(port, dev, type)                              \
         for ((port) = 1; (port) <= (dev)->caps.num_ports; (port)++)     \
                 if ((type) == (dev)->caps.port_mask[(port)])
@@ -828,7 +908,9 @@ static inline int mlx4_num_reserved_sqps(struct mlx4_dev *dev)
 static inline int mlx4_is_qp_reserved(struct mlx4_dev *dev, u32 qpn)
 {
         return (qpn < dev->phys_caps.base_sqpn + 8 +
-                16 * MLX4_MFUNC_MAX * !!mlx4_is_master(dev));
+                16 * MLX4_MFUNC_MAX * !!mlx4_is_master(dev) &&
+                qpn >= dev->phys_caps.base_sqpn) ||
+               (qpn < dev->caps.reserved_qps_cnt[MLX4_QP_REGION_FW]);
 }
 
 static inline int mlx4_is_guest_proxy(struct mlx4_dev *dev, int slave, u32 qpn)
@@ -904,8 +986,8 @@ int mlx4_cq_alloc(struct mlx4_dev *dev, int nent, struct mlx4_mtt *mtt,
                   struct mlx4_uar *uar, u64 db_rec, struct mlx4_cq *cq,
                   unsigned vector, int collapsed, int timestamp_en);
 void mlx4_cq_free(struct mlx4_dev *dev, struct mlx4_cq *cq);
-
-int mlx4_qp_reserve_range(struct mlx4_dev *dev, int cnt, int align, int *base);
+int mlx4_qp_reserve_range(struct mlx4_dev *dev, int cnt, int align,
+                          int *base, u8 flags);
 void mlx4_qp_release_range(struct mlx4_dev *dev, int base_qpn, int cnt);
 
 int mlx4_qp_alloc(struct mlx4_dev *dev, int qpn, struct mlx4_qp *qp,
@@ -1276,10 +1358,50 @@ int mlx4_mr_rereg_mem_write(struct mlx4_dev *dev, struct mlx4_mr *mr,
                             u64 iova, u64 size, int npages,
                             int page_shift, struct mlx4_mpt_entry *mpt_entry);
 
+int mlx4_get_module_info(struct mlx4_dev *dev, u8 port,
+                         u16 offset, u16 size, u8 *data);
+
 /* Returns true if running in low memory profile (kdump kernel) */
 static inline bool mlx4_low_memory_profile(void)
 {
-        return reset_devices;
+        return is_kdump_kernel();
 }
 
+/* ACCESS REG commands */
+enum mlx4_access_reg_method {
+        MLX4_ACCESS_REG_QUERY = 0x1,
+        MLX4_ACCESS_REG_WRITE = 0x2,
+};
+
+/* ACCESS PTYS Reg command */
+enum mlx4_ptys_proto {
+        MLX4_PTYS_IB = 1<<0,
+        MLX4_PTYS_EN = 1<<2,
+};
+
+struct mlx4_ptys_reg {
+        u8 resrvd1;
+        u8 local_port;
+        u8 resrvd2;
+        u8 proto_mask;
+        __be32 resrvd3[2];
+        __be32 eth_proto_cap;
+        __be16 ib_width_cap;
+        __be16 ib_speed_cap;
+        __be32 resrvd4;
+        __be32 eth_proto_admin;
+        __be16 ib_width_admin;
+        __be16 ib_speed_admin;
+        __be32 resrvd5;
+        __be32 eth_proto_oper;
+        __be16 ib_width_oper;
+        __be16 ib_speed_oper;
+        __be32 resrvd6;
+        __be32 eth_proto_lp_adv;
+} __packed;
+
+int mlx4_ACCESS_PTYS_REG(struct mlx4_dev *dev,
+                         enum mlx4_access_reg_method method,
+                         struct mlx4_ptys_reg *ptys_reg);
+
 #endif /* MLX4_DEVICE_H */
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index 5f4e36cf0091..467ccdf94c98 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -120,13 +120,15 @@ enum {
         MLX4_RSS_QPC_FLAG_OFFSET                = 13,
 };
 
+#define MLX4_EN_RSS_KEY_SIZE 40
+
 struct mlx4_rss_context {
         __be32                  base_qpn;
         __be32                  default_qpn;
         u16                     reserved;
         u8                      hash_fn;
         u8                      flags;
-        __be32                  rss_key[10];
+        __be32                  rss_key[MLX4_EN_RSS_KEY_SIZE / sizeof(__be32)];
         __be32                  base_qpn_udp;
 };
 
diff --git a/include/linux/mlx5/device.h b/include/linux/mlx5/device.h
index 334947151dfc..4e5bd813bb9a 100644
--- a/include/linux/mlx5/device.h
+++ b/include/linux/mlx5/device.h
@@ -44,6 +44,50 @@
 #error Host endianness not defined
 #endif
 
+/* helper macros */
+#define __mlx5_nullp(typ) ((struct mlx5_ifc_##typ##_bits *)0)
+#define __mlx5_bit_sz(typ, fld) sizeof(__mlx5_nullp(typ)->fld)
+#define __mlx5_bit_off(typ, fld) ((unsigned)(unsigned long)(&(__mlx5_nullp(typ)->fld)))
+#define __mlx5_dw_off(typ, fld) (__mlx5_bit_off(typ, fld) / 32)
+#define __mlx5_64_off(typ, fld) (__mlx5_bit_off(typ, fld) / 64)
+#define __mlx5_dw_bit_off(typ, fld) (32 - __mlx5_bit_sz(typ, fld) - (__mlx5_bit_off(typ, fld) & 0x1f))
+#define __mlx5_mask(typ, fld) ((u32)((1ull << __mlx5_bit_sz(typ, fld)) - 1))
+#define __mlx5_dw_mask(typ, fld) (__mlx5_mask(typ, fld) << __mlx5_dw_bit_off(typ, fld))
+#define __mlx5_st_sz_bits(typ) sizeof(struct mlx5_ifc_##typ##_bits)
+
+#define MLX5_FLD_SZ_BYTES(typ, fld) (__mlx5_bit_sz(typ, fld) / 8)
+#define MLX5_ST_SZ_BYTES(typ) (sizeof(struct mlx5_ifc_##typ##_bits) / 8)
+#define MLX5_ST_SZ_DW(typ) (sizeof(struct mlx5_ifc_##typ##_bits) / 32)
+#define MLX5_BYTE_OFF(typ, fld) (__mlx5_bit_off(typ, fld) / 8)
+#define MLX5_ADDR_OF(typ, p, fld) ((char *)(p) + MLX5_BYTE_OFF(typ, fld))
+
+/* insert a value to a struct */
+#define MLX5_SET(typ, p, fld, v) do { \
+        BUILD_BUG_ON(__mlx5_st_sz_bits(typ) % 32);             \
+        *((__be32 *)(p) + __mlx5_dw_off(typ, fld)) = \
+        cpu_to_be32((be32_to_cpu(*((__be32 *)(p) + __mlx5_dw_off(typ, fld))) & \
+                     (~__mlx5_dw_mask(typ, fld))) | (((v) & __mlx5_mask(typ, fld)) \
+                     << __mlx5_dw_bit_off(typ, fld))); \
+} while (0)
+
+#define MLX5_GET(typ, p, fld) ((be32_to_cpu(*((__be32 *)(p) +\
+__mlx5_dw_off(typ, fld))) >> __mlx5_dw_bit_off(typ, fld)) & \
+__mlx5_mask(typ, fld))
+
+#define MLX5_GET_PR(typ, p, fld) ({ \
+        u32 ___t = MLX5_GET(typ, p, fld); \
+        pr_debug(#fld " = 0x%x\n", ___t); \
+        ___t; \
+})
+
+#define MLX5_SET64(typ, p, fld, v) do { \
+        BUILD_BUG_ON(__mlx5_bit_sz(typ, fld) != 64); \
+        BUILD_BUG_ON(__mlx5_bit_off(typ, fld) % 64); \
+        *((__be64 *)(p) + __mlx5_64_off(typ, fld)) = cpu_to_be64(v); \
+} while (0)
+
+#define MLX5_GET64(typ, p, fld) be64_to_cpu(*((__be64 *)(p) + __mlx5_64_off(typ, fld)))
+
 enum {
         MLX5_MAX_COMMANDS               = 32,
         MLX5_CMD_DATA_BLOCK_SIZE        = 512,
@@ -71,6 +115,20 @@ enum {
 };
 
 enum {
+        MLX5_MIN_PKEY_TABLE_SIZE = 128,
+        MLX5_MAX_LOG_PKEY_TABLE  = 5,
+};
+
+enum {
+        MLX5_MKEY_INBOX_PG_ACCESS = 1 << 31
+};
+
+enum {
+        MLX5_PFAULT_SUBTYPE_WQE = 0,
+        MLX5_PFAULT_SUBTYPE_RDMA = 1,
+};
+
+enum {
         MLX5_PERM_LOCAL_READ    = 1 << 2,
         MLX5_PERM_LOCAL_WRITE   = 1 << 3,
         MLX5_PERM_REMOTE_READ   = 1 << 4,
@@ -131,6 +189,19 @@ enum {
         MLX5_MKEY_MASK_FREE             = 1ull << 29,
 };
 
+enum {
+        MLX5_UMR_TRANSLATION_OFFSET_EN  = (1 << 4),
+
+        MLX5_UMR_CHECK_NOT_FREE         = (1 << 5),
+        MLX5_UMR_CHECK_FREE             = (2 << 5),
+
+        MLX5_UMR_INLINE                 = (1 << 7),
+};
+
+#define MLX5_UMR_MTT_ALIGNMENT 0x40
+#define MLX5_UMR_MTT_MASK      (MLX5_UMR_MTT_ALIGNMENT - 1)
+#define MLX5_UMR_MTT_MIN_CHUNK_SIZE MLX5_UMR_MTT_ALIGNMENT
+
 enum mlx5_event {
         MLX5_EVENT_TYPE_COMP               = 0x0,
 
@@ -157,6 +228,8 @@ enum mlx5_event {
 
         MLX5_EVENT_TYPE_CMD                = 0x0a,
         MLX5_EVENT_TYPE_PAGE_REQUEST       = 0xb,
+
+        MLX5_EVENT_TYPE_PAGE_FAULT         = 0xc,
 };
 
 enum {
@@ -170,11 +243,7 @@ enum {
 };
 
 enum {
-        MLX5_DEV_CAP_FLAG_RC            = 1LL <<  0,
-        MLX5_DEV_CAP_FLAG_UC            = 1LL <<  1,
-        MLX5_DEV_CAP_FLAG_UD            = 1LL <<  2,
         MLX5_DEV_CAP_FLAG_XRC           = 1LL <<  3,
-        MLX5_DEV_CAP_FLAG_SRQ           = 1LL <<  6,
         MLX5_DEV_CAP_FLAG_BAD_PKEY_CNTR = 1LL <<  8,
         MLX5_DEV_CAP_FLAG_BAD_QKEY_CNTR = 1LL <<  9,
         MLX5_DEV_CAP_FLAG_APM           = 1LL << 17,
@@ -183,11 +252,8 @@ enum {
         MLX5_DEV_CAP_FLAG_ON_DMND_PG    = 1LL << 24,
         MLX5_DEV_CAP_FLAG_CQ_MODER      = 1LL << 29,
         MLX5_DEV_CAP_FLAG_RESIZE_CQ     = 1LL << 30,
-        MLX5_DEV_CAP_FLAG_RESIZE_SRQ    = 1LL << 32,
-        MLX5_DEV_CAP_FLAG_REMOTE_FENCE  = 1LL << 38,
-        MLX5_DEV_CAP_FLAG_TLP_HINTS     = 1LL << 39,
+        MLX5_DEV_CAP_FLAG_DCT           = 1LL << 37,
         MLX5_DEV_CAP_FLAG_SIG_HAND_OVER = 1LL << 40,
-        MLX5_DEV_CAP_FLAG_DCT           = 1LL << 41,
         MLX5_DEV_CAP_FLAG_CMDIF_CSUM    = 3LL << 46,
 };
 
@@ -243,10 +309,16 @@ enum {
 };
 
 enum {
-        MLX5_CAP_OFF_DCT                = 41,
         MLX5_CAP_OFF_CMDIF_CSUM         = 46,
 };
 
+enum {
+        HCA_CAP_OPMOD_GET_MAX   = 0,
+        HCA_CAP_OPMOD_GET_CUR   = 1,
+        HCA_CAP_OPMOD_GET_ODP_MAX = 4,
+        HCA_CAP_OPMOD_GET_ODP_CUR = 5
+};
+
 struct mlx5_inbox_hdr {
         __be16          opcode;
         u8              rsvd[4];
@@ -274,101 +346,23 @@ struct mlx5_cmd_query_adapter_mbox_out {
         u8                      vsd_psid[16];
 };
 
-struct mlx5_hca_cap {
-        u8      rsvd1[16];
-        u8      log_max_srq_sz;
-        u8      log_max_qp_sz;
-        u8      rsvd2;
-        u8      log_max_qp;
-        u8      log_max_strq_sz;
-        u8      log_max_srqs;
-        u8      rsvd4[2];
-        u8      rsvd5;
-        u8      log_max_cq_sz;
-        u8      rsvd6;
-        u8      log_max_cq;
-        u8      log_max_eq_sz;
-        u8      log_max_mkey;
-        u8      rsvd7;
-        u8      log_max_eq;
-        u8      max_indirection;
-        u8      log_max_mrw_sz;
-        u8      log_max_bsf_list_sz;
-        u8      log_max_klm_list_sz;
-        u8      rsvd_8_0;
-        u8      log_max_ra_req_dc;
-        u8      rsvd_8_1;
-        u8      log_max_ra_res_dc;
-        u8      rsvd9;
-        u8      log_max_ra_req_qp;
-        u8      rsvd10;
-        u8      log_max_ra_res_qp;
-        u8      rsvd11[4];
-        __be16  max_qp_count;
-        __be16  rsvd12;
-        u8      rsvd13;
-        u8      local_ca_ack_delay;
-        u8      rsvd14;
-        u8      num_ports;
-        u8      log_max_msg;
-        u8      rsvd15[3];
-        __be16  stat_rate_support;
-        u8      rsvd16[2];
-        __be64  flags;
-        u8      rsvd17;
-        u8      uar_sz;
-        u8      rsvd18;
-        u8      log_pg_sz;
-        __be16  bf_log_bf_reg_size;
-        u8      rsvd19[4];
-        __be16  max_desc_sz_sq;
-        u8      rsvd20[2];
-        __be16  max_desc_sz_rq;
-        u8      rsvd21[2];
-        __be16  max_desc_sz_sq_dc;
-        __be32  max_qp_mcg;
-        u8      rsvd22[3];
-        u8      log_max_mcg;
-        u8      rsvd23;
-        u8      log_max_pd;
-        u8      rsvd24;
-        u8      log_max_xrcd;
-        u8      rsvd25[42];
-        __be16  log_uar_page_sz;
-        u8      rsvd26[28];
-        u8      log_max_atomic_size_qp;
-        u8      rsvd27[2];
-        u8      log_max_atomic_size_dc;
-        u8      rsvd28[76];
-};
-
-
-struct mlx5_cmd_query_hca_cap_mbox_in {
-        struct mlx5_inbox_hdr   hdr;
-        u8                      rsvd[8];
-};
-
-
-struct mlx5_cmd_query_hca_cap_mbox_out {
-        struct mlx5_outbox_hdr  hdr;
-        u8                      rsvd0[8];
-        struct mlx5_hca_cap     hca_cap;
+enum mlx5_odp_transport_cap_bits {
+        MLX5_ODP_SUPPORT_SEND    = 1 << 31,
+        MLX5_ODP_SUPPORT_RECV    = 1 << 30,
+        MLX5_ODP_SUPPORT_WRITE   = 1 << 29,
+        MLX5_ODP_SUPPORT_READ    = 1 << 28,
 };
 
-
-struct mlx5_cmd_set_hca_cap_mbox_in {
-        struct mlx5_inbox_hdr   hdr;
-        u8                      rsvd[8];
-        struct mlx5_hca_cap     hca_cap;
+struct mlx5_odp_caps {
+        char reserved[0x10];
+        struct {
+                __be32                  rc_odp_caps;
+                __be32                  uc_odp_caps;
+                __be32                  ud_odp_caps;
+        } per_transport_caps;
+        char reserved2[0xe4];
 };
 
-
-struct mlx5_cmd_set_hca_cap_mbox_out {
-        struct mlx5_outbox_hdr  hdr;
-        u8                      rsvd0[8];
-};
-
-
 struct mlx5_cmd_init_hca_mbox_in {
         struct mlx5_inbox_hdr   hdr;
         u8                      rsvd0[2];
@@ -489,6 +483,27 @@ struct mlx5_eqe_page_req {
         __be32          rsvd1[5];
 };
 
+struct mlx5_eqe_page_fault {
+        __be32 bytes_committed;
+        union {
+                struct {
+                        u16     reserved1;
+                        __be16  wqe_index;
+                        u16     reserved2;
+                        __be16  packet_length;
+                        u8      reserved3[12];
+                } __packed wqe;
+                struct {
+                        __be32  r_key;
+                        u16     reserved1;
+                        __be16  packet_length;
+                        __be32  rdma_op_len;
+                        __be64  rdma_va;
+                } __packed rdma;
+        } __packed;
+        __be32 flags_qpn;
+} __packed;
+
 union ev_data {
         __be32                          raw[7];
         struct mlx5_eqe_cmd             cmd;
@@ -500,6 +515,7 @@ union ev_data {
         struct mlx5_eqe_congestion      cong;
         struct mlx5_eqe_stall_vl        stall_vl;
         struct mlx5_eqe_page_req        req_pages;
+        struct mlx5_eqe_page_fault      page_fault;
 } __packed;
 
 struct mlx5_eqe {
@@ -826,6 +842,10 @@ struct mlx5_query_eq_mbox_out {
         struct mlx5_eq_context  ctx;
 };
 
+enum {
+        MLX5_MKEY_STATUS_FREE = 1 << 6,
+};
+
 struct mlx5_mkey_seg {
         /* This is a two bit field occupying bits 31-30.
          * bit 31 is always 0,
@@ -862,7 +882,7 @@ struct mlx5_query_special_ctxs_mbox_out {
 struct mlx5_create_mkey_mbox_in {
         struct mlx5_inbox_hdr   hdr;
         __be32                  input_mkey_index;
-        u8                      rsvd0[4];
+        __be32                  flags;
         struct mlx5_mkey_seg    seg;
         u8                      rsvd1[16];
         __be32                  xlat_oct_act_size;
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index b88e9b46d957..166d9315fe4b 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -44,6 +44,7 @@
 
 #include <linux/mlx5/device.h>
 #include <linux/mlx5/doorbell.h>
+#include <linux/mlx5/mlx5_ifc.h>
 
 enum {
         MLX5_BOARD_ID_LEN = 64,
@@ -99,81 +100,6 @@ enum {
 };
 
 enum {
-        MLX5_CMD_OP_QUERY_HCA_CAP               = 0x100,
-        MLX5_CMD_OP_QUERY_ADAPTER               = 0x101,
-        MLX5_CMD_OP_INIT_HCA                    = 0x102,
-        MLX5_CMD_OP_TEARDOWN_HCA                = 0x103,
-        MLX5_CMD_OP_ENABLE_HCA                  = 0x104,
-        MLX5_CMD_OP_DISABLE_HCA                 = 0x105,
-        MLX5_CMD_OP_QUERY_PAGES                 = 0x107,
-        MLX5_CMD_OP_MANAGE_PAGES                = 0x108,
-        MLX5_CMD_OP_SET_HCA_CAP                 = 0x109,
-
-        MLX5_CMD_OP_CREATE_MKEY                 = 0x200,
-        MLX5_CMD_OP_QUERY_MKEY                  = 0x201,
-        MLX5_CMD_OP_DESTROY_MKEY                = 0x202,
-        MLX5_CMD_OP_QUERY_SPECIAL_CONTEXTS      = 0x203,
-
-        MLX5_CMD_OP_CREATE_EQ                   = 0x301,
-        MLX5_CMD_OP_DESTROY_EQ                  = 0x302,
-        MLX5_CMD_OP_QUERY_EQ                    = 0x303,
-
-        MLX5_CMD_OP_CREATE_CQ                   = 0x400,
-        MLX5_CMD_OP_DESTROY_CQ                  = 0x401,
-        MLX5_CMD_OP_QUERY_CQ                    = 0x402,
-        MLX5_CMD_OP_MODIFY_CQ                   = 0x403,
-
-        MLX5_CMD_OP_CREATE_QP                   = 0x500,
-        MLX5_CMD_OP_DESTROY_QP                  = 0x501,
-        MLX5_CMD_OP_RST2INIT_QP                 = 0x502,
-        MLX5_CMD_OP_INIT2RTR_QP                 = 0x503,
-        MLX5_CMD_OP_RTR2RTS_QP                  = 0x504,
-        MLX5_CMD_OP_RTS2RTS_QP                  = 0x505,
-        MLX5_CMD_OP_SQERR2RTS_QP                = 0x506,
-        MLX5_CMD_OP_2ERR_QP                     = 0x507,
-        MLX5_CMD_OP_RTS2SQD_QP                  = 0x508,
-        MLX5_CMD_OP_SQD2RTS_QP                  = 0x509,
-        MLX5_CMD_OP_2RST_QP                     = 0x50a,
-        MLX5_CMD_OP_QUERY_QP                    = 0x50b,
-        MLX5_CMD_OP_CONF_SQP                    = 0x50c,
-        MLX5_CMD_OP_MAD_IFC                     = 0x50d,
-        MLX5_CMD_OP_INIT2INIT_QP                = 0x50e,
-        MLX5_CMD_OP_SUSPEND_QP                  = 0x50f,
-        MLX5_CMD_OP_UNSUSPEND_QP                = 0x510,
-        MLX5_CMD_OP_SQD2SQD_QP                  = 0x511,
-        MLX5_CMD_OP_ALLOC_QP_COUNTER_SET        = 0x512,
-        MLX5_CMD_OP_DEALLOC_QP_COUNTER_SET      = 0x513,
-        MLX5_CMD_OP_QUERY_QP_COUNTER_SET        = 0x514,
-
-        MLX5_CMD_OP_CREATE_PSV                  = 0x600,
-        MLX5_CMD_OP_DESTROY_PSV                 = 0x601,
-        MLX5_CMD_OP_QUERY_PSV                   = 0x602,
-        MLX5_CMD_OP_QUERY_SIG_RULE_TABLE        = 0x603,
-        MLX5_CMD_OP_QUERY_BLOCK_SIZE_TABLE      = 0x604,
-
-        MLX5_CMD_OP_CREATE_SRQ                  = 0x700,
-        MLX5_CMD_OP_DESTROY_SRQ                 = 0x701,
-        MLX5_CMD_OP_QUERY_SRQ                   = 0x702,
-        MLX5_CMD_OP_ARM_RQ                      = 0x703,
-        MLX5_CMD_OP_RESIZE_SRQ                  = 0x704,
-
-        MLX5_CMD_OP_ALLOC_PD                    = 0x800,
-        MLX5_CMD_OP_DEALLOC_PD                  = 0x801,
-        MLX5_CMD_OP_ALLOC_UAR                   = 0x802,
-        MLX5_CMD_OP_DEALLOC_UAR                 = 0x803,
-
-        MLX5_CMD_OP_ATTACH_TO_MCG               = 0x806,
-        MLX5_CMD_OP_DETACH_FROM_MCG             = 0x807,
-
-
-        MLX5_CMD_OP_ALLOC_XRCD                  = 0x80e,
-        MLX5_CMD_OP_DEALLOC_XRCD                = 0x80f,
-
-        MLX5_CMD_OP_ACCESS_REG                  = 0x805,
-        MLX5_CMD_OP_MAX                         = 0x810,
-};
-
-enum {
         MLX5_REG_PCAP            = 0x5001,
         MLX5_REG_PMTU            = 0x5003,
         MLX5_REG_PTYS            = 0x5004,
@@ -187,6 +113,13 @@ enum {
         MLX5_REG_HOST_ENDIANNESS = 0x7004,
 };
 
+enum mlx5_page_fault_resume_flags {
+        MLX5_PAGE_FAULT_RESUME_REQUESTOR = 1 << 0,
+        MLX5_PAGE_FAULT_RESUME_WRITE     = 1 << 1,
+        MLX5_PAGE_FAULT_RESUME_RDMA      = 1 << 2,
+        MLX5_PAGE_FAULT_RESUME_ERROR     = 1 << 7,
+};
+
 enum dbg_rsc_type {
         MLX5_DBG_RSC_QP,
         MLX5_DBG_RSC_EQ,
@@ -335,23 +268,30 @@ struct mlx5_port_caps {
         int     pkey_table_len;
 };
 
-struct mlx5_caps {
+struct mlx5_general_caps {
         u8      log_max_eq;
         u8      log_max_cq;
         u8      log_max_qp;
         u8      log_max_mkey;
         u8      log_max_pd;
         u8      log_max_srq;
+        u8      log_max_strq;
+        u8      log_max_mrw_sz;
+        u8      log_max_bsf_list_size;
+        u8      log_max_klm_list_size;
         u32     max_cqes;
         int     max_wqes;
+        u32     max_eqes;
+        u32     max_indirection;
         int     max_sq_desc_sz;
         int     max_rq_desc_sz;
+        int     max_dc_sq_desc_sz;
         u64     flags;
         u16     stat_rate_support;
         int     log_max_msg;
         int     num_ports;
-        int     max_ra_res_qp;
-        int     max_ra_req_qp;
+        u8      log_max_ra_res_qp;
+        u8      log_max_ra_req_qp;
         int     max_srq_wqes;
         int     bf_reg_size;
         int     bf_regs_per_page;
@@ -363,6 +303,19 @@ struct mlx5_caps {
         u8      log_max_mcg;
         u32     max_qp_mcg;
         int     min_page_sz;
+        int     pd_cap;
+        u32     max_qp_counters;
+        u32     pkey_table_size;
+        u8      log_max_ra_req_dc;
+        u8      log_max_ra_res_dc;
+        u32     uar_sz;
+        u8      min_log_pg_sz;
+        u8      log_max_xrcd;
+        u16     log_uar_page_sz;
+};
+
+struct mlx5_caps {
+        struct mlx5_general_caps gen;
 };
 
 struct mlx5_cmd_mailbox {
@@ -429,6 +382,16 @@ struct mlx5_core_mr {
         u32                     pd;
 };
 
+enum mlx5_res_type {
+        MLX5_RES_QP,
+};
+
+struct mlx5_core_rsc_common {
+        enum mlx5_res_type      res;
+        atomic_t                refcount;
+        struct completion       free;
+};
+
 struct mlx5_core_srq {
         u32             srqn;
         int             max;
@@ -511,7 +474,7 @@ struct mlx5_priv {
         struct workqueue_struct *pg_wq;
         struct rb_root          page_root;
         int                     fw_pages;
-        int                     reg_pages;
+        atomic_t                reg_pages;
         struct list_head        free_list;
 
         struct mlx5_core_health health;
@@ -677,14 +640,6 @@ static inline void *mlx5_vzalloc(unsigned long size)
         return rtn;
 }
 
-static inline void mlx5_vfree(const void *addr)
-{
-        if (addr && is_vmalloc_addr(addr))
-                vfree(addr);
-        else
-                kfree(addr);
-}
-
 static inline u32 mlx5_base_mkey(const u32 key)
 {
         return key & 0xffffff00u;
@@ -695,6 +650,9 @@ void mlx5_cmd_cleanup(struct mlx5_core_dev *dev);
 void mlx5_cmd_use_events(struct mlx5_core_dev *dev);
 void mlx5_cmd_use_polling(struct mlx5_core_dev *dev);
 int mlx5_cmd_status_to_err(struct mlx5_outbox_hdr *hdr);
+int mlx5_cmd_status_to_err_v2(void *ptr);
+int mlx5_core_get_caps(struct mlx5_core_dev *dev, struct mlx5_caps *caps,
+                       u16 opmod);
 int mlx5_cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out,
                   int out_size);
 int mlx5_cmd_exec_cb(struct mlx5_core_dev *dev, void *in, int in_size,
@@ -751,7 +709,10 @@ int mlx5_eq_init(struct mlx5_core_dev *dev);
 void mlx5_eq_cleanup(struct mlx5_core_dev *dev);
 void mlx5_fill_page_array(struct mlx5_buf *buf, __be64 *pas);
 void mlx5_cq_completion(struct mlx5_core_dev *dev, u32 cqn);
-void mlx5_qp_event(struct mlx5_core_dev *dev, u32 qpn, int event_type);
+void mlx5_rsc_event(struct mlx5_core_dev *dev, u32 rsn, int event_type);
+#ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
+void mlx5_eq_pagefault(struct mlx5_core_dev *dev, struct mlx5_eqe *eqe);
+#endif
 void mlx5_srq_event(struct mlx5_core_dev *dev, u32 srqn, int event_type);
 struct mlx5_core_srq *mlx5_core_get_srq(struct mlx5_core_dev *dev, u32 srqn);
 void mlx5_cmd_comp_handler(struct mlx5_core_dev *dev, unsigned long vector);
@@ -788,6 +749,9 @@ void mlx5_cmdif_debugfs_cleanup(struct mlx5_core_dev *dev);
 int mlx5_core_create_psv(struct mlx5_core_dev *dev, u32 pdn,
                          int npsvs, u32 *sig_index);
 int mlx5_core_destroy_psv(struct mlx5_core_dev *dev, int psv_num);
+void mlx5_core_put_rsc(struct mlx5_core_rsc_common *common);
+int mlx5_query_odp_caps(struct mlx5_core_dev *dev,
+                        struct mlx5_odp_caps *odp_caps);
 
 static inline u32 mlx5_mkey_to_idx(u32 mkey)
 {
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
new file mode 100644
index 000000000000..5f48b8f592c5
--- /dev/null
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c) 2014, Mellanox Technologies inc.  All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef MLX5_IFC_H
+#define MLX5_IFC_H
+
+enum {
+        MLX5_CMD_OP_QUERY_HCA_CAP                 = 0x100,
+        MLX5_CMD_OP_QUERY_ADAPTER                 = 0x101,
+        MLX5_CMD_OP_INIT_HCA                      = 0x102,
+        MLX5_CMD_OP_TEARDOWN_HCA                  = 0x103,
+        MLX5_CMD_OP_ENABLE_HCA                    = 0x104,
+        MLX5_CMD_OP_DISABLE_HCA                   = 0x105,
+        MLX5_CMD_OP_QUERY_PAGES                   = 0x107,
+        MLX5_CMD_OP_MANAGE_PAGES                  = 0x108,
+        MLX5_CMD_OP_SET_HCA_CAP                   = 0x109,
+        MLX5_CMD_OP_CREATE_MKEY                   = 0x200,
+        MLX5_CMD_OP_QUERY_MKEY                    = 0x201,
+        MLX5_CMD_OP_DESTROY_MKEY                  = 0x202,
+        MLX5_CMD_OP_QUERY_SPECIAL_CONTEXTS        = 0x203,
+        MLX5_CMD_OP_PAGE_FAULT_RESUME             = 0x204,
+        MLX5_CMD_OP_CREATE_EQ                     = 0x301,
+        MLX5_CMD_OP_DESTROY_EQ                    = 0x302,
+        MLX5_CMD_OP_QUERY_EQ                      = 0x303,
+        MLX5_CMD_OP_GEN_EQE                       = 0x304,
+        MLX5_CMD_OP_CREATE_CQ                     = 0x400,
+        MLX5_CMD_OP_DESTROY_CQ                    = 0x401,
+        MLX5_CMD_OP_QUERY_CQ                      = 0x402,
+        MLX5_CMD_OP_MODIFY_CQ                     = 0x403,
+        MLX5_CMD_OP_CREATE_QP                     = 0x500,
+        MLX5_CMD_OP_DESTROY_QP                    = 0x501,
+        MLX5_CMD_OP_RST2INIT_QP                   = 0x502,
+        MLX5_CMD_OP_INIT2RTR_QP                   = 0x503,
+        MLX5_CMD_OP_RTR2RTS_QP                    = 0x504,
+        MLX5_CMD_OP_RTS2RTS_QP                    = 0x505,
+        MLX5_CMD_OP_SQERR2RTS_QP                  = 0x506,
+        MLX5_CMD_OP_2ERR_QP                       = 0x507,
+        MLX5_CMD_OP_2RST_QP                       = 0x50a,
+        MLX5_CMD_OP_QUERY_QP                      = 0x50b,
+        MLX5_CMD_OP_INIT2INIT_QP                  = 0x50e,
+        MLX5_CMD_OP_CREATE_PSV                    = 0x600,
+        MLX5_CMD_OP_DESTROY_PSV                   = 0x601,
+        MLX5_CMD_OP_CREATE_SRQ                    = 0x700,
+        MLX5_CMD_OP_DESTROY_SRQ                   = 0x701,
+        MLX5_CMD_OP_QUERY_SRQ                     = 0x702,
+        MLX5_CMD_OP_ARM_RQ                        = 0x703,
+        MLX5_CMD_OP_RESIZE_SRQ                    = 0x704,
+        MLX5_CMD_OP_CREATE_DCT                    = 0x710,
+        MLX5_CMD_OP_DESTROY_DCT                   = 0x711,
+        MLX5_CMD_OP_DRAIN_DCT                     = 0x712,
+        MLX5_CMD_OP_QUERY_DCT                     = 0x713,
+        MLX5_CMD_OP_ARM_DCT_FOR_KEY_VIOLATION     = 0x714,
+        MLX5_CMD_OP_QUERY_VPORT_STATE             = 0x750,
+        MLX5_CMD_OP_MODIFY_VPORT_STATE            = 0x751,
+        MLX5_CMD_OP_QUERY_ESW_VPORT_CONTEXT       = 0x752,
+        MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT      = 0x753,
+        MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT       = 0x754,
+        MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT      = 0x755,
+        MLX5_CMD_OP_QUERY_RCOE_ADDRESS            = 0x760,
+        MLX5_CMD_OP_SET_ROCE_ADDRESS              = 0x761,
+        MLX5_CMD_OP_QUERY_VPORT_COUNTER           = 0x770,
+        MLX5_CMD_OP_ALLOC_Q_COUNTER               = 0x771,
+        MLX5_CMD_OP_DEALLOC_Q_COUNTER             = 0x772,
+        MLX5_CMD_OP_QUERY_Q_COUNTER               = 0x773,
+        MLX5_CMD_OP_ALLOC_PD                      = 0x800,
+        MLX5_CMD_OP_DEALLOC_PD                    = 0x801,
+        MLX5_CMD_OP_ALLOC_UAR                     = 0x802,
+        MLX5_CMD_OP_DEALLOC_UAR                   = 0x803,
+        MLX5_CMD_OP_CONFIG_INT_MODERATION         = 0x804,
+        MLX5_CMD_OP_ACCESS_REG                    = 0x805,
+        MLX5_CMD_OP_ATTACH_TO_MCG                 = 0x806,
+        MLX5_CMD_OP_DETACH_FROM_MCG               = 0x807,
+        MLX5_CMD_OP_GET_DROPPED_PACKET_LOG        = 0x80a,
+        MLX5_CMD_OP_MAD_IFC                       = 0x50d,
+        MLX5_CMD_OP_QUERY_MAD_DEMUX               = 0x80b,
+        MLX5_CMD_OP_SET_MAD_DEMUX                 = 0x80c,
+        MLX5_CMD_OP_NOP                           = 0x80d,
+        MLX5_CMD_OP_ALLOC_XRCD                    = 0x80e,
+        MLX5_CMD_OP_DEALLOC_XRCD                  = 0x80f,
+        MLX5_CMD_OP_SET_BURST_SIZE                = 0x812,
+        MLX5_CMD_OP_QUERY_BURST_SZIE              = 0x813,
+        MLX5_CMD_OP_ACTIVATE_TRACER               = 0x814,
+        MLX5_CMD_OP_DEACTIVATE_TRACER             = 0x815,
+        MLX5_CMD_OP_CREATE_SNIFFER_RULE           = 0x820,
+        MLX5_CMD_OP_DESTROY_SNIFFER_RULE          = 0x821,
+        MLX5_CMD_OP_QUERY_CONG_PARAMS             = 0x822,
+        MLX5_CMD_OP_MODIFY_CONG_PARAMS            = 0x823,
+        MLX5_CMD_OP_QUERY_CONG_STATISTICS         = 0x824,
+        MLX5_CMD_OP_CREATE_TIR                    = 0x900,
+        MLX5_CMD_OP_MODIFY_TIR                    = 0x901,
+        MLX5_CMD_OP_DESTROY_TIR                   = 0x902,
+        MLX5_CMD_OP_QUERY_TIR                     = 0x903,
+        MLX5_CMD_OP_CREATE_TIS                    = 0x912,
+        MLX5_CMD_OP_MODIFY_TIS                    = 0x913,
+        MLX5_CMD_OP_DESTROY_TIS                   = 0x914,
+        MLX5_CMD_OP_QUERY_TIS                     = 0x915,
+        MLX5_CMD_OP_CREATE_SQ                     = 0x904,
+        MLX5_CMD_OP_MODIFY_SQ                     = 0x905,
+        MLX5_CMD_OP_DESTROY_SQ                    = 0x906,
+        MLX5_CMD_OP_QUERY_SQ                      = 0x907,
+        MLX5_CMD_OP_CREATE_RQ                     = 0x908,
+        MLX5_CMD_OP_MODIFY_RQ                     = 0x909,
+        MLX5_CMD_OP_DESTROY_RQ                    = 0x90a,
+        MLX5_CMD_OP_QUERY_RQ                      = 0x90b,
+        MLX5_CMD_OP_CREATE_RMP                    = 0x90c,
+        MLX5_CMD_OP_MODIFY_RMP                    = 0x90d,
+        MLX5_CMD_OP_DESTROY_RMP                   = 0x90e,
+        MLX5_CMD_OP_QUERY_RMP                     = 0x90f,
+        MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY          = 0x910,
+        MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY        = 0x911,
+        MLX5_CMD_OP_MAX                           = 0x911
+};
+
+struct mlx5_ifc_cmd_hca_cap_bits {
+        u8         reserved_0[0x80];
+
+        u8         log_max_srq_sz[0x8];
+        u8         log_max_qp_sz[0x8];
+        u8         reserved_1[0xb];
+        u8         log_max_qp[0x5];
+
+        u8         log_max_strq_sz[0x8];
+        u8         reserved_2[0x3];
+        u8         log_max_srqs[0x5];
+        u8         reserved_3[0x10];
+
+        u8         reserved_4[0x8];
+        u8         log_max_cq_sz[0x8];
+        u8         reserved_5[0xb];
+        u8         log_max_cq[0x5];
+
+        u8         log_max_eq_sz[0x8];
+        u8         reserved_6[0x2];
+        u8         log_max_mkey[0x6];
+        u8         reserved_7[0xc];
+        u8         log_max_eq[0x4];
+
+        u8         max_indirection[0x8];
+        u8         reserved_8[0x1];
+        u8         log_max_mrw_sz[0x7];
+        u8         reserved_9[0x2];
+        u8         log_max_bsf_list_size[0x6];
+        u8         reserved_10[0x2];
+        u8         log_max_klm_list_size[0x6];
+
+        u8         reserved_11[0xa];
+        u8         log_max_ra_req_dc[0x6];
+        u8         reserved_12[0xa];
+        u8         log_max_ra_res_dc[0x6];
+
+        u8         reserved_13[0xa];
+        u8         log_max_ra_req_qp[0x6];
+        u8         reserved_14[0xa];
+        u8         log_max_ra_res_qp[0x6];
+
+        u8         pad_cap[0x1];
+        u8         cc_query_allowed[0x1];
+        u8         cc_modify_allowed[0x1];
+        u8         reserved_15[0x1d];
+
+        u8         reserved_16[0x6];
+        u8         max_qp_cnt[0xa];
+        u8         pkey_table_size[0x10];
+
+        u8         eswitch_owner[0x1];
+        u8         reserved_17[0xa];
+        u8         local_ca_ack_delay[0x5];
+        u8         reserved_18[0x8];
+        u8         num_ports[0x8];
+
+        u8         reserved_19[0x3];
+        u8         log_max_msg[0x5];
+        u8         reserved_20[0x18];
+
+        u8         stat_rate_support[0x10];
+        u8         reserved_21[0x10];
+
+        u8         reserved_22[0x10];
+        u8         cmdif_checksum[0x2];
+        u8         sigerr_cqe[0x1];
+        u8         reserved_23[0x1];
+        u8         wq_signature[0x1];
+        u8         sctr_data_cqe[0x1];
+        u8         reserved_24[0x1];
+        u8         sho[0x1];
+        u8         tph[0x1];
+        u8         rf[0x1];
+        u8         dc[0x1];
+        u8         reserved_25[0x2];
+        u8         roce[0x1];
+        u8         atomic[0x1];
+        u8         rsz_srq[0x1];
+
+        u8         cq_oi[0x1];
+        u8         cq_resize[0x1];
+        u8         cq_moderation[0x1];
+        u8         sniffer_rule_flow[0x1];
+        u8         sniffer_rule_vport[0x1];
+        u8         sniffer_rule_phy[0x1];
+        u8         reserved_26[0x1];
+        u8         pg[0x1];
+        u8         block_lb_mc[0x1];
+        u8         reserved_27[0x3];
+        u8         cd[0x1];
+        u8         reserved_28[0x1];
+        u8         apm[0x1];
+        u8         reserved_29[0x7];
+        u8         qkv[0x1];
+        u8         pkv[0x1];
+        u8         reserved_30[0x4];
+        u8         xrc[0x1];
+        u8         ud[0x1];
+        u8         uc[0x1];
+        u8         rc[0x1];
+
+        u8         reserved_31[0xa];
+        u8         uar_sz[0x6];
+        u8         reserved_32[0x8];
+        u8         log_pg_sz[0x8];
+
+        u8         bf[0x1];
+        u8         reserved_33[0xa];
+        u8         log_bf_reg_size[0x5];
+        u8         reserved_34[0x10];
+
+        u8         reserved_35[0x10];
+        u8         max_wqe_sz_sq[0x10];
+
+        u8         reserved_36[0x10];
+        u8         max_wqe_sz_rq[0x10];
+
+        u8         reserved_37[0x10];
+        u8         max_wqe_sz_sq_dc[0x10];
+
+        u8         reserved_38[0x7];
+        u8         max_qp_mcg[0x19];
+
+        u8         reserved_39[0x18];
+        u8         log_max_mcg[0x8];
+
+        u8         reserved_40[0xb];
+        u8         log_max_pd[0x5];
+        u8         reserved_41[0xb];
+        u8         log_max_xrcd[0x5];
+
+        u8         reserved_42[0x20];
+
+        u8         reserved_43[0x3];
+        u8         log_max_rq[0x5];
+        u8         reserved_44[0x3];
+        u8         log_max_sq[0x5];
+        u8         reserved_45[0x3];
+        u8         log_max_tir[0x5];
+        u8         reserved_46[0x3];
+        u8         log_max_tis[0x5];
+
+        u8         reserved_47[0x13];
+        u8         log_max_rq_per_tir[0x5];
+        u8         reserved_48[0x3];
+        u8         log_max_tis_per_sq[0x5];
+
+        u8         reserved_49[0xe0];
+
+        u8         reserved_50[0x10];
+        u8         log_uar_page_sz[0x10];
+
+        u8         reserved_51[0x100];
+
+        u8         reserved_52[0x1f];
+        u8         cqe_zip[0x1];
+
+        u8         cqe_zip_timeout[0x10];
+        u8         cqe_zip_max_num[0x10];
+
+        u8         reserved_53[0x220];
+};
+
+struct mlx5_ifc_set_hca_cap_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_cmd_hca_cap_bits hca_capability_struct;
+};
+
+struct mlx5_ifc_query_hca_cap_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_query_hca_cap_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         capability_struct[256][0x8];
+};
+
+struct mlx5_ifc_set_hca_cap_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+#endif /* MLX5_IFC_H */
diff --git a/include/linux/mlx5/qp.h b/include/linux/mlx5/qp.h
index 9709b30e2d69..61f7a342d1bf 100644
--- a/include/linux/mlx5/qp.h
+++ b/include/linux/mlx5/qp.h
@@ -40,6 +40,18 @@
 #define MLX5_SIG_WQE_SIZE       (MLX5_SEND_WQE_BB * 5)
 #define MLX5_DIF_SIZE           8
 #define MLX5_STRIDE_BLOCK_OP    0x400
+#define MLX5_CPY_GRD_MASK       0xc0
+#define MLX5_CPY_APP_MASK       0x30
+#define MLX5_CPY_REF_MASK       0x0f
+#define MLX5_BSF_INC_REFTAG     (1 << 6)
+#define MLX5_BSF_INL_VALID      (1 << 15)
+#define MLX5_BSF_REFRESH_DIF    (1 << 14)
+#define MLX5_BSF_REPEAT_BLOCK   (1 << 7)
+#define MLX5_BSF_APPTAG_ESCAPE  0x1
+#define MLX5_BSF_APPREF_ESCAPE  0x2
+
+#define MLX5_QPN_BITS           24
+#define MLX5_QPN_MASK           ((1 << MLX5_QPN_BITS) - 1)
 
 enum mlx5_qp_optpar {
         MLX5_QP_OPTPAR_ALT_ADDR_PATH            = 1 << 0,
@@ -180,6 +192,14 @@ struct mlx5_wqe_ctrl_seg {
         __be32                  imm;
 };
 
+#define MLX5_WQE_CTRL_DS_MASK 0x3f
+#define MLX5_WQE_CTRL_QPN_MASK 0xffffff00
+#define MLX5_WQE_CTRL_QPN_SHIFT 8
+#define MLX5_WQE_DS_UNITS 16
+#define MLX5_WQE_CTRL_OPCODE_MASK 0xff
+#define MLX5_WQE_CTRL_WQE_INDEX_MASK 0x00ffff00
+#define MLX5_WQE_CTRL_WQE_INDEX_SHIFT 8
+
 struct mlx5_wqe_xrc_seg {
         __be32                  xrc_srqn;
         u8                      rsvd[12];
@@ -283,10 +303,28 @@ struct mlx5_wqe_signature_seg {
         u8      rsvd1[11];
 };
 
+#define MLX5_WQE_INLINE_SEG_BYTE_COUNT_MASK 0x3ff
+
 struct mlx5_wqe_inline_seg {
         __be32  byte_count;
 };
 
+enum mlx5_sig_type {
+        MLX5_DIF_CRC = 0x1,
+        MLX5_DIF_IPCS = 0x2,
+};
+
+struct mlx5_bsf_inl {
+        __be16          vld_refresh;
+        __be16          dif_apptag;
+        __be32          dif_reftag;
+        u8              sig_type;
+        u8              rp_inv_seed;
+        u8              rsvd[3];
+        u8              dif_inc_ref_guard_check;
+        __be16          dif_app_bitmask_check;
+};
+
 struct mlx5_bsf {
         struct mlx5_bsf_basic {
                 u8              bsf_size_sbs;
@@ -310,14 +348,8 @@ struct mlx5_bsf {
                 __be32          w_tfs_psv;
                 __be32          m_tfs_psv;
         } ext;
-        struct mlx5_bsf_inl {
-                __be32          w_inl_vld;
-                __be32          w_rsvd;
-                __be64          w_block_format;
-                __be32          m_inl_vld;
-                __be32          m_rsvd;
-                __be64          m_block_format;
-        } inl;
+        struct mlx5_bsf_inl     w_inl;
+        struct mlx5_bsf_inl     m_inl;
 };
 
 struct mlx5_klm {
@@ -341,11 +373,47 @@ struct mlx5_stride_block_ctrl_seg {
         __be16          num_entries;
 };
 
+enum mlx5_pagefault_flags {
+        MLX5_PFAULT_REQUESTOR = 1 << 0,
+        MLX5_PFAULT_WRITE     = 1 << 1,
+        MLX5_PFAULT_RDMA      = 1 << 2,
+};
+
+/* Contains the details of a pagefault. */
+struct mlx5_pagefault {
+        u32                     bytes_committed;
+        u8                      event_subtype;
+        enum mlx5_pagefault_flags flags;
+        union {
+                /* Initiator or send message responder pagefault details. */
+                struct {
+                        /* Received packet size, only valid for responders. */
+                        u32     packet_size;
+                        /*
+                         * WQE index. Refers to either the send queue or
+                         * receive queue, according to event_subtype.
+                         */
+                        u16     wqe_index;
+                } wqe;
+                /* RDMA responder pagefault details */
+                struct {
+                        u32     r_key;
+                        /*
+                         * Received packet size, minimal size page fault
+                         * resolution required for forward progress.
+                         */
+                        u32     packet_size;
+                        u32     rdma_op_len;
+                        u64     rdma_va;
+                } rdma;
+        };
+};
+
 struct mlx5_core_qp {
+        struct mlx5_core_rsc_common     common; /* must be first */
         void (*event)           (struct mlx5_core_qp *, int);
+        void (*pfault_handler)(struct mlx5_core_qp *, struct mlx5_pagefault *);
         int                     qpn;
-        atomic_t                refcount;
-        struct completion       free;
         struct mlx5_rsc_debug   *dbg;
         int                     pid;
 };
@@ -512,6 +580,17 @@ static inline struct mlx5_core_mr *__mlx5_mr_lookup(struct mlx5_core_dev *dev, u
         return radix_tree_lookup(&dev->priv.mr_table.tree, key);
 }
 
+struct mlx5_page_fault_resume_mbox_in {
+        struct mlx5_inbox_hdr   hdr;
+        __be32                  flags_qpn;
+        u8                      reserved[4];
+};
+
+struct mlx5_page_fault_resume_mbox_out {
+        struct mlx5_outbox_hdr  hdr;
+        u8                      rsvd[8];
+};
+
 int mlx5_core_create_qp(struct mlx5_core_dev *dev,
                         struct mlx5_core_qp *qp,
                         struct mlx5_create_qp_mbox_in *in,
@@ -531,6 +610,10 @@ void mlx5_init_qp_table(struct mlx5_core_dev *dev);
 void mlx5_cleanup_qp_table(struct mlx5_core_dev *dev);
 int mlx5_debug_qp_add(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp);
 void mlx5_debug_qp_remove(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp);
+#ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
+int mlx5_core_page_fault_resume(struct mlx5_core_dev *dev, u32 qpn,
+                                u8 context, int error);
+#endif
 
 static inline const char *mlx5_qp_type_str(int type)
 {
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 8981cc882ed2..80fc92a49649 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -18,6 +18,8 @@
 #include <linux/pfn.h>
 #include <linux/bit_spinlock.h>
 #include <linux/shrinker.h>
+#include <linux/resource.h>
+#include <linux/page_ext.h>
 
 struct mempolicy;
 struct anon_vma;
@@ -55,6 +57,17 @@ extern int sysctl_legacy_va_layout;
 #define __pa_symbol(x)  __pa(RELOC_HIDE((unsigned long)(x), 0))
 #endif
 
+/*
+ * To prevent common memory management code establishing
+ * a zero page mapping on a read fault.
+ * This macro should be defined within <asm/pgtable.h>.
+ * s390 does this to prevent multiplexing of hardware bits
+ * related to the physical page in case of virtualization.
+ */
+#ifndef mm_forbids_zeropage
+#define mm_forbids_zeropage(X)  (0)
+#endif
+
 extern unsigned long sysctl_user_reserve_kbytes;
 extern unsigned long sysctl_admin_reserve_kbytes;
 
@@ -127,6 +140,7 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_HUGETLB      0x00400000      /* Huge TLB Page VM */
 #define VM_NONLINEAR    0x00800000      /* Is non-linear (remap_file_pages) */
 #define VM_ARCH_1       0x01000000      /* Architecture-specific flag */
+#define VM_ARCH_2       0x02000000
 #define VM_DONTDUMP     0x04000000      /* Do not include in the core dump */
 
 #ifdef CONFIG_MEM_SOFT_DIRTY
@@ -154,6 +168,11 @@ extern unsigned int kobjsize(const void *objp);
 # define VM_MAPPED_COPY VM_ARCH_1       /* T if mapped copy of data (nommu mmap) */
 #endif
 
+#if defined(CONFIG_X86)
+/* MPX specific bounds table or bounds directory */
+# define VM_MPX         VM_ARCH_2
+#endif
+
 #ifndef VM_GROWSUP
 # define VM_GROWSUP     VM_NONE
 #endif
@@ -267,8 +286,6 @@ struct vm_operations_struct {
          */
         struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
                                         unsigned long addr);
-        int (*migrate)(struct vm_area_struct *vma, const nodemask_t *from,
-                const nodemask_t *to, unsigned long flags);
 #endif
         /* called by sys_remap_file_pages() to populate non-linear mapping */
         int (*remap_pages)(struct vm_area_struct *vma, unsigned long addr,
@@ -346,6 +363,7 @@ static inline int put_page_unless_one(struct page *page)
 }
 
 extern int page_is_ram(unsigned long pfn);
+extern int region_is_ram(resource_size_t phys_addr, unsigned long size);
 
 /* Support for virtually mapped pages */
 struct page *vmalloc_to_page(const void *addr);
@@ -553,6 +571,25 @@ static inline void __ClearPageBuddy(struct page *page)
         atomic_set(&page->_mapcount, -1);
 }
 
+#define PAGE_BALLOON_MAPCOUNT_VALUE (-256)
+
+static inline int PageBalloon(struct page *page)
+{
+        return atomic_read(&page->_mapcount) == PAGE_BALLOON_MAPCOUNT_VALUE;
+}
+
+static inline void __SetPageBalloon(struct page *page)
+{
+        VM_BUG_ON_PAGE(atomic_read(&page->_mapcount) != -1, page);
+        atomic_set(&page->_mapcount, PAGE_BALLOON_MAPCOUNT_VALUE);
+}
+
+static inline void __ClearPageBalloon(struct page *page)
+{
+        VM_BUG_ON_PAGE(!PageBalloon(page), page);
+        atomic_set(&page->_mapcount, -1);
+}
+
 void put_page(struct page *page);
 void put_pages_list(struct list_head *pages);
 
@@ -1155,6 +1192,7 @@ static inline void unmap_shared_mapping_range(struct address_space *mapping,
 
 extern void truncate_pagecache(struct inode *inode, loff_t new);
 extern void truncate_setsize(struct inode *inode, loff_t newsize);
+void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to);
 void truncate_pagecache_range(struct inode *inode, loff_t offset, loff_t end);
 int truncate_inode_page(struct address_space *mapping, struct page *page);
 int generic_error_remove_page(struct address_space *mapping, struct page *page);
@@ -1213,7 +1251,6 @@ int __set_page_dirty_no_writeback(struct page *page);
 int redirty_page_for_writepage(struct writeback_control *wbc,
                                 struct page *page);
 void account_page_dirtied(struct page *page, struct address_space *mapping);
-void account_page_writeback(struct page *page);
 int set_page_dirty(struct page *page);
 int set_page_dirty_lock(struct page *page);
 int clear_page_dirty_for_io(struct page *page);
@@ -1247,8 +1284,8 @@ static inline int stack_guard_page_end(struct vm_area_struct *vma,
                 !vma_growsup(vma->vm_next, addr);
 }
 
-extern pid_t
-vm_is_stack(struct task_struct *task, struct vm_area_struct *vma, int in_group);
+extern struct task_struct *task_of_stack(struct task_struct *task,
+                                struct vm_area_struct *vma, bool in_group);
 
 extern unsigned long move_page_tables(struct vm_area_struct *vma,
                 unsigned long old_addr, struct vm_area_struct *new_vma,
@@ -1780,6 +1817,20 @@ extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
         bool *need_rmap_locks);
 extern void exit_mmap(struct mm_struct *);
 
+static inline int check_data_rlimit(unsigned long rlim,
+                                    unsigned long new,
+                                    unsigned long start,
+                                    unsigned long end_data,
+                                    unsigned long start_data)
+{
+        if (rlim < RLIM_INFINITY) {
+                if (((new - start) + (end_data - start_data)) > rlim)
+                        return -ENOSPC;
+        }
+
+        return 0;
+}
+
 extern int mm_take_all_locks(struct mm_struct *mm);
 extern void mm_drop_all_locks(struct mm_struct *mm);
 
@@ -1901,7 +1952,7 @@ extern int expand_downwards(struct vm_area_struct *vma,
 #if VM_GROWSUP
 extern int expand_upwards(struct vm_area_struct *vma, unsigned long address);
 #else
-  #define expand_upwards(vma, address) do { } while (0)
+  #define expand_upwards(vma, address) (0)
 #endif
 
 /* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
@@ -1939,11 +1990,16 @@ static inline struct vm_area_struct *find_exact_vma(struct mm_struct *mm,
 
 #ifdef CONFIG_MMU
 pgprot_t vm_get_page_prot(unsigned long vm_flags);
+void vma_set_page_prot(struct vm_area_struct *vma);
 #else
 static inline pgprot_t vm_get_page_prot(unsigned long vm_flags)
 {
         return __pgprot(0);
 }
+static inline void vma_set_page_prot(struct vm_area_struct *vma)
+{
+        vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
+}
 #endif
 
 #ifdef CONFIG_NUMA_BALANCING
@@ -1985,6 +2041,7 @@ static inline struct page *follow_page(struct vm_area_struct *vma,
 #define FOLL_HWPOISON   0x100   /* check page is hwpoisoned */
 #define FOLL_NUMA       0x200   /* force NUMA hinting page fault */
 #define FOLL_MIGRATION  0x400   /* wait for page to replace migration entry */
+#define FOLL_TRIED      0x800   /* a retry, previous pass started an IO */
 
 typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr,
                         void *data);
@@ -2002,7 +2059,22 @@ static inline void vm_stat_account(struct mm_struct *mm,
 #endif /* CONFIG_PROC_FS */
 
 #ifdef CONFIG_DEBUG_PAGEALLOC
-extern void kernel_map_pages(struct page *page, int numpages, int enable);
+extern bool _debug_pagealloc_enabled;
+extern void __kernel_map_pages(struct page *page, int numpages, int enable);
+
+static inline bool debug_pagealloc_enabled(void)
+{
+        return _debug_pagealloc_enabled;
+}
+
+static inline void
+kernel_map_pages(struct page *page, int numpages, int enable)
+{
+        if (!debug_pagealloc_enabled())
+                return;
+
+        __kernel_map_pages(page, numpages, enable);
+}
 #ifdef CONFIG_HIBERNATION
 extern bool kernel_page_present(struct page *page);
 #endif /* CONFIG_HIBERNATION */
@@ -2036,9 +2108,9 @@ int drop_caches_sysctl_handler(struct ctl_table *, int,
                                         void __user *, size_t *, loff_t *);
 #endif
 
-unsigned long shrink_slab(struct shrink_control *shrink,
-                          unsigned long nr_pages_scanned,
-                          unsigned long lru_pages);
+unsigned long shrink_node_slabs(gfp_t gfp_mask, int nid,
+                                unsigned long nr_scanned,
+                                unsigned long nr_eligible);
 
 #ifndef CONFIG_MMU
 #define randomize_va_space 0
@@ -2097,20 +2169,36 @@ extern void copy_user_huge_page(struct page *dst, struct page *src,
                                 unsigned int pages_per_huge_page);
 #endif /* CONFIG_TRANSPARENT_HUGEPAGE || CONFIG_HUGETLBFS */
 
+extern struct page_ext_operations debug_guardpage_ops;
+extern struct page_ext_operations page_poisoning_ops;
+
 #ifdef CONFIG_DEBUG_PAGEALLOC
 extern unsigned int _debug_guardpage_minorder;
+extern bool _debug_guardpage_enabled;
 
 static inline unsigned int debug_guardpage_minorder(void)
 {
         return _debug_guardpage_minorder;
 }
 
+static inline bool debug_guardpage_enabled(void)
+{
+        return _debug_guardpage_enabled;
+}
+
 static inline bool page_is_guard(struct page *page)
 {
-        return test_bit(PAGE_DEBUG_FLAG_GUARD, &page->debug_flags);
+        struct page_ext *page_ext;
+
+        if (!debug_guardpage_enabled())
+                return false;
+
+        page_ext = lookup_page_ext(page);
+        return test_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
 }
 #else
 static inline unsigned int debug_guardpage_minorder(void) { return 0; }
+static inline bool debug_guardpage_enabled(void) { return false; }
 static inline bool page_is_guard(struct page *page) { return false; }
 #endif /* CONFIG_DEBUG_PAGEALLOC */
 
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 6e0b286649f1..6d34aa266a8c 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -10,7 +10,6 @@
 #include <linux/rwsem.h>
 #include <linux/completion.h>
 #include <linux/cpumask.h>
-#include <linux/page-debug-flags.h>
 #include <linux/uprobes.h>
 #include <linux/page-flags-layout.h>
 #include <asm/page.h>
@@ -22,6 +21,7 @@
 #define AT_VECTOR_SIZE (2*(AT_VECTOR_SIZE_ARCH + AT_VECTOR_SIZE_BASE + 1))
 
 struct address_space;
+struct mem_cgroup;
 
 #define USE_SPLIT_PTE_PTLOCKS   (NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS)
 #define USE_SPLIT_PMD_PTLOCKS   (USE_SPLIT_PTE_PTLOCKS && \
@@ -167,6 +167,10 @@ struct page {
                 struct page *first_page;        /* Compound tail pages */
         };
 
+#ifdef CONFIG_MEMCG
+        struct mem_cgroup *mem_cgroup;
+#endif
+
         /*
          * On machines where all RAM is mapped into kernel address space,
          * we can simply calculate the virtual address. On machines with
@@ -181,9 +185,6 @@ struct page {
         void *virtual;                  /* Kernel virtual address (NULL if
                                            not kmapped, ie. highmem) */
 #endif /* WANT_PAGE_VIRTUAL */
-#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
-        unsigned long debug_flags;      /* Use atomic bitops on this */
-#endif
 
 #ifdef CONFIG_KMEMCHECK
         /*
@@ -454,6 +455,10 @@ struct mm_struct {
         bool tlb_flush_pending;
 #endif
         struct uprobes_state uprobes_state;
+#ifdef CONFIG_X86_INTEL_MPX
+        /* address of the bounds directory */
+        void __user *bd_addr;
+#endif
 };
 
 static inline void mm_init_cpumask(struct mm_struct *mm)
@@ -525,4 +530,12 @@ enum tlb_flush_reason {
         NR_TLB_FLUSH_REASONS,
 };
 
+ /*
+  * A swap entry has to fit into a "unsigned long", as the entry is hidden
+  * in the "index" field of the swapper address space.
+  */
+typedef struct {
+        unsigned long val;
+} swp_entry_t;
+
 #endif /* _LINUX_MM_TYPES_H */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index d424b9de3aff..4d69c00497bd 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -42,7 +42,8 @@ struct mmc_csd {
         unsigned int            read_partial:1,
                                 read_misalign:1,
                                 write_partial:1,
-                                write_misalign:1;
+                                write_misalign:1,
+                                dsr_imp:1;
 };
 
 struct mmc_ext_csd {
@@ -74,7 +75,7 @@ struct mmc_ext_csd {
         unsigned int            sec_trim_mult;  /* Secure trim multiplier  */
         unsigned int            sec_erase_mult; /* Secure erase multiplier */
         unsigned int            trim_timeout;           /* In milliseconds */
-        bool                    enhanced_area_en;       /* enable bit */
+        bool                    partition_setting_completed;    /* enable bit */
         unsigned long long      enhanced_area_offset;   /* Units: Byte */
         unsigned int            enhanced_area_size;     /* Units: KB */
         unsigned int            cache_size;             /* Units: KB */
@@ -87,6 +88,9 @@ struct mmc_ext_csd {
         unsigned int            data_tag_unit_size;     /* DATA TAG UNIT size */
         unsigned int            boot_ro_lock;           /* ro lock support */
         bool                    boot_ro_lockable;
+        bool                    ffu_capable;    /* Firmware upgrade support */
+#define MMC_FIRMWARE_LEN 8
+        u8                      fwrev[MMC_FIRMWARE_LEN];  /* FW version */
         u8                      raw_exception_status;   /* 54 */
         u8                      raw_partition_support;  /* 160 */
         u8                      raw_rpmb_size_mult;     /* 168 */
@@ -214,11 +218,12 @@ enum mmc_blk_status {
 };
 
 /* The number of MMC physical partitions.  These consist of:
- * boot partitions (2), general purpose partitions (4) in MMC v4.4.
+ * boot partitions (2), general purpose partitions (4) and
+ * RPMB partition (1) in MMC v4.4.
  */
 #define MMC_NUM_BOOT_PARTITION  2
 #define MMC_NUM_GP_PARTITION    4
-#define MMC_NUM_PHY_PARTITION   6
+#define MMC_NUM_PHY_PARTITION   7
 #define MAX_MMC_PART_NAME_LEN   20
 
 /*
@@ -507,24 +512,8 @@ static inline int mmc_card_broken_irq_polling(const struct mmc_card *c)
 
 #define mmc_dev_to_card(d)      container_of(d, struct mmc_card, dev)
 
-#define mmc_list_to_card(l)     container_of(l, struct mmc_card, node)
-#define mmc_get_drvdata(c)      dev_get_drvdata(&(c)->dev)
-#define mmc_set_drvdata(c,d)    dev_set_drvdata(&(c)->dev, d)
-
-/*
- * MMC device driver (e.g., Flash card, I/O card...)
- */
-struct mmc_driver {
-        struct device_driver drv;
-        int (*probe)(struct mmc_card *);
-        void (*remove)(struct mmc_card *);
-        int (*suspend)(struct mmc_card *);
-        int (*resume)(struct mmc_card *);
-        void (*shutdown)(struct mmc_card *);
-};
-
-extern int mmc_register_driver(struct mmc_driver *);
-extern void mmc_unregister_driver(struct mmc_driver *);
+extern int mmc_register_driver(struct device_driver *);
+extern void mmc_unregister_driver(struct device_driver *);
 
 extern void mmc_fixup_device(struct mmc_card *card,
                              const struct mmc_fixup *table);
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index f206e29f94d7..cb2b0400d284 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -154,7 +154,8 @@ extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
 extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool,
                         bool, bool);
 extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
-extern int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd);
+extern int mmc_send_tuning(struct mmc_host *host);
+extern int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd);
 
 #define MMC_ERASE_ARG           0x00000000
 #define MMC_SECURE_ERASE_ARG    0x80000000
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index 29ce014ab421..42b724e8d503 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -26,6 +26,8 @@ enum dw_mci_state {
         STATE_DATA_BUSY,
         STATE_SENDING_STOP,
         STATE_DATA_ERROR,
+        STATE_SENDING_CMD11,
+        STATE_WAITING_CMD11_DONE,
 };
 
 enum {
@@ -52,6 +54,7 @@ struct mmc_data;
  *      transfer is in progress.
  * @use_dma: Whether DMA channel is initialized or not.
  * @using_dma: Whether DMA is in use for the current transfer.
+ * @dma_64bit_address: Whether DMA supports 64-bit address mode or not.
  * @sg_dma: Bus address of DMA buffer.
  * @sg_cpu: Virtual address of DMA buffer.
  * @dma_ops: Pointer to platform-specific DMA callbacks.
@@ -94,6 +97,7 @@ struct mmc_data;
  * @quirks: Set of quirks that apply to specific versions of the IP.
  * @irq_flags: The flags to be passed to request_irq.
  * @irq: The irq value to be passed to request_irq.
+ * @sdio_id0: Number of slot0 in the SDIO interrupt registers.
  *
  * Locking
  * =======
@@ -133,11 +137,11 @@ struct dw_mci {
         struct mmc_command      stop_abort;
         unsigned int            prev_blksz;
         unsigned char           timing;
-        struct workqueue_struct *card_workqueue;
 
         /* DMA interface members*/
         int                     use_dma;
         int                     using_dma;
+        int                     dma_64bit_address;
 
         dma_addr_t              sg_dma;
         void                    *sg_cpu;
@@ -152,7 +156,6 @@ struct dw_mci {
         u32                     stop_cmdr;
         u32                     dir_status;
         struct tasklet_struct   tasklet;
-        struct work_struct      card_work;
         unsigned long           pending_events;
         unsigned long           completed_events;
         enum dw_mci_state       state;
@@ -188,9 +191,11 @@ struct dw_mci {
         /* Workaround flags */
         u32                     quirks;
 
-        struct regulator        *vmmc;  /* Power regulator */
+        bool                    vqmmc_enabled;
         unsigned long           irq_flags; /* IRQ flags */
         int                     irq;
+
+        int                     sdio_id0;
 };
 
 /* DMA ops for Internal/External DMAC interface */
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 7960424d0bc0..9f322706f7cb 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -42,6 +42,7 @@ struct mmc_ios {
 #define MMC_POWER_OFF           0
 #define MMC_POWER_UP            1
 #define MMC_POWER_ON            2
+#define MMC_POWER_UNDEFINED     3
 
         unsigned char   bus_width;              /* data bus width */
 
@@ -139,6 +140,13 @@ struct mmc_host_ops {
         int     (*select_drive_strength)(unsigned int max_dtr, int host_drv, int card_drv);
         void    (*hw_reset)(struct mmc_host *host);
         void    (*card_event)(struct mmc_host *host);
+
+        /*
+         * Optional callback to support controllers with HW issues for multiple
+         * I/O. Returns the number of supported blocks for the request.
+         */
+        int     (*multi_io_quirk)(struct mmc_card *card,
+                                  unsigned int direction, int blk_size);
 };
 
 struct mmc_card;
@@ -265,7 +273,6 @@ struct mmc_host {
 
 #define MMC_CAP2_BOOTPART_NOACC (1 << 0)        /* Boot partition no access */
 #define MMC_CAP2_FULL_PWR_CYCLE (1 << 2)        /* Can do full power cycle */
-#define MMC_CAP2_NO_MULTI_READ  (1 << 3)        /* Multiblock reads don't work */
 #define MMC_CAP2_HS200_1_8V_SDR (1 << 5)        /* can support */
 #define MMC_CAP2_HS200_1_2V_SDR (1 << 6)        /* can support */
 #define MMC_CAP2_HS200          (MMC_CAP2_HS200_1_8V_SDR | \
@@ -282,6 +289,7 @@ struct mmc_host {
 #define MMC_CAP2_HS400_1_2V     (1 << 16)       /* Can support HS400 1.2V */
 #define MMC_CAP2_HS400          (MMC_CAP2_HS400_1_8V | \
                                  MMC_CAP2_HS400_1_2V)
+#define MMC_CAP2_HSX00_1_2V     (MMC_CAP2_HS200_1_2V_SDR | MMC_CAP2_HS400_1_2V)
 #define MMC_CAP2_SDIO_IRQ_NOTHREAD (1 << 17)
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
@@ -365,6 +373,9 @@ struct mmc_host {
 
         unsigned int            slotno; /* used for sdio acpi binding */
 
+        int                     dsr_req;        /* DSR value is valid */
+        u32                     dsr;    /* optional driver stage (DSR) value */
+
         unsigned long           private[0] ____cacheline_aligned;
 };
 
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 64ec963ed347..49ad7a943638 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -53,6 +53,11 @@
 #define MMC_SEND_TUNING_BLOCK    19   /* adtc                    R1  */
 #define MMC_SEND_TUNING_BLOCK_HS200     21      /* adtc R1  */
 
+#define MMC_TUNING_BLK_PATTERN_4BIT_SIZE         64
+#define MMC_TUNING_BLK_PATTERN_8BIT_SIZE        128
+extern const u8 tuning_blk_pattern_4bit[MMC_TUNING_BLK_PATTERN_4BIT_SIZE];
+extern const u8 tuning_blk_pattern_8bit[MMC_TUNING_BLK_PATTERN_8BIT_SIZE];
+
   /* class 3 */
 #define MMC_WRITE_DAT_UNTIL_STOP 20   /* adtc [31:0] data addr   R1  */
 
@@ -281,6 +286,7 @@ struct _mmc_csd {
 #define EXT_CSD_EXP_EVENTS_CTRL         56      /* R/W, 2 bytes */
 #define EXT_CSD_DATA_SECTOR_SIZE        61      /* R */
 #define EXT_CSD_GP_SIZE_MULT            143     /* R/W */
+#define EXT_CSD_PARTITION_SETTING_COMPLETED 155 /* R/W */
 #define EXT_CSD_PARTITION_ATTRIBUTE     156     /* R/W */
 #define EXT_CSD_PARTITION_SUPPORT       160     /* RO */
 #define EXT_CSD_HPI_MGMT                161     /* R/W */
@@ -290,6 +296,7 @@ struct _mmc_csd {
 #define EXT_CSD_SANITIZE_START          165     /* W */
 #define EXT_CSD_WR_REL_PARAM            166     /* RO */
 #define EXT_CSD_RPMB_MULT               168     /* RO */
+#define EXT_CSD_FW_CONFIG               169     /* R/W */
 #define EXT_CSD_BOOT_WP                 173     /* R/W */
 #define EXT_CSD_ERASE_GROUP_DEF         175     /* R/W */
 #define EXT_CSD_PART_CONFIG             179     /* R/W */
@@ -326,6 +333,8 @@ struct _mmc_csd {
 #define EXT_CSD_GENERIC_CMD6_TIME       248     /* RO */
 #define EXT_CSD_CACHE_SIZE              249     /* RO, 4 bytes */
 #define EXT_CSD_PWR_CL_DDR_200_360      253     /* RO */
+#define EXT_CSD_FIRMWARE_VERSION        254     /* RO, 8 bytes */
+#define EXT_CSD_SUPPORTED_MODE          493     /* RO */
 #define EXT_CSD_TAG_UNIT_SIZE           498     /* RO */
 #define EXT_CSD_DATA_TAG_SUPPORT        499     /* RO */
 #define EXT_CSD_MAX_PACKED_WRITES       500     /* RO */
@@ -349,6 +358,7 @@ struct _mmc_csd {
 #define EXT_CSD_PART_CONFIG_ACC_RPMB    (0x3)
 #define EXT_CSD_PART_CONFIG_ACC_GP0     (0x4)
 
+#define EXT_CSD_PART_SETTING_COMPLETED  (0x1)
 #define EXT_CSD_PART_SUPPORT_PART_EN    (0x1)
 
 #define EXT_CSD_CMD_SET_NORMAL          (1<<0)
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index 09ebe57d5ce9..375af80bde7d 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -98,6 +98,14 @@ struct sdhci_host {
 #define SDHCI_QUIRK2_BROKEN_HS200                       (1<<6)
 /* Controller does not support DDR50 */
 #define SDHCI_QUIRK2_BROKEN_DDR50                       (1<<7)
+/* Stop command (CMD12) can set Transfer Complete when not using MMC_RSP_BUSY */
+#define SDHCI_QUIRK2_STOP_WITH_TC                       (1<<8)
+/* Controller does not support 64-bit DMA */
+#define SDHCI_QUIRK2_BROKEN_64_BIT_DMA                  (1<<9)
+/* need clear transfer mode register before send cmd */
+#define SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD  (1<<10)
+/* Capability register bit-63 indicates HS400 support */
+#define SDHCI_QUIRK2_CAPS_BIT63_FOR_HS400               (1<<11)
 
         int irq;                /* Device IRQ */
         void __iomem *ioaddr;   /* Mapped address */
@@ -128,6 +136,7 @@ struct sdhci_host {
 #define SDHCI_SDIO_IRQ_ENABLED  (1<<9)  /* SDIO irq enabled */
 #define SDHCI_SDR104_NEEDS_TUNING (1<<10)       /* SDR104/HS200 needs tuning */
 #define SDHCI_USING_RETUNING_TIMER (1<<11)      /* Host is using a retuning timer for the card */
+#define SDHCI_USE_64_BIT_DMA    (1<<12) /* Use 64-bit DMA */
 
         unsigned int version;   /* SDHCI spec. version */
 
@@ -146,18 +155,26 @@ struct sdhci_host {
         struct mmc_command *cmd;        /* Current command */
         struct mmc_data *data;  /* Current data request */
         unsigned int data_early:1;      /* Data finished before cmd */
+        unsigned int busy_handle:1;     /* Handling the order of Busy-end */
 
         struct sg_mapping_iter sg_miter;        /* SG state for PIO */
         unsigned int blocks;    /* remaining PIO blocks */
 
         int sg_count;           /* Mapped sg entries */
 
-        u8 *adma_desc;          /* ADMA descriptor table */
-        u8 *align_buffer;       /* Bounce buffer */
+        void *adma_table;       /* ADMA descriptor table */
+        void *align_buffer;     /* Bounce buffer */
+
+        size_t adma_table_sz;   /* ADMA descriptor table size */
+        size_t align_buffer_sz; /* Bounce buffer size */
 
         dma_addr_t adma_addr;   /* Mapped ADMA descr. table */
         dma_addr_t align_addr;  /* Mapped bounce buffer */
 
+        unsigned int desc_sz;   /* ADMA descriptor size */
+        unsigned int align_sz;  /* ADMA alignment */
+        unsigned int align_mask;        /* ADMA alignment mask */
+
         struct tasklet_struct finish_tasklet;   /* Tasklet structures */
 
         struct timer_list timer;        /* Timer for timeouts */
diff --git a/include/linux/mmc/sdio_func.h b/include/linux/mmc/sdio_func.h
index 50f0bc952328..aab032a6ae61 100644
--- a/include/linux/mmc/sdio_func.h
+++ b/include/linux/mmc/sdio_func.h
@@ -84,8 +84,6 @@ struct sdio_driver {
         struct device_driver drv;
 };
 
-#define to_sdio_driver(d)       container_of(d, struct sdio_driver, drv)
-
 /**
  * SDIO_DEVICE - macro used to describe a specific SDIO device
  * @vend: the 16 bit manufacturer code
diff --git a/include/linux/mmc/slot-gpio.h b/include/linux/mmc/slot-gpio.h
index d2433381e828..e56fa24c9322 100644
--- a/include/linux/mmc/slot-gpio.h
+++ b/include/linux/mmc/slot-gpio.h
@@ -24,7 +24,10 @@ void mmc_gpio_free_cd(struct mmc_host *host);
 
 int mmc_gpiod_request_cd(struct mmc_host *host, const char *con_id,
                          unsigned int idx, bool override_active_level,
-                         unsigned int debounce);
+                         unsigned int debounce, bool *gpio_invert);
+int mmc_gpiod_request_ro(struct mmc_host *host, const char *con_id,
+                         unsigned int idx, bool override_active_level,
+                         unsigned int debounce, bool *gpio_invert);
 void mmc_gpiod_free_cd(struct mmc_host *host);
 void mmc_gpiod_request_cd_irq(struct mmc_host *host);
 
diff --git a/include/linux/mmdebug.h b/include/linux/mmdebug.h
index 2f348d02f640..877ef226f90f 100644
--- a/include/linux/mmdebug.h
+++ b/include/linux/mmdebug.h
@@ -4,10 +4,14 @@
 #include <linux/stringify.h>
 
 struct page;
+struct vm_area_struct;
+struct mm_struct;
 
 extern void dump_page(struct page *page, const char *reason);
 extern void dump_page_badflags(struct page *page, const char *reason,
                                unsigned long badflags);
+void dump_vma(const struct vm_area_struct *vma);
+void dump_mm(const struct mm_struct *mm);
 
 #ifdef CONFIG_DEBUG_VM
 #define VM_BUG_ON(cond) BUG_ON(cond)
@@ -18,12 +22,28 @@ extern void dump_page_badflags(struct page *page, const char *reason,
                         BUG();                                          \
                 }                                                       \
         } while (0)
+#define VM_BUG_ON_VMA(cond, vma)                                        \
+        do {                                                            \
+                if (unlikely(cond)) {                                   \
+                        dump_vma(vma);                                  \
+                        BUG();                                          \
+                }                                                       \
+        } while (0)
+#define VM_BUG_ON_MM(cond, mm)                                          \
+        do {                                                            \
+                if (unlikely(cond)) {                                   \
+                        dump_mm(mm);                                    \
+                        BUG();                                          \
+                }                                                       \
+        } while (0)
 #define VM_WARN_ON(cond) WARN_ON(cond)
 #define VM_WARN_ON_ONCE(cond) WARN_ON_ONCE(cond)
 #define VM_WARN_ONCE(cond, format...) WARN_ONCE(cond, format)
 #else
 #define VM_BUG_ON(cond) BUILD_BUG_ON_INVALID(cond)
 #define VM_BUG_ON_PAGE(cond, page) VM_BUG_ON(cond)
+#define VM_BUG_ON_VMA(cond, vma) VM_BUG_ON(cond)
+#define VM_BUG_ON_MM(cond, mm) VM_BUG_ON(cond)
 #define VM_WARN_ON(cond) BUILD_BUG_ON_INVALID(cond)
 #define VM_WARN_ON_ONCE(cond) BUILD_BUG_ON_INVALID(cond)
 #define VM_WARN_ONCE(cond, format...) BUILD_BUG_ON_INVALID(cond)
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index 27288692241e..95243d28a0ee 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -57,10 +57,13 @@ struct mmu_notifier_ops {
          * pte. This way the VM will provide proper aging to the
          * accesses to the page through the secondary MMUs and not
          * only to the ones through the Linux pte.
+         * Start-end is necessary in case the secondary MMU is mapping the page
+         * at a smaller granularity than the primary MMU.
          */
         int (*clear_flush_young)(struct mmu_notifier *mn,
                                  struct mm_struct *mm,
-                                 unsigned long address);
+                                 unsigned long start,
+                                 unsigned long end);
 
         /*
          * test_young is called to check the young/accessed bitflag in
@@ -95,11 +98,11 @@ struct mmu_notifier_ops {
         /*
          * invalidate_range_start() and invalidate_range_end() must be
          * paired and are called only when the mmap_sem and/or the
-         * locks protecting the reverse maps are held. The subsystem
-         * must guarantee that no additional references are taken to
-         * the pages in the range established between the call to
-         * invalidate_range_start() and the matching call to
-         * invalidate_range_end().
+         * locks protecting the reverse maps are held. If the subsystem
+         * can't guarantee that no additional references are taken to
+         * the pages in the range, it has to implement the
+         * invalidate_range() notifier to remove any references taken
+         * after invalidate_range_start().
          *
          * Invalidation of multiple concurrent ranges may be
          * optionally permitted by the driver. Either way the
@@ -141,6 +144,29 @@ struct mmu_notifier_ops {
         void (*invalidate_range_end)(struct mmu_notifier *mn,
                                      struct mm_struct *mm,
                                      unsigned long start, unsigned long end);
+
+        /*
+         * invalidate_range() is either called between
+         * invalidate_range_start() and invalidate_range_end() when the
+         * VM has to free pages that where unmapped, but before the
+         * pages are actually freed, or outside of _start()/_end() when
+         * a (remote) TLB is necessary.
+         *
+         * If invalidate_range() is used to manage a non-CPU TLB with
+         * shared page-tables, it not necessary to implement the
+         * invalidate_range_start()/end() notifiers, as
+         * invalidate_range() alread catches the points in time when an
+         * external TLB range needs to be flushed.
+         *
+         * The invalidate_range() function is called under the ptl
+         * spin-lock and not allowed to sleep.
+         *
+         * Note that this function might be called with just a sub-range
+         * of what was passed to invalidate_range_start()/end(), if
+         * called between those functions.
+         */
+        void (*invalidate_range)(struct mmu_notifier *mn, struct mm_struct *mm,
+                                 unsigned long start, unsigned long end);
 };
 
 /*
@@ -151,7 +177,7 @@ struct mmu_notifier_ops {
  * Therefore notifier chains can only be traversed when either
  *
  * 1. mmap_sem is held.
- * 2. One of the reverse map locks is held (i_mmap_mutex or anon_vma->rwsem).
+ * 2. One of the reverse map locks is held (i_mmap_rwsem or anon_vma->rwsem).
  * 3. No other concurrent thread can access the list (release)
  */
 struct mmu_notifier {
@@ -175,7 +201,8 @@ extern void mmu_notifier_unregister_no_release(struct mmu_notifier *mn,
 extern void __mmu_notifier_mm_destroy(struct mm_struct *mm);
 extern void __mmu_notifier_release(struct mm_struct *mm);
 extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
-                                          unsigned long address);
+                                          unsigned long start,
+                                          unsigned long end);
 extern int __mmu_notifier_test_young(struct mm_struct *mm,
                                      unsigned long address);
 extern void __mmu_notifier_change_pte(struct mm_struct *mm,
@@ -186,6 +213,8 @@ extern void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
                                   unsigned long start, unsigned long end);
 extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                                   unsigned long start, unsigned long end);
+extern void __mmu_notifier_invalidate_range(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end);
 
 static inline void mmu_notifier_release(struct mm_struct *mm)
 {
@@ -194,10 +223,11 @@ static inline void mmu_notifier_release(struct mm_struct *mm)
 }
 
 static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
-                                          unsigned long address)
+                                          unsigned long start,
+                                          unsigned long end)
 {
         if (mm_has_notifiers(mm))
-                return __mmu_notifier_clear_flush_young(mm, address);
+                return __mmu_notifier_clear_flush_young(mm, start, end);
         return 0;
 }
 
@@ -237,6 +267,13 @@ static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                 __mmu_notifier_invalidate_range_end(mm, start, end);
 }
 
+static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+        if (mm_has_notifiers(mm))
+                __mmu_notifier_invalidate_range(mm, start, end);
+}
+
 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
 {
         mm->mmu_notifier_mm = NULL;
@@ -255,7 +292,9 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
         unsigned long ___address = __address;                           \
         __young = ptep_clear_flush_young(___vma, ___address, __ptep);   \
         __young |= mmu_notifier_clear_flush_young(___vma->vm_mm,        \
-                                                  ___address);          \
+                                                  ___address,           \
+                                                  ___address +          \
+                                                        PAGE_SIZE);     \
         __young;                                                        \
 })
 
@@ -266,10 +305,50 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
         unsigned long ___address = __address;                           \
         __young = pmdp_clear_flush_young(___vma, ___address, __pmdp);   \
         __young |= mmu_notifier_clear_flush_young(___vma->vm_mm,        \
-                                                  ___address);          \
+                                                  ___address,           \
+                                                  ___address +          \
+                                                        PMD_SIZE);      \
         __young;                                                        \
 })
 
+#define ptep_clear_flush_notify(__vma, __address, __ptep)               \
+({                                                                      \
+        unsigned long ___addr = __address & PAGE_MASK;                  \
+        struct mm_struct *___mm = (__vma)->vm_mm;                       \
+        pte_t ___pte;                                                   \
+                                                                        \
+        ___pte = ptep_clear_flush(__vma, __address, __ptep);            \
+        mmu_notifier_invalidate_range(___mm, ___addr,                   \
+                                        ___addr + PAGE_SIZE);           \
+                                                                        \
+        ___pte;                                                         \
+})
+
+#define pmdp_clear_flush_notify(__vma, __haddr, __pmd)                  \
+({                                                                      \
+        unsigned long ___haddr = __haddr & HPAGE_PMD_MASK;              \
+        struct mm_struct *___mm = (__vma)->vm_mm;                       \
+        pmd_t ___pmd;                                                   \
+                                                                        \
+        ___pmd = pmdp_clear_flush(__vma, __haddr, __pmd);               \
+        mmu_notifier_invalidate_range(___mm, ___haddr,                  \
+                                      ___haddr + HPAGE_PMD_SIZE);       \
+                                                                        \
+        ___pmd;                                                         \
+})
+
+#define pmdp_get_and_clear_notify(__mm, __haddr, __pmd)                 \
+({                                                                      \
+        unsigned long ___haddr = __haddr & HPAGE_PMD_MASK;              \
+        pmd_t ___pmd;                                                   \
+                                                                        \
+        ___pmd = pmdp_get_and_clear(__mm, __haddr, __pmd);              \
+        mmu_notifier_invalidate_range(__mm, ___haddr,                   \
+                                      ___haddr + HPAGE_PMD_SIZE);       \
+                                                                        \
+        ___pmd;                                                         \
+})
+
 /*
  * set_pte_at_notify() sets the pte _after_ running the notifier.
  * This is safe to start by updating the secondary MMUs, because the primary MMU
@@ -301,7 +380,8 @@ static inline void mmu_notifier_release(struct mm_struct *mm)
 }
 
 static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
-                                          unsigned long address)
+                                          unsigned long start,
+                                          unsigned long end)
 {
         return 0;
 }
@@ -332,6 +412,11 @@ static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
 {
 }
 
+static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+}
+
 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
 {
 }
@@ -342,6 +427,9 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
 
 #define ptep_clear_flush_young_notify ptep_clear_flush_young
 #define pmdp_clear_flush_young_notify pmdp_clear_flush_young
+#define ptep_clear_flush_notify ptep_clear_flush
+#define pmdp_clear_flush_notify pmdp_clear_flush
+#define pmdp_get_and_clear_notify pmdp_get_and_clear
 #define set_pte_at_notify set_pte_at
 
 #endif /* CONFIG_MMU_NOTIFIER */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 318df7051850..2f0856d14b21 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -431,6 +431,15 @@ struct zone {
          */
         int                     nr_migrate_reserve_block;
 
+#ifdef CONFIG_MEMORY_ISOLATION
+        /*
+         * Number of isolated pageblock. It is used to solve incorrect
+         * freepage counting problem due to racy retrieving migratetype
+         * of pageblock. Protected by zone->lock.
+         */
+        unsigned long           nr_isolate_pageblock;
+#endif
+
 #ifdef CONFIG_MEMORY_HOTPLUG
         /* see spanned/present_pages for more description */
         seqlock_t               span_seqlock;
@@ -521,13 +530,13 @@ struct zone {
         atomic_long_t           vm_stat[NR_VM_ZONE_STAT_ITEMS];
 } ____cacheline_internodealigned_in_smp;
 
-typedef enum {
+enum zone_flags {
         ZONE_RECLAIM_LOCKED,            /* prevents concurrent reclaim */
         ZONE_OOM_LOCKED,                /* zone is in OOM killer zonelist */
         ZONE_CONGESTED,                 /* zone has many dirty pages backed by
                                          * a congested BDI
                                          */
-        ZONE_TAIL_LRU_DIRTY,            /* reclaim scanning has recently found
+        ZONE_DIRTY,                     /* reclaim scanning has recently found
                                          * many dirty file pages at the tail
                                          * of the LRU.
                                          */
@@ -535,52 +544,7 @@ typedef enum {
                                          * many pages under writeback
                                          */
         ZONE_FAIR_DEPLETED,             /* fair zone policy batch depleted */
-} zone_flags_t;
-
-static inline void zone_set_flag(struct zone *zone, zone_flags_t flag)
-{
-        set_bit(flag, &zone->flags);
-}
-
-static inline int zone_test_and_set_flag(struct zone *zone, zone_flags_t flag)
-{
-        return test_and_set_bit(flag, &zone->flags);
-}
-
-static inline void zone_clear_flag(struct zone *zone, zone_flags_t flag)
-{
-        clear_bit(flag, &zone->flags);
-}
-
-static inline int zone_is_reclaim_congested(const struct zone *zone)
-{
-        return test_bit(ZONE_CONGESTED, &zone->flags);
-}
-
-static inline int zone_is_reclaim_dirty(const struct zone *zone)
-{
-        return test_bit(ZONE_TAIL_LRU_DIRTY, &zone->flags);
-}
-
-static inline int zone_is_reclaim_writeback(const struct zone *zone)
-{
-        return test_bit(ZONE_WRITEBACK, &zone->flags);
-}
-
-static inline int zone_is_reclaim_locked(const struct zone *zone)
-{
-        return test_bit(ZONE_RECLAIM_LOCKED, &zone->flags);
-}
-
-static inline int zone_is_fair_depleted(const struct zone *zone)
-{
-        return test_bit(ZONE_FAIR_DEPLETED, &zone->flags);
-}
-
-static inline int zone_is_oom_locked(const struct zone *zone)
-{
-        return test_bit(ZONE_OOM_LOCKED, &zone->flags);
-}
+};
 
 static inline unsigned long zone_end_pfn(const struct zone *zone)
 {
@@ -758,8 +722,8 @@ typedef struct pglist_data {
         int nr_zones;
 #ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */
         struct page *node_mem_map;
-#ifdef CONFIG_MEMCG
-        struct page_cgroup *node_page_cgroup;
+#ifdef CONFIG_PAGE_EXTENSION
+        struct page_ext *node_page_ext;
 #endif
 #endif
 #ifndef CONFIG_NO_BOOTMEM
@@ -1114,7 +1078,7 @@ static inline unsigned long early_pfn_to_nid(unsigned long pfn)
 #define SECTION_ALIGN_DOWN(pfn) ((pfn) & PAGE_SECTION_MASK)
 
 struct page;
-struct page_cgroup;
+struct page_ext;
 struct mem_section {
         /*
          * This is, logically, a pointer to an array of struct
@@ -1132,12 +1096,12 @@ struct mem_section {
 
         /* See declaration of similar field in struct zone */
         unsigned long *pageblock_flags;
-#ifdef CONFIG_MEMCG
+#ifdef CONFIG_PAGE_EXTENSION
         /*
-         * If !SPARSEMEM, pgdat doesn't have page_cgroup pointer. We use
-         * section. (see memcontrol.h/page_cgroup.h about this.)
+         * If !SPARSEMEM, pgdat doesn't have page_ext pointer. We use
+         * section. (see page_ext.h about this.)
          */
-        struct page_cgroup *page_cgroup;
+        struct page_ext *page_ext;
         unsigned long pad;
 #endif
         /*
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 44eeef0da186..745def862580 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -69,7 +69,7 @@ struct ieee1394_device_id {
  * @bDeviceClass: Class of device; numbers are assigned
  *      by the USB forum.  Products may choose to implement classes,
  *      or be vendor-specific.  Device classes specify behavior of all
- *      the interfaces on a devices.
+ *      the interfaces on a device.
  * @bDeviceSubClass: Subclass of device; associated with bDeviceClass.
  * @bDeviceProtocol: Protocol of device; associated with bDeviceClass.
  * @bInterfaceClass: Class of interface; numbers are assigned
diff --git a/include/linux/module.h b/include/linux/module.h
index 71f282a4e307..ebfb0e153c6a 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -210,20 +210,6 @@ enum module_state {
         MODULE_STATE_UNFORMED,  /* Still setting it up. */
 };
 
-/**
- * struct module_ref - per cpu module reference counts
- * @incs: number of module get on this cpu
- * @decs: number of module put on this cpu
- *
- * We force an alignment on 8 or 16 bytes, so that alloc_percpu()
- * put @incs/@decs in same cache line, with no extra memory cost,
- * since alloc_percpu() is fine grained.
- */
-struct module_ref {
-        unsigned long incs;
-        unsigned long decs;
-} __attribute((aligned(2 * sizeof(unsigned long))));
-
 struct module {
         enum module_state state;
 
@@ -367,7 +353,7 @@ struct module {
         /* Destruction function. */
         void (*exit)(void);
 
-        struct module_ref __percpu *refptr;
+        atomic_t refcnt;
 #endif
 
 #ifdef CONFIG_CONSTRUCTORS
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index 494f99e852da..1c9effa25e26 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -42,7 +42,7 @@ struct kernel_param;
  * NOARG - the parameter allows for no argument (foo instead of foo=1)
  */
 enum {
-        KERNEL_PARAM_FL_NOARG = (1 << 0)
+        KERNEL_PARAM_OPS_FL_NOARG = (1 << 0)
 };
 
 struct kernel_param_ops {
@@ -56,11 +56,21 @@ struct kernel_param_ops {
         void (*free)(void *arg);
 };
 
+/*
+ * Flags available for kernel_param
+ *
+ * UNSAFE - the parameter is dangerous and setting it will taint the kernel
+ */
+enum {
+        KERNEL_PARAM_FL_UNSAFE = (1 << 0)
+};
+
 struct kernel_param {
         const char *name;
         const struct kernel_param_ops *ops;
         u16 perm;
-        s16 level;
+        s8 level;
+        u8 flags;
         union {
                 void *arg;
                 const struct kparam_string *str;
@@ -68,6 +78,8 @@ struct kernel_param {
         };
 };
 
+extern const struct kernel_param __start___param[], __stop___param[];
+
 /* Special one for strings we want to copy into */
 struct kparam_string {
         unsigned int maxlen;
@@ -113,6 +125,12 @@ struct kparam_array
         module_param_named(name, name, type, perm)
 
 /**
+ * module_param_unsafe - same as module_param but taints kernel
+ */
+#define module_param_unsafe(name, type, perm)                   \
+        module_param_named_unsafe(name, name, type, perm)
+
+/**
  * module_param_named - typesafe helper for a renamed module/cmdline parameter
  * @name: a valid C identifier which is the parameter name.
  * @value: the actual lvalue to alter.
@@ -129,6 +147,14 @@ struct kparam_array
         __MODULE_PARM_TYPE(name, #type)
 
 /**
+ * module_param_named_unsafe - same as module_param_named but taints kernel
+ */
+#define module_param_named_unsafe(name, value, type, perm)              \
+        param_check_##type(name, &(value));                             \
+        module_param_cb_unsafe(name, &param_ops_##type, &value, perm);  \
+        __MODULE_PARM_TYPE(name, #type)
+
+/**
  * module_param_cb - general callback for a module/cmdline parameter
  * @name: a valid C identifier which is the parameter name.
  * @ops: the set & get operations for this parameter.
@@ -137,7 +163,11 @@ struct kparam_array
  * The ops can have NULL set or get functions.
  */
 #define module_param_cb(name, ops, arg, perm)                                 \
-        __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1)
+        __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1, 0)
+
+#define module_param_cb_unsafe(name, ops, arg, perm)                          \
+        __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, -1,    \
+                            KERNEL_PARAM_FL_UNSAFE)
 
 /**
  * <level>_param_cb - general callback for a module/cmdline parameter
@@ -149,7 +179,7 @@ struct kparam_array
  * The ops can have NULL set or get functions.
  */
 #define __level_param_cb(name, ops, arg, perm, level)                   \
-        __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level)
+        __module_param_call(MODULE_PARAM_PREFIX, name, ops, arg, perm, level, 0)
 
 #define core_param_cb(name, ops, arg, perm)             \
         __level_param_cb(name, ops, arg, perm, 1)
@@ -184,22 +214,22 @@ struct kparam_array
 
 /* This is the fundamental function for registering boot/module
    parameters. */
-#define __module_param_call(prefix, name, ops, arg, perm, level)        \
+#define __module_param_call(prefix, name, ops, arg, perm, level, flags) \
         /* Default value instead of permissions? */                     \
         static const char __param_str_##name[] = prefix #name; \
         static struct kernel_param __moduleparam_const __param_##name   \
         __used                                                          \
     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
         = { __param_str_##name, ops, VERIFY_OCTAL_PERMISSIONS(perm),    \
-            level, { arg } }
+            level, flags, { arg } }
 
 /* Obsolete - use module_param_cb() */
 #define module_param_call(name, set, get, arg, perm)                    \
         static struct kernel_param_ops __param_ops_##name =             \
-                { 0, (void *)set, (void *)get };                        \
+                { .flags = 0, (void *)set, (void *)get };               \
         __module_param_call(MODULE_PARAM_PREFIX,                        \
                             name, &__param_ops_##name, arg,             \
-                            (perm) + sizeof(__check_old_set_param(set))*0, -1)
+                            (perm) + sizeof(__check_old_set_param(set))*0, -1, 0)
 
 /* We don't get oldget: it's often a new-style param_get_uint, etc. */
 static inline int
@@ -279,7 +309,7 @@ static inline void __kernel_param_unlock(void)
  */
 #define core_param(name, var, type, perm)                               \
         param_check_##type(name, &(var));                               \
-        __module_param_call("", name, &param_ops_##type, &var, perm, -1)
+        __module_param_call("", name, &param_ops_##type, &var, perm, -1, 0)
 #endif /* !MODULE */
 
 /**
@@ -297,7 +327,7 @@ static inline void __kernel_param_unlock(void)
                 = { len, string };                                      \
         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
                             &param_ops_string,                          \
-                            .str = &__param_string_##name, perm, -1);   \
+                            .str = &__param_string_##name, perm, -1, 0);\
         __MODULE_PARM_TYPE(name, "string")
 
 /**
@@ -444,7 +474,7 @@ extern int param_set_bint(const char *val, const struct kernel_param *kp);
         __module_param_call(MODULE_PARAM_PREFIX, name,                  \
                             &param_array_ops,                           \
                             .arr = &__param_arr_##name,                 \
-                            perm, -1);                                  \
+                            perm, -1, 0);                               \
         __MODULE_PARM_TYPE(name, "array of " #type)
 
 extern struct kernel_param_ops param_array_ops;
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 9262e4bf0cc3..c2c561dc0114 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -81,6 +81,9 @@ extern struct vfsmount *mntget(struct vfsmount *mnt);
 extern struct vfsmount *mnt_clone_internal(struct path *path);
 extern int __mnt_is_readonly(struct vfsmount *mnt);
 
+struct path;
+extern struct vfsmount *clone_private_mount(struct path *path);
+
 struct file_system_type;
 extern struct vfsmount *vfs_kern_mount(struct file_system_type *type,
                                       int flags, const char *name,
diff --git a/include/linux/msi.h b/include/linux/msi.h
index 8103f32f6d87..8ac4a68ffae2 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -10,17 +10,12 @@ struct msi_msg {
         u32     data;           /* 16 bits of msi message data */
 };
 
+extern int pci_msi_ignore_mask;
 /* Helper functions */
 struct irq_data;
 struct msi_desc;
-void mask_msi_irq(struct irq_data *data);
-void unmask_msi_irq(struct irq_data *data);
-void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
 void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
-void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
-void read_msi_msg(unsigned int irq, struct msi_msg *msg);
 void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg);
-void write_msi_msg(unsigned int irq, struct msi_msg *msg);
 
 struct msi_desc {
         struct {
@@ -29,7 +24,6 @@ struct msi_desc {
                 __u8    multi_cap : 3;  /* log2 num of messages supported */
                 __u8    maskbit : 1;    /* mask-pending bit supported ? */
                 __u8    is_64   : 1;    /* Address size: 0=32bit 1=64bit */
-                __u8    pos;            /* Location of the msi capability */
                 __u16   entry_nr;       /* specific enabled entry */
                 unsigned default_irq;   /* default pre-assigned irq */
         } msi_attrib;
@@ -47,10 +41,54 @@ struct msi_desc {
 
         /* Last set MSI message */
         struct msi_msg msg;
-
-        struct kobject kobj;
 };
 
+/* Helpers to hide struct msi_desc implementation details */
+#define msi_desc_to_dev(desc)           (&(desc)->dev.dev)
+#define dev_to_msi_list(dev)            (&to_pci_dev((dev))->msi_list)
+#define first_msi_entry(dev)            \
+        list_first_entry(dev_to_msi_list((dev)), struct msi_desc, list)
+#define for_each_msi_entry(desc, dev)   \
+        list_for_each_entry((desc), dev_to_msi_list((dev)), list)
+
+#ifdef CONFIG_PCI_MSI
+#define first_pci_msi_entry(pdev)       first_msi_entry(&(pdev)->dev)
+#define for_each_pci_msi_entry(desc, pdev)      \
+        for_each_msi_entry((desc), &(pdev)->dev)
+
+static inline struct pci_dev *msi_desc_to_pci_dev(struct msi_desc *desc)
+{
+        return desc->dev;
+}
+#endif /* CONFIG_PCI_MSI */
+
+void __pci_read_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
+void __pci_write_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
+void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg);
+
+u32 __pci_msix_desc_mask_irq(struct msi_desc *desc, u32 flag);
+u32 __pci_msi_desc_mask_irq(struct msi_desc *desc, u32 mask, u32 flag);
+void pci_msi_mask_irq(struct irq_data *data);
+void pci_msi_unmask_irq(struct irq_data *data);
+
+/* Conversion helpers. Should be removed after merging */
+static inline void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
+{
+        __pci_write_msi_msg(entry, msg);
+}
+static inline void write_msi_msg(int irq, struct msi_msg *msg)
+{
+        pci_write_msi_msg(irq, msg);
+}
+static inline void mask_msi_irq(struct irq_data *data)
+{
+        pci_msi_mask_irq(data);
+}
+static inline void unmask_msi_irq(struct irq_data *data)
+{
+        pci_msi_unmask_irq(data);
+}
+
 /*
  * The arch hooks to setup up msi irqs. Those functions are
  * implemented as weak symbols so that they /can/ be overriden by
@@ -60,25 +98,146 @@ int arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc);
 void arch_teardown_msi_irq(unsigned int irq);
 int arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type);
 void arch_teardown_msi_irqs(struct pci_dev *dev);
-int arch_msi_check_device(struct pci_dev* dev, int nvec, int type);
 void arch_restore_msi_irqs(struct pci_dev *dev);
 
 void default_teardown_msi_irqs(struct pci_dev *dev);
 void default_restore_msi_irqs(struct pci_dev *dev);
-u32 default_msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag);
-u32 default_msix_mask_irq(struct msi_desc *desc, u32 flag);
 
-struct msi_chip {
+struct msi_controller {
         struct module *owner;
         struct device *dev;
         struct device_node *of_node;
         struct list_head list;
+#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
+        struct irq_domain *domain;
+#endif
 
-        int (*setup_irq)(struct msi_chip *chip, struct pci_dev *dev,
+        int (*setup_irq)(struct msi_controller *chip, struct pci_dev *dev,
                          struct msi_desc *desc);
-        void (*teardown_irq)(struct msi_chip *chip, unsigned int irq);
-        int (*check_device)(struct msi_chip *chip, struct pci_dev *dev,
-                            int nvec, int type);
+        void (*teardown_irq)(struct msi_controller *chip, unsigned int irq);
 };
 
+#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
+
+#include <linux/irqhandler.h>
+#include <asm/msi.h>
+
+struct irq_domain;
+struct irq_chip;
+struct device_node;
+struct msi_domain_info;
+
+/**
+ * struct msi_domain_ops - MSI interrupt domain callbacks
+ * @get_hwirq:          Retrieve the resulting hw irq number
+ * @msi_init:           Domain specific init function for MSI interrupts
+ * @msi_free:           Domain specific function to free a MSI interrupts
+ * @msi_check:          Callback for verification of the domain/info/dev data
+ * @msi_prepare:        Prepare the allocation of the interrupts in the domain
+ * @msi_finish:         Optional callbacl to finalize the allocation
+ * @set_desc:           Set the msi descriptor for an interrupt
+ * @handle_error:       Optional error handler if the allocation fails
+ *
+ * @get_hwirq, @msi_init and @msi_free are callbacks used by
+ * msi_create_irq_domain() and related interfaces
+ *
+ * @msi_check, @msi_prepare, @msi_finish, @set_desc and @handle_error
+ * are callbacks used by msi_irq_domain_alloc_irqs() and related
+ * interfaces which are based on msi_desc.
+ */
+struct msi_domain_ops {
+        irq_hw_number_t (*get_hwirq)(struct msi_domain_info *info,
+                                     msi_alloc_info_t *arg);
+        int             (*msi_init)(struct irq_domain *domain,
+                                    struct msi_domain_info *info,
+                                    unsigned int virq, irq_hw_number_t hwirq,
+                                    msi_alloc_info_t *arg);
+        void            (*msi_free)(struct irq_domain *domain,
+                                    struct msi_domain_info *info,
+                                    unsigned int virq);
+        int             (*msi_check)(struct irq_domain *domain,
+                                     struct msi_domain_info *info,
+                                     struct device *dev);
+        int             (*msi_prepare)(struct irq_domain *domain,
+                                       struct device *dev, int nvec,
+                                       msi_alloc_info_t *arg);
+        void            (*msi_finish)(msi_alloc_info_t *arg, int retval);
+        void            (*set_desc)(msi_alloc_info_t *arg,
+                                    struct msi_desc *desc);
+        int             (*handle_error)(struct irq_domain *domain,
+                                        struct msi_desc *desc, int error);
+};
+
+/**
+ * struct msi_domain_info - MSI interrupt domain data
+ * @flags:              Flags to decribe features and capabilities
+ * @ops:                The callback data structure
+ * @chip:               Optional: associated interrupt chip
+ * @chip_data:          Optional: associated interrupt chip data
+ * @handler:            Optional: associated interrupt flow handler
+ * @handler_data:       Optional: associated interrupt flow handler data
+ * @handler_name:       Optional: associated interrupt flow handler name
+ * @data:               Optional: domain specific data
+ */
+struct msi_domain_info {
+        u32                     flags;
+        struct msi_domain_ops   *ops;
+        struct irq_chip         *chip;
+        void                    *chip_data;
+        irq_flow_handler_t      handler;
+        void                    *handler_data;
+        const char              *handler_name;
+        void                    *data;
+};
+
+/* Flags for msi_domain_info */
+enum {
+        /*
+         * Init non implemented ops callbacks with default MSI domain
+         * callbacks.
+         */
+        MSI_FLAG_USE_DEF_DOM_OPS        = (1 << 0),
+        /*
+         * Init non implemented chip callbacks with default MSI chip
+         * callbacks.
+         */
+        MSI_FLAG_USE_DEF_CHIP_OPS       = (1 << 1),
+        /* Build identity map between hwirq and irq */
+        MSI_FLAG_IDENTITY_MAP           = (1 << 2),
+        /* Support multiple PCI MSI interrupts */
+        MSI_FLAG_MULTI_PCI_MSI          = (1 << 3),
+        /* Support PCI MSIX interrupts */
+        MSI_FLAG_PCI_MSIX               = (1 << 4),
+};
+
+int msi_domain_set_affinity(struct irq_data *data, const struct cpumask *mask,
+                            bool force);
+
+struct irq_domain *msi_create_irq_domain(struct device_node *of_node,
+                                         struct msi_domain_info *info,
+                                         struct irq_domain *parent);
+int msi_domain_alloc_irqs(struct irq_domain *domain, struct device *dev,
+                          int nvec);
+void msi_domain_free_irqs(struct irq_domain *domain, struct device *dev);
+struct msi_domain_info *msi_get_domain_info(struct irq_domain *domain);
+
+#endif /* CONFIG_GENERIC_MSI_IRQ_DOMAIN */
+
+#ifdef CONFIG_PCI_MSI_IRQ_DOMAIN
+void pci_msi_domain_write_msg(struct irq_data *irq_data, struct msi_msg *msg);
+struct irq_domain *pci_msi_create_irq_domain(struct device_node *node,
+                                             struct msi_domain_info *info,
+                                             struct irq_domain *parent);
+int pci_msi_domain_alloc_irqs(struct irq_domain *domain, struct pci_dev *dev,
+                              int nvec, int type);
+void pci_msi_domain_free_irqs(struct irq_domain *domain, struct pci_dev *dev);
+struct irq_domain *pci_msi_create_default_irq_domain(struct device_node *node,
+                 struct msi_domain_info *info, struct irq_domain *parent);
+
+irq_hw_number_t pci_msi_domain_calc_hwirq(struct pci_dev *dev,
+                                          struct msi_desc *desc);
+int pci_msi_domain_check_cap(struct irq_domain *domain,
+                             struct msi_domain_info *info, struct device *dev);
+#endif /* CONFIG_PCI_MSI_IRQ_DOMAIN */
+
 #endif /* LINUX_MSI_H */
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index 37ef6b194089..299d7d31fe53 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -153,7 +153,7 @@ struct cfi_ident {
         uint16_t MaxBufWriteSize;
         uint8_t  NumEraseRegions;
         uint32_t EraseRegionInfo[0]; /* Not host ordered */
-} __attribute__((packed));
+} __packed;
 
 /* Extended Query Structure for both PRI and ALT */
 
@@ -161,7 +161,7 @@ struct cfi_extquery {
         uint8_t  pri[3];
         uint8_t  MajorVersion;
         uint8_t  MinorVersion;
-} __attribute__((packed));
+} __packed;
 
 /* Vendor-Specific PRI for Intel/Sharp Extended Command Set (0x0001) */
 
@@ -180,7 +180,7 @@ struct cfi_pri_intelext {
         uint8_t  FactProtRegSize;
         uint8_t  UserProtRegSize;
         uint8_t  extra[0];
-} __attribute__((packed));
+} __packed;
 
 struct cfi_intelext_otpinfo {
         uint32_t ProtRegAddr;
@@ -188,7 +188,7 @@ struct cfi_intelext_otpinfo {
         uint8_t  FactProtRegSize;
         uint16_t UserGroups;
         uint8_t  UserProtRegSize;
-} __attribute__((packed));
+} __packed;
 
 struct cfi_intelext_blockinfo {
         uint16_t NumIdentBlocks;
@@ -196,7 +196,7 @@ struct cfi_intelext_blockinfo {
         uint16_t MinBlockEraseCycles;
         uint8_t  BitsPerCell;
         uint8_t  BlockCap;
-} __attribute__((packed));
+} __packed;
 
 struct cfi_intelext_regioninfo {
         uint16_t NumIdentPartitions;
@@ -205,7 +205,7 @@ struct cfi_intelext_regioninfo {
         uint8_t  NumOpAllowedSimEraMode;
         uint8_t  NumBlockTypes;
         struct cfi_intelext_blockinfo BlockTypes[1];
-} __attribute__((packed));
+} __packed;
 
 struct cfi_intelext_programming_regioninfo {
         uint8_t  ProgRegShift;
@@ -214,7 +214,7 @@ struct cfi_intelext_programming_regioninfo {
         uint8_t  Reserved2;
         uint8_t  ControlInvalid;
         uint8_t  Reserved3;
-} __attribute__((packed));
+} __packed;
 
 /* Vendor-Specific PRI for AMD/Fujitsu Extended Command Set (0x0002) */
 
@@ -233,7 +233,7 @@ struct cfi_pri_amdstd {
         uint8_t  VppMin;
         uint8_t  VppMax;
         uint8_t  TopBottom;
-} __attribute__((packed));
+} __packed;
 
 /* Vendor-Specific PRI for Atmel chips (command set 0x0002) */
 
@@ -245,18 +245,18 @@ struct cfi_pri_atmel {
         uint8_t BottomBoot;
         uint8_t BurstMode;
         uint8_t PageMode;
-} __attribute__((packed));
+} __packed;
 
 struct cfi_pri_query {
         uint8_t  NumFields;
         uint32_t ProtField[1]; /* Not host ordered */
-} __attribute__((packed));
+} __packed;
 
 struct cfi_bri_query {
         uint8_t  PageModeReadCap;
         uint8_t  NumFields;
         uint32_t ConfField[1]; /* Not host ordered */
-} __attribute__((packed));
+} __packed;
 
 #define P_ID_NONE               0x0000
 #define P_ID_INTEL_EXT          0x0001
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index c300db3ae285..3d4ea7eb2b68 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -455,8 +455,21 @@ struct nand_hw_control {
  *              be provided if an hardware ECC is available
  * @calculate:  function for ECC calculation or readback from ECC hardware
  * @correct:    function for ECC correction, matching to ECC generator (sw/hw)
- * @read_page_raw:      function to read a raw page without ECC
- * @write_page_raw:     function to write a raw page without ECC
+ * @read_page_raw:      function to read a raw page without ECC. This function
+ *                      should hide the specific layout used by the ECC
+ *                      controller and always return contiguous in-band and
+ *                      out-of-band data even if they're not stored
+ *                      contiguously on the NAND chip (e.g.
+ *                      NAND_ECC_HW_SYNDROME interleaves in-band and
+ *                      out-of-band data).
+ * @write_page_raw:     function to write a raw page without ECC. This function
+ *                      should hide the specific layout used by the ECC
+ *                      controller and consider the passed data as contiguous
+ *                      in-band and out-of-band data. ECC controller is
+ *                      responsible for doing the appropriate transformations
+ *                      to adapt to its specific layout (e.g.
+ *                      NAND_ECC_HW_SYNDROME interleaves in-band and
+ *                      out-of-band data).
  * @read_page:  function to read a page according to the ECC generator
  *              requirements; returns maximum number of bitflips corrected in
  *              any single ECC step, 0 if bitflips uncorrectable, -EIO hw error
@@ -587,6 +600,11 @@ struct nand_buffers {
  * @ecc_step_ds:        [INTERN] ECC step required by the @ecc_strength_ds,
  *                      also from the datasheet. It is the recommended ECC step
  *                      size, if known; if unknown, set to zero.
+ * @onfi_timing_mode_default: [INTERN] default ONFI timing mode. This field is
+ *                            either deduced from the datasheet if the NAND
+ *                            chip is not ONFI compliant or set to 0 if it is
+ *                            (an ONFI chip is always configured in mode 0
+ *                            after a NAND reset)
  * @numchips:           [INTERN] number of physical chips
  * @chipsize:           [INTERN] the size of one chip for multichip arrays
  * @pagemask:           [INTERN] page number mask = number of (pages / chip) - 1
@@ -671,6 +689,7 @@ struct nand_chip {
         uint8_t bits_per_cell;
         uint16_t ecc_strength_ds;
         uint16_t ecc_step_ds;
+        int onfi_timing_mode_default;
         int badblockpos;
         int badblockbits;
 
@@ -717,6 +736,7 @@ struct nand_chip {
 #define NAND_MFR_EON            0x92
 #define NAND_MFR_SANDISK        0x45
 #define NAND_MFR_INTEL          0x89
+#define NAND_MFR_ATO            0x9b
 
 /* The maximum expected count of bytes in the NAND ID sequence */
 #define NAND_MAX_ID_LEN 8
@@ -766,12 +786,17 @@ struct nand_chip {
  * @options: stores various chip bit options
  * @id_len: The valid length of the @id.
  * @oobsize: OOB size
+ * @ecc: ECC correctability and step information from the datasheet.
  * @ecc.strength_ds: The ECC correctability from the datasheet, same as the
  *                   @ecc_strength_ds in nand_chip{}.
  * @ecc.step_ds: The ECC step required by the @ecc.strength_ds, same as the
  *               @ecc_step_ds in nand_chip{}, also from the datasheet.
  *               For example, the "4bit ECC for each 512Byte" can be set with
  *               NAND_ECC_INFO(4, 512).
+ * @onfi_timing_mode_default: the default ONFI timing mode entered after a NAND
+ *                            reset. Should be deduced from timings described
+ *                            in the datasheet.
+ *
  */
 struct nand_flash_dev {
         char *name;
@@ -792,6 +817,7 @@ struct nand_flash_dev {
                 uint16_t strength_ds;
                 uint16_t step_ds;
         } ecc;
+        int onfi_timing_mode_default;
 };
 
 /**
diff --git a/include/linux/mtd/spi-nor.h b/include/linux/mtd/spi-nor.h
index 9e6294f32ba8..63aeccf9ddc8 100644
--- a/include/linux/mtd/spi-nor.h
+++ b/include/linux/mtd/spi-nor.h
@@ -116,6 +116,10 @@ enum spi_nor_ops {
         SPI_NOR_OPS_UNLOCK,
 };
 
+enum spi_nor_option_flags {
+        SNOR_F_USE_FSR          = BIT(0),
+};
+
 /**
  * struct spi_nor - Structure for defining a the SPI NOR layer
  * @mtd:                point to a mtd_info structure
@@ -129,6 +133,7 @@ enum spi_nor_ops {
  * @program_opcode:     the program opcode
  * @flash_read:         the mode of the read
  * @sst_write_second:   used by the SST write operation
+ * @flags:              flag options for the current SPI-NOR (SNOR_F_*)
  * @cfg:                used by the read_xfer/write_xfer
  * @cmd_buf:            used by the write_reg
  * @prepare:            [OPTIONAL] do some preparations for the
@@ -139,9 +144,6 @@ enum spi_nor_ops {
  * @write_xfer:         [OPTIONAL] the writefundamental primitive
  * @read_reg:           [DRIVER-SPECIFIC] read out the register
  * @write_reg:          [DRIVER-SPECIFIC] write data to the register
- * @read_id:            [REPLACEABLE] read out the ID data, and find
- *                      the proper spi_device_id
- * @wait_till_ready:    [REPLACEABLE] wait till the NOR becomes ready
  * @read:               [DRIVER-SPECIFIC] read data from the SPI NOR
  * @write:              [DRIVER-SPECIFIC] write data to the SPI NOR
  * @erase:              [DRIVER-SPECIFIC] erase a sector of the SPI NOR
@@ -160,6 +162,7 @@ struct spi_nor {
         u8                      program_opcode;
         enum read_mode          flash_read;
         bool                    sst_write_second;
+        u32                     flags;
         struct spi_nor_xfer_cfg cfg;
         u8                      cmd_buf[SPI_NOR_MAX_CMD_SIZE];
 
@@ -172,8 +175,6 @@ struct spi_nor {
         int (*read_reg)(struct spi_nor *nor, u8 opcode, u8 *buf, int len);
         int (*write_reg)(struct spi_nor *nor, u8 opcode, u8 *buf, int len,
                         int write_enable);
-        const struct spi_device_id *(*read_id)(struct spi_nor *nor);
-        int (*wait_till_ready)(struct spi_nor *nor);
 
         int (*read)(struct spi_nor *nor, loff_t from,
                         size_t len, size_t *retlen, u_char *read_buf);
@@ -187,32 +188,17 @@ struct spi_nor {
 /**
  * spi_nor_scan() - scan the SPI NOR
  * @nor:        the spi_nor structure
- * @id:         the spi_device_id provided by the driver
+ * @name:       the chip type name
  * @mode:       the read mode supported by the driver
  *
  * The drivers can use this fuction to scan the SPI NOR.
  * In the scanning, it will try to get all the necessary information to
  * fill the mtd_info{} and the spi_nor{}.
  *
- * The board may assigns a spi_device_id with @id which be used to compared with
- * the spi_device_id detected by the scanning.
+ * The chip type name can be provided through the @name parameter.
  *
  * Return: 0 for success, others for failure.
  */
-int spi_nor_scan(struct spi_nor *nor, const struct spi_device_id *id,
-                        enum read_mode mode);
-extern const struct spi_device_id spi_nor_ids[];
-
-/**
- * spi_nor_match_id() - find the spi_device_id by the name
- * @name:       the name of the spi_device_id
- *
- * The drivers use this function to find the spi_device_id
- * specified by the @name.
- *
- * Return: returns the right spi_device_id pointer on success,
- *         and returns NULL on failure.
- */
-const struct spi_device_id *spi_nor_match_id(char *name);
+int spi_nor_scan(struct spi_nor *nor, const char *name, enum read_mode mode);
 
 #endif
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index 8d5535c58cc2..cc31498fc526 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -52,7 +52,7 @@ struct mutex {
         atomic_t                count;
         spinlock_t              wait_lock;
         struct list_head        wait_list;
-#if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_SMP)
+#if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_MUTEX_SPIN_ON_OWNER)
         struct task_struct      *owner;
 #endif
 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
@@ -133,7 +133,7 @@ static inline int mutex_is_locked(struct mutex *lock)
 
 /*
  * See kernel/locking/mutex.c for detailed documentation of these APIs.
- * Also see Documentation/mutex-design.txt.
+ * Also see Documentation/locking/mutex-design.txt.
  */
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
diff --git a/include/linux/namei.h b/include/linux/namei.h
index 492de72560fa..c8990779f0c3 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -7,21 +7,10 @@
 #include <linux/path.h>
 
 struct vfsmount;
+struct nameidata;
 
 enum { MAX_NESTED_LINKS = 8 };
 
-struct nameidata {
-        struct path     path;
-        struct qstr     last;
-        struct path     root;
-        struct inode    *inode; /* path.dentry.d_inode */
-        unsigned int    flags;
-        unsigned        seq, m_seq;
-        int             last_type;
-        unsigned        depth;
-        char *saved_names[MAX_NESTED_LINKS + 1];
-};
-
 /*
  * Type of the last component on LOOKUP_PARENT
  */
@@ -82,16 +71,8 @@ extern struct dentry *lock_rename(struct dentry *, struct dentry *);
 extern void unlock_rename(struct dentry *, struct dentry *);
 
 extern void nd_jump_link(struct nameidata *nd, struct path *path);
-
-static inline void nd_set_link(struct nameidata *nd, char *path)
-{
-        nd->saved_names[nd->depth] = path;
-}
-
-static inline char *nd_get_link(struct nameidata *nd)
-{
-        return nd->saved_names[nd->depth];
-}
+extern void nd_set_link(struct nameidata *nd, char *path);
+extern char *nd_get_link(struct nameidata *nd);
 
 static inline void nd_terminate_link(void *name, size_t len, size_t maxlen)
 {
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index dcfdecbfa0b7..8e30685affeb 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -47,9 +47,9 @@ enum {
         NETIF_F_GSO_SIT_BIT,            /* ... SIT tunnel with TSO */
         NETIF_F_GSO_UDP_TUNNEL_BIT,     /* ... UDP TUNNEL with TSO */
         NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT,/* ... UDP TUNNEL with TSO & CSUM */
-        NETIF_F_GSO_MPLS_BIT,           /* ... MPLS segmentation */
+        NETIF_F_GSO_TUNNEL_REMCSUM_BIT, /* ... TUNNEL with TSO & REMCSUM */
         /**/NETIF_F_GSO_LAST =          /* last bit, see GSO_MASK */
-                NETIF_F_GSO_MPLS_BIT,
+                NETIF_F_GSO_TUNNEL_REMCSUM_BIT,
 
         NETIF_F_FCOE_CRC_BIT,           /* FCoE CRC32 */
         NETIF_F_SCTP_CSUM_BIT,          /* SCTP checksum offload */
@@ -118,7 +118,7 @@ enum {
 #define NETIF_F_GSO_SIT         __NETIF_F(GSO_SIT)
 #define NETIF_F_GSO_UDP_TUNNEL  __NETIF_F(GSO_UDP_TUNNEL)
 #define NETIF_F_GSO_UDP_TUNNEL_CSUM __NETIF_F(GSO_UDP_TUNNEL_CSUM)
-#define NETIF_F_GSO_MPLS        __NETIF_F(GSO_MPLS)
+#define NETIF_F_GSO_TUNNEL_REMCSUM __NETIF_F(GSO_TUNNEL_REMCSUM)
 #define NETIF_F_HW_VLAN_STAG_FILTER __NETIF_F(HW_VLAN_STAG_FILTER)
 #define NETIF_F_HW_VLAN_STAG_RX __NETIF_F(HW_VLAN_STAG_RX)
 #define NETIF_F_HW_VLAN_STAG_TX __NETIF_F(HW_VLAN_STAG_TX)
@@ -181,7 +181,6 @@ enum {
                                  NETIF_F_GSO_IPIP |                     \
                                  NETIF_F_GSO_SIT |                      \
                                  NETIF_F_GSO_UDP_TUNNEL |               \
-                                 NETIF_F_GSO_UDP_TUNNEL_CSUM |          \
-                                 NETIF_F_GSO_MPLS)
+                                 NETIF_F_GSO_UDP_TUNNEL_CSUM)
 
 #endif  /* _LINUX_NETDEV_FEATURES_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index c8e388e5fccc..679e6e90aa4c 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -30,6 +30,7 @@
 #include <linux/bug.h>
 #include <linux/delay.h>
 #include <linux/atomic.h>
+#include <linux/prefetch.h>
 #include <asm/cache.h>
 #include <asm/byteorder.h>
 
@@ -56,6 +57,8 @@ struct device;
 struct phy_device;
 /* 802.11 specific */
 struct wireless_dev;
+/* 802.15.4 specific */
+struct wpan_dev;
 
 void netdev_set_default_ethtool_ops(struct net_device *dev,
                                     const struct ethtool_ops *ops);
@@ -313,6 +316,7 @@ struct napi_struct {
         struct net_device       *dev;
         struct sk_buff          *gro_list;
         struct sk_buff          *skb;
+        struct hrtimer          timer;
         struct list_head        dev_list;
         struct hlist_node       napi_hash_node;
         unsigned int            napi_id;
@@ -385,6 +389,7 @@ typedef enum rx_handler_result rx_handler_result_t;
 typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
 
 void __napi_schedule(struct napi_struct *n);
+void __napi_schedule_irqoff(struct napi_struct *n);
 
 static inline bool napi_disable_pending(struct napi_struct *n)
 {
@@ -419,6 +424,18 @@ static inline void napi_schedule(struct napi_struct *n)
                 __napi_schedule(n);
 }
 
+/**
+ *      napi_schedule_irqoff - schedule NAPI poll
+ *      @n: napi context
+ *
+ * Variant of napi_schedule(), assuming hard irqs are masked.
+ */
+static inline void napi_schedule_irqoff(struct napi_struct *n)
+{
+        if (napi_schedule_prep(n))
+                __napi_schedule_irqoff(n);
+}
+
 /* Try to reschedule poll. Called by dev->poll() after napi_complete().  */
 static inline bool napi_reschedule(struct napi_struct *napi)
 {
@@ -429,14 +446,19 @@ static inline bool napi_reschedule(struct napi_struct *napi)
         return false;
 }
 
+void __napi_complete(struct napi_struct *n);
+void napi_complete_done(struct napi_struct *n, int work_done);
 /**
  *      napi_complete - NAPI processing complete
  *      @n: napi context
  *
  * Mark NAPI processing as complete.
+ * Consider using napi_complete_done() instead.
  */
-void __napi_complete(struct napi_struct *n);
-void napi_complete(struct napi_struct *n);
+static inline void napi_complete(struct napi_struct *n)
+{
+        return napi_complete_done(n, 0);
+}
 
 /**
  *      napi_by_id - lookup a NAPI by napi_id
@@ -471,14 +493,7 @@ void napi_hash_del(struct napi_struct *napi);
  * Stop NAPI from being scheduled on this context.
  * Waits till any outstanding processing completes.
  */
-static inline void napi_disable(struct napi_struct *n)
-{
-        might_sleep();
-        set_bit(NAPI_STATE_DISABLE, &n->state);
-        while (test_and_set_bit(NAPI_STATE_SCHED, &n->state))
-                msleep(1);
-        clear_bit(NAPI_STATE_DISABLE, &n->state);
-}
+void napi_disable(struct napi_struct *n);
 
 /**
  *      napi_enable - enable NAPI scheduling
@@ -543,7 +558,7 @@ struct netdev_queue {
  * read mostly part
  */
         struct net_device       *dev;
-        struct Qdisc            *qdisc;
+        struct Qdisc __rcu      *qdisc;
         struct Qdisc            *qdisc_sleeping;
 #ifdef CONFIG_SYSFS
         struct kobject          kobj;
@@ -739,13 +754,13 @@ struct netdev_fcoe_hbainfo {
 };
 #endif
 
-#define MAX_PHYS_PORT_ID_LEN 32
+#define MAX_PHYS_ITEM_ID_LEN 32
 
-/* This structure holds a unique identifier to identify the
- * physical port used by a netdevice.
+/* This structure holds a unique identifier to identify some
+ * physical item (port for example) used by a netdevice.
  */
-struct netdev_phys_port_id {
-        unsigned char id[MAX_PHYS_PORT_ID_LEN];
+struct netdev_phys_item_id {
+        unsigned char id[MAX_PHYS_ITEM_ID_LEN];
         unsigned char id_len;
 };
 
@@ -936,11 +951,11 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *
  * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
  *                    struct net_device *dev,
- *                    const unsigned char *addr, u16 flags)
+ *                    const unsigned char *addr, u16 vid, u16 flags)
  *      Adds an FDB entry to dev for addr.
  * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
  *                    struct net_device *dev,
- *                    const unsigned char *addr)
+ *                    const unsigned char *addr, u16 vid)
  *      Deletes the FDB entry from dev coresponding to addr.
  * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
  *                     struct net_device *dev, struct net_device *filter_dev,
@@ -961,7 +976,7 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *      USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
  *
  * int (*ndo_get_phys_port_id)(struct net_device *dev,
- *                             struct netdev_phys_port_id *ppid);
+ *                             struct netdev_phys_item_id *ppid);
  *      Called to get ID of physical port of this device. If driver does
  *      not implement this, it is assumed that the hw is not able to have
  *      multiple net devices on single physical port.
@@ -997,6 +1012,24 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *      Callback to use for xmit over the accelerated station. This
  *      is used in place of ndo_start_xmit on accelerated net
  *      devices.
+ * netdev_features_t (*ndo_features_check) (struct sk_buff *skb,
+ *                                          struct net_device *dev
+ *                                          netdev_features_t features);
+ *      Called by core transmit path to determine if device is capable of
+ *      performing offload operations on a given packet. This is to give
+ *      the device an opportunity to implement any restrictions that cannot
+ *      be otherwise expressed by feature flags. The check is called with
+ *      the set of features that the stack has calculated and it returns
+ *      those the driver believes to be appropriate.
+ *
+ * int (*ndo_switch_parent_id_get)(struct net_device *dev,
+ *                                 struct netdev_phys_item_id *psid);
+ *      Called to get an ID of the switch chip this port is part of.
+ *      If driver implements this, it indicates that it represents a port
+ *      of a switch chip.
+ * int (*ndo_switch_port_stp_update)(struct net_device *dev, u8 state);
+ *      Called to notify switch device port of bridge port STP
+ *      state change.
  */
 struct net_device_ops {
         int                     (*ndo_init)(struct net_device *dev);
@@ -1107,11 +1140,13 @@ struct net_device_ops {
                                                struct nlattr *tb[],
                                                struct net_device *dev,
                                                const unsigned char *addr,
+                                               u16 vid,
                                                u16 flags);
         int                     (*ndo_fdb_del)(struct ndmsg *ndm,
                                                struct nlattr *tb[],
                                                struct net_device *dev,
-                                               const unsigned char *addr);
+                                               const unsigned char *addr,
+                                               u16 vid);
         int                     (*ndo_fdb_dump)(struct sk_buff *skb,
                                                 struct netlink_callback *cb,
                                                 struct net_device *dev,
@@ -1129,7 +1164,7 @@ struct net_device_ops {
         int                     (*ndo_change_carrier)(struct net_device *dev,
                                                       bool new_carrier);
         int                     (*ndo_get_phys_port_id)(struct net_device *dev,
-                                                        struct netdev_phys_port_id *ppid);
+                                                        struct netdev_phys_item_id *ppid);
         void                    (*ndo_add_vxlan_port)(struct  net_device *dev,
                                                       sa_family_t sa_family,
                                                       __be16 port);
@@ -1146,6 +1181,15 @@ struct net_device_ops {
                                                         struct net_device *dev,
                                                         void *priv);
         int                     (*ndo_get_lock_subclass)(struct net_device *dev);
+        netdev_features_t       (*ndo_features_check) (struct sk_buff *skb,
+                                                       struct net_device *dev,
+                                                       netdev_features_t features);
+#ifdef CONFIG_NET_SWITCHDEV
+        int                     (*ndo_switch_parent_id_get)(struct net_device *dev,
+                                                            struct netdev_phys_item_id *psid);
+        int                     (*ndo_switch_port_stp_update)(struct net_device *dev,
+                                                              u8 state);
+#endif
 };
 
 /**
@@ -1206,6 +1250,9 @@ enum netdev_priv_flags {
         IFF_SUPP_NOFCS                  = 1<<19,
         IFF_LIVE_ADDR_CHANGE            = 1<<20,
         IFF_MACVLAN                     = 1<<21,
+        IFF_XMIT_DST_RELEASE_PERM       = 1<<22,
+        IFF_IPVLAN_MASTER               = 1<<23,
+        IFF_IPVLAN_SLAVE                = 1<<24,
 };
 
 #define IFF_802_1Q_VLAN                 IFF_802_1Q_VLAN
@@ -1230,6 +1277,9 @@ enum netdev_priv_flags {
 #define IFF_SUPP_NOFCS                  IFF_SUPP_NOFCS
 #define IFF_LIVE_ADDR_CHANGE            IFF_LIVE_ADDR_CHANGE
 #define IFF_MACVLAN                     IFF_MACVLAN
+#define IFF_XMIT_DST_RELEASE_PERM       IFF_XMIT_DST_RELEASE_PERM
+#define IFF_IPVLAN_MASTER               IFF_IPVLAN_MASTER
+#define IFF_IPVLAN_SLAVE                IFF_IPVLAN_SLAVE
 
 /**
  *      struct net_device - The DEVICE structure.
@@ -1416,6 +1466,8 @@ enum netdev_priv_flags {
  *      @gso_max_size:  Maximum size of generic segmentation offload
  *      @gso_max_segs:  Maximum number of segments that can be passed to the
  *                      NIC for GSO
+ *      @gso_min_segs:  Minimum number of segments that can be passed to the
+ *                      NIC for GSO
  *
  *      @dcbnl_ops:     Data Center Bridging netlink ops
  *      @num_tc:        Number of traffic classes in the net device
@@ -1559,6 +1611,7 @@ struct net_device {
         struct inet6_dev __rcu  *ip6_ptr;
         void                    *ax25_ptr;
         struct wireless_dev     *ieee80211_ptr;
+        struct wpan_dev         *ieee802154_ptr;
 
 /*
  * Cache lines mostly used on receive path (including eth_type_trans())
@@ -1577,6 +1630,7 @@ struct net_device {
 
 #endif
 
+        unsigned long           gro_flush_timeout;
         rx_handler_func_t __rcu *rx_handler;
         void __rcu              *rx_handler_data;
 
@@ -1666,7 +1720,7 @@ struct net_device {
         unsigned int            gso_max_size;
 #define GSO_MAX_SEGS            65535
         u16                     gso_max_segs;
-
+        u16                     gso_min_segs;
 #ifdef CONFIG_DCB
         const struct dcbnl_rtnl_ops *dcbnl_ops;
 #endif
@@ -1747,6 +1801,12 @@ struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
         return &dev->_tx[index];
 }
 
+static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
+                                                    const struct sk_buff *skb)
+{
+        return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
+}
+
 static inline void netdev_for_each_tx_queue(struct net_device *dev,
                                             void (*f)(struct net_device *,
                                                       struct netdev_queue *,
@@ -1781,24 +1841,13 @@ void dev_net_set(struct net_device *dev, struct net *net)
 #endif
 }
 
-static inline bool netdev_uses_dsa_tags(struct net_device *dev)
-{
-#ifdef CONFIG_NET_DSA_TAG_DSA
-        if (dev->dsa_ptr != NULL)
-                return dsa_uses_dsa_tags(dev->dsa_ptr);
-#endif
-
-        return 0;
-}
-
-static inline bool netdev_uses_trailer_tags(struct net_device *dev)
+static inline bool netdev_uses_dsa(struct net_device *dev)
 {
-#ifdef CONFIG_NET_DSA_TAG_TRAILER
+#if IS_ENABLED(CONFIG_NET_DSA)
         if (dev->dsa_ptr != NULL)
-                return dsa_uses_trailer_tags(dev->dsa_ptr);
+                return dsa_uses_tagged_protocol(dev->dsa_ptr);
 #endif
-
-        return 0;
+        return false;
 }
 
 /**
@@ -1879,11 +1928,20 @@ struct napi_gro_cb {
         /* jiffies when first packet was created/queued */
         unsigned long age;
 
-        /* Used in ipv6_gro_receive() */
+        /* Used in ipv6_gro_receive() and foo-over-udp */
         u16     proto;
 
         /* Used in udp_gro_receive */
-        u16     udp_mark;
+        u8      udp_mark:1;
+
+        /* GRO checksum is valid */
+        u8      csum_valid:1;
+
+        /* Number of checksums via CHECKSUM_UNNECESSARY */
+        u8      csum_cnt:3;
+
+        /* Used in foo-over-udp, set in udp[46]_gro_receive */
+        u8      is_ipv6:1;
 
         /* used to support CHECKSUM_COMPLETE for tunneling protocols */
         __wsum  csum;
@@ -1910,7 +1968,6 @@ struct packet_type {
 struct offload_callbacks {
         struct sk_buff          *(*gso_segment)(struct sk_buff *skb,
                                                 netdev_features_t features);
-        int                     (*gso_send_check)(struct sk_buff *skb);
         struct sk_buff          **(*gro_receive)(struct sk_buff **head,
                                                struct sk_buff *skb);
         int                     (*gro_complete)(struct sk_buff *skb, int nhoff);
@@ -1924,6 +1981,7 @@ struct packet_offload {
 
 struct udp_offload {
         __be16                   port;
+        u8                       ipproto;
         struct offload_callbacks callbacks;
 };
 
@@ -1982,6 +2040,7 @@ struct pcpu_sw_netstats {
 #define NETDEV_CHANGEUPPER      0x0015
 #define NETDEV_RESEND_IGMP      0x0016
 #define NETDEV_PRECHANGEMTU     0x0017 /* notify before mtu change happened */
+#define NETDEV_CHANGEINFODATA   0x0018
 
 int register_netdevice_notifier(struct notifier_block *nb);
 int unregister_netdevice_notifier(struct notifier_block *nb);
@@ -2074,8 +2133,8 @@ void __dev_remove_pack(struct packet_type *pt);
 void dev_add_offload(struct packet_offload *po);
 void dev_remove_offload(struct packet_offload *po);
 
-struct net_device *dev_get_by_flags_rcu(struct net *net, unsigned short flags,
-                                        unsigned short mask);
+struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
+                                      unsigned short mask);
 struct net_device *dev_get_by_name(struct net *net, const char *name);
 struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
 struct net_device *__dev_get_by_name(struct net *net, const char *name);
@@ -2153,11 +2212,97 @@ static inline void *skb_gro_network_header(struct sk_buff *skb)
 static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
                                         const void *start, unsigned int len)
 {
-        if (skb->ip_summed == CHECKSUM_COMPLETE)
+        if (NAPI_GRO_CB(skb)->csum_valid)
                 NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
                                                   csum_partial(start, len, 0));
 }
 
+/* GRO checksum functions. These are logical equivalents of the normal
+ * checksum functions (in skbuff.h) except that they operate on the GRO
+ * offsets and fields in sk_buff.
+ */
+
+__sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
+
+static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
+                                                      bool zero_okay,
+                                                      __sum16 check)
+{
+        return (skb->ip_summed != CHECKSUM_PARTIAL &&
+                NAPI_GRO_CB(skb)->csum_cnt == 0 &&
+                (!zero_okay || check));
+}
+
+static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
+                                                           __wsum psum)
+{
+        if (NAPI_GRO_CB(skb)->csum_valid &&
+            !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
+                return 0;
+
+        NAPI_GRO_CB(skb)->csum = psum;
+
+        return __skb_gro_checksum_complete(skb);
+}
+
+static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
+{
+        if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
+                /* Consume a checksum from CHECKSUM_UNNECESSARY */
+                NAPI_GRO_CB(skb)->csum_cnt--;
+        } else {
+                /* Update skb for CHECKSUM_UNNECESSARY and csum_level when we
+                 * verified a new top level checksum or an encapsulated one
+                 * during GRO. This saves work if we fallback to normal path.
+                 */
+                __skb_incr_checksum_unnecessary(skb);
+        }
+}
+
+#define __skb_gro_checksum_validate(skb, proto, zero_okay, check,       \
+                                    compute_pseudo)                     \
+({                                                                      \
+        __sum16 __ret = 0;                                              \
+        if (__skb_gro_checksum_validate_needed(skb, zero_okay, check))  \
+                __ret = __skb_gro_checksum_validate_complete(skb,       \
+                                compute_pseudo(skb, proto));            \
+        if (__ret)                                                      \
+                __skb_mark_checksum_bad(skb);                           \
+        else                                                            \
+                skb_gro_incr_csum_unnecessary(skb);                     \
+        __ret;                                                          \
+})
+
+#define skb_gro_checksum_validate(skb, proto, compute_pseudo)           \
+        __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
+
+#define skb_gro_checksum_validate_zero_check(skb, proto, check,         \
+                                             compute_pseudo)            \
+        __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
+
+#define skb_gro_checksum_simple_validate(skb)                           \
+        __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
+
+static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
+{
+        return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
+                !NAPI_GRO_CB(skb)->csum_valid);
+}
+
+static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
+                                              __sum16 check, __wsum pseudo)
+{
+        NAPI_GRO_CB(skb)->csum = ~pseudo;
+        NAPI_GRO_CB(skb)->csum_valid = 1;
+}
+
+#define skb_gro_checksum_try_convert(skb, proto, check, compute_pseudo) \
+do {                                                                    \
+        if (__skb_gro_checksum_convert_check(skb))                      \
+                __skb_gro_checksum_convert(skb, check,                  \
+                                           compute_pseudo(skb, proto)); \
+} while (0)
+
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
                                   unsigned short type,
                                   const void *daddr, const void *saddr,
@@ -2212,10 +2357,7 @@ extern int netdev_flow_limit_table_len;
  * Incoming packets are placed on per-cpu queues
  */
 struct softnet_data {
-        struct Qdisc            *output_queue;
-        struct Qdisc            **output_queue_tailp;
         struct list_head        poll_list;
-        struct sk_buff          *completion_queue;
         struct sk_buff_head     process_queue;
 
         /* stats */
@@ -2223,10 +2365,17 @@ struct softnet_data {
         unsigned int            time_squeeze;
         unsigned int            cpu_collision;
         unsigned int            received_rps;
-
 #ifdef CONFIG_RPS
         struct softnet_data     *rps_ipi_list;
+#endif
+#ifdef CONFIG_NET_FLOW_LIMIT
+        struct sd_flow_limit __rcu *flow_limit;
+#endif
+        struct Qdisc            *output_queue;
+        struct Qdisc            **output_queue_tailp;
+        struct sk_buff          *completion_queue;
 
+#ifdef CONFIG_RPS
         /* Elements below can be accessed between CPUs for RPS */
         struct call_single_data csd ____cacheline_aligned_in_smp;
         struct softnet_data     *rps_ipi_next;
@@ -2238,9 +2387,6 @@ struct softnet_data {
         struct sk_buff_head     input_pkt_queue;
         struct napi_struct      backlog;
 
-#ifdef CONFIG_NET_FLOW_LIMIT
-        struct sd_flow_limit __rcu *flow_limit;
-#endif
 };
 
 static inline void input_queue_head_incr(struct softnet_data *sd)
@@ -2261,12 +2407,7 @@ static inline void input_queue_tail_incr_save(struct softnet_data *sd,
 DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
 
 void __netif_schedule(struct Qdisc *q);
-
-static inline void netif_schedule_queue(struct netdev_queue *txq)
-{
-        if (!(txq->state & QUEUE_STATE_ANY_XOFF))
-                __netif_schedule(txq->qdisc);
-}
+void netif_schedule_queue(struct netdev_queue *txq);
 
 static inline void netif_tx_schedule_all(struct net_device *dev)
 {
@@ -2302,11 +2443,7 @@ static inline void netif_tx_start_all_queues(struct net_device *dev)
         }
 }
 
-static inline void netif_tx_wake_queue(struct netdev_queue *dev_queue)
-{
-        if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state))
-                __netif_schedule(dev_queue->qdisc);
-}
+void netif_tx_wake_queue(struct netdev_queue *dev_queue);
 
 /**
  *      netif_wake_queue - restart transmit
@@ -2394,6 +2531,34 @@ netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
         return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
 }
 
+/**
+ *      netdev_txq_bql_enqueue_prefetchw - prefetch bql data for write
+ *      @dev_queue: pointer to transmit queue
+ *
+ * BQL enabled drivers might use this helper in their ndo_start_xmit(),
+ * to give appropriate hint to the cpu.
+ */
+static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
+{
+#ifdef CONFIG_BQL
+        prefetchw(&dev_queue->dql.num_queued);
+#endif
+}
+
+/**
+ *      netdev_txq_bql_complete_prefetchw - prefetch bql data for write
+ *      @dev_queue: pointer to transmit queue
+ *
+ * BQL enabled drivers might use this helper in their TX completion path,
+ * to give appropriate hint to the cpu.
+ */
+static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
+{
+#ifdef CONFIG_BQL
+        prefetchw(&dev_queue->dql.limit);
+#endif
+}
+
 static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
                                         unsigned int bytes)
 {
@@ -2578,19 +2743,7 @@ static inline bool netif_subqueue_stopped(const struct net_device *dev,
         return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
 }
 
-/**
- *      netif_wake_subqueue - allow sending packets on subqueue
- *      @dev: network device
- *      @queue_index: sub queue index
- *
- * Resume individual transmit queue of a device with multiple transmit queues.
- */
-static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
-{
-        struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
-        if (test_and_clear_bit(__QUEUE_STATE_DRV_XOFF, &txq->state))
-                __netif_schedule(txq->qdisc);
-}
+void netif_wake_subqueue(struct net_device *dev, u16 queue_index);
 
 #ifdef CONFIG_XPS
 int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
@@ -2637,23 +2790,6 @@ static inline int netif_set_real_num_rx_queues(struct net_device *dev,
 }
 #endif
 
-static inline int netif_copy_real_num_queues(struct net_device *to_dev,
-                                             const struct net_device *from_dev)
-{
-        int err;
-
-        err = netif_set_real_num_tx_queues(to_dev,
-                                           from_dev->real_num_tx_queues);
-        if (err)
-                return err;
-#ifdef CONFIG_SYSFS
-        return netif_set_real_num_rx_queues(to_dev,
-                                            from_dev->real_num_rx_queues);
-#else
-        return 0;
-#endif
-}
-
 #ifdef CONFIG_SYSFS
 static inline unsigned int get_netdev_rx_queue_index(
                 struct netdev_rx_queue *queue)
@@ -2753,9 +2889,10 @@ void dev_set_group(struct net_device *, int);
 int dev_set_mac_address(struct net_device *, struct sockaddr *);
 int dev_change_carrier(struct net_device *, bool new_carrier);
 int dev_get_phys_port_id(struct net_device *dev,
-                         struct netdev_phys_port_id *ppid);
-int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
-                        struct netdev_queue *txq);
+                         struct netdev_phys_item_id *ppid);
+struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev);
+struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
+                                    struct netdev_queue *txq, int *ret);
 int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
 bool is_skb_forwardable(struct net_device *dev, struct sk_buff *skb);
@@ -3313,6 +3450,12 @@ void netdev_upper_dev_unlink(struct net_device *dev,
 void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
 void *netdev_lower_dev_get_private(struct net_device *dev,
                                    struct net_device *lower_dev);
+
+/* RSS keys are 40 or 52 bytes long */
+#define NETDEV_RSS_KEY_LEN 52
+extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN];
+void netdev_rss_key_fill(void *buffer, size_t len);
+
 int dev_get_nest_level(struct net_device *dev,
                        bool (*type_check)(struct net_device *dev));
 int skb_checksum_help(struct sk_buff *skb);
@@ -3357,6 +3500,27 @@ int __init dev_proc_init(void);
 #define dev_proc_init() 0
 #endif
 
+static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
+                                              struct sk_buff *skb, struct net_device *dev,
+                                              bool more)
+{
+        skb->xmit_more = more ? 1 : 0;
+        return ops->ndo_start_xmit(skb, dev);
+}
+
+static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
+                                            struct netdev_queue *txq, bool more)
+{
+        const struct net_device_ops *ops = dev->netdev_ops;
+        int rc;
+
+        rc = __netdev_start_xmit(ops, skb, dev, more);
+        if (rc == NETDEV_TX_OK)
+                txq_trans_update(txq);
+
+        return rc;
+}
+
 int netdev_class_create_file_ns(struct class_attribute *class_attr,
                                 const void *ns);
 void netdev_class_remove_file_ns(struct class_attribute *class_attr,
@@ -3436,7 +3600,7 @@ static inline bool net_gso_ok(netdev_features_t features, int gso_type)
         BUILD_BUG_ON(SKB_GSO_SIT     != (NETIF_F_GSO_SIT >> NETIF_F_GSO_SHIFT));
         BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
         BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
-        BUILD_BUG_ON(SKB_GSO_MPLS    != (NETIF_F_GSO_MPLS >> NETIF_F_GSO_SHIFT));
+        BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
 
         return (features & feature) == feature;
 }
@@ -3447,7 +3611,7 @@ static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
                (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
 }
 
-static inline bool netif_needs_gso(struct sk_buff *skb,
+static inline bool netif_needs_gso(struct net_device *dev, struct sk_buff *skb,
                                    netdev_features_t features)
 {
         return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
@@ -3479,6 +3643,21 @@ static inline bool netif_is_macvlan(struct net_device *dev)
         return dev->priv_flags & IFF_MACVLAN;
 }
 
+static inline bool netif_is_macvlan_port(struct net_device *dev)
+{
+        return dev->priv_flags & IFF_MACVLAN_PORT;
+}
+
+static inline bool netif_is_ipvlan(struct net_device *dev)
+{
+        return dev->priv_flags & IFF_IPVLAN_SLAVE;
+}
+
+static inline bool netif_is_ipvlan_port(struct net_device *dev)
+{
+        return dev->priv_flags & IFF_IPVLAN_MASTER;
+}
+
 static inline bool netif_is_bond_master(struct net_device *dev)
 {
         return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
@@ -3494,6 +3673,12 @@ static inline bool netif_supports_nofcs(struct net_device *dev)
         return dev->priv_flags & IFF_SUPP_NOFCS;
 }
 
+/* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
+static inline void netif_keep_dst(struct net_device *dev)
+{
+        dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
+}
+
 extern struct pernet_operations __net_initdata loopback_net_ops;
 
 /* Logging, debugging and troubleshooting/diagnostic helpers. */
@@ -3523,22 +3708,22 @@ static inline const char *netdev_reg_state(const struct net_device *dev)
 }
 
 __printf(3, 4)
-int netdev_printk(const char *level, const struct net_device *dev,
-                  const char *format, ...);
+void netdev_printk(const char *level, const struct net_device *dev,
+                   const char *format, ...);
 __printf(2, 3)
-int netdev_emerg(const struct net_device *dev, const char *format, ...);
+void netdev_emerg(const struct net_device *dev, const char *format, ...);
 __printf(2, 3)
-int netdev_alert(const struct net_device *dev, const char *format, ...);
+void netdev_alert(const struct net_device *dev, const char *format, ...);
 __printf(2, 3)
-int netdev_crit(const struct net_device *dev, const char *format, ...);
+void netdev_crit(const struct net_device *dev, const char *format, ...);
 __printf(2, 3)
-int netdev_err(const struct net_device *dev, const char *format, ...);
+void netdev_err(const struct net_device *dev, const char *format, ...);
 __printf(2, 3)
-int netdev_warn(const struct net_device *dev, const char *format, ...);
+void netdev_warn(const struct net_device *dev, const char *format, ...);
 __printf(2, 3)
-int netdev_notice(const struct net_device *dev, const char *format, ...);
+void netdev_notice(const struct net_device *dev, const char *format, ...);
 __printf(2, 3)
-int netdev_info(const struct net_device *dev, const char *format, ...);
+void netdev_info(const struct net_device *dev, const char *format, ...);
 
 #define MODULE_ALIAS_NETDEV(device) \
         MODULE_ALIAS("netdev-" device)
@@ -3556,7 +3741,6 @@ do {								\
 ({                                                              \
         if (0)                                                  \
                 netdev_printk(KERN_DEBUG, __dev, format, ##args); \
-        0;                                                      \
 })
 #endif
 
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
index 96afc29184be..f1606fa6132d 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -57,6 +57,8 @@ enum ip_set_extension {
         IPSET_EXT_COUNTER = (1 << IPSET_EXT_BIT_COUNTER),
         IPSET_EXT_BIT_COMMENT = 2,
         IPSET_EXT_COMMENT = (1 << IPSET_EXT_BIT_COMMENT),
+        IPSET_EXT_BIT_SKBINFO = 3,
+        IPSET_EXT_SKBINFO = (1 << IPSET_EXT_BIT_SKBINFO),
         /* Mark set with an extension which needs to call destroy */
         IPSET_EXT_BIT_DESTROY = 7,
         IPSET_EXT_DESTROY = (1 << IPSET_EXT_BIT_DESTROY),
@@ -65,12 +67,14 @@ enum ip_set_extension {
 #define SET_WITH_TIMEOUT(s)     ((s)->extensions & IPSET_EXT_TIMEOUT)
 #define SET_WITH_COUNTER(s)     ((s)->extensions & IPSET_EXT_COUNTER)
 #define SET_WITH_COMMENT(s)     ((s)->extensions & IPSET_EXT_COMMENT)
+#define SET_WITH_SKBINFO(s)     ((s)->extensions & IPSET_EXT_SKBINFO)
 #define SET_WITH_FORCEADD(s)    ((s)->flags & IPSET_CREATE_FLAG_FORCEADD)
 
 /* Extension id, in size order */
 enum ip_set_ext_id {
         IPSET_EXT_ID_COUNTER = 0,
         IPSET_EXT_ID_TIMEOUT,
+        IPSET_EXT_ID_SKBINFO,
         IPSET_EXT_ID_COMMENT,
         IPSET_EXT_ID_MAX,
 };
@@ -92,6 +96,10 @@ struct ip_set_ext {
         u64 packets;
         u64 bytes;
         u32 timeout;
+        u32 skbmark;
+        u32 skbmarkmask;
+        u32 skbprio;
+        u16 skbqueue;
         char *comment;
 };
 
@@ -104,6 +112,13 @@ struct ip_set_comment {
         char *str;
 };
 
+struct ip_set_skbinfo {
+        u32 skbmark;
+        u32 skbmarkmask;
+        u32 skbprio;
+        u16 skbqueue;
+};
+
 struct ip_set;
 
 #define ext_timeout(e, s)       \
@@ -112,7 +127,8 @@ struct ip_set;
 (struct ip_set_counter *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_COUNTER])
 #define ext_comment(e, s)       \
 (struct ip_set_comment *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_COMMENT])
-
+#define ext_skbinfo(e, s)       \
+(struct ip_set_skbinfo *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_SKBINFO])
 
 typedef int (*ipset_adtfn)(struct ip_set *set, void *value,
                            const struct ip_set_ext *ext,
@@ -256,6 +272,8 @@ ip_set_put_flags(struct sk_buff *skb, struct ip_set *set)
                 cadt_flags |= IPSET_FLAG_WITH_COUNTERS;
         if (SET_WITH_COMMENT(set))
                 cadt_flags |= IPSET_FLAG_WITH_COMMENT;
+        if (SET_WITH_SKBINFO(set))
+                cadt_flags |= IPSET_FLAG_WITH_SKBINFO;
         if (SET_WITH_FORCEADD(set))
                 cadt_flags |= IPSET_FLAG_WITH_FORCEADD;
 
@@ -304,6 +322,43 @@ ip_set_update_counter(struct ip_set_counter *counter,
         }
 }
 
+static inline void
+ip_set_get_skbinfo(struct ip_set_skbinfo *skbinfo,
+                      const struct ip_set_ext *ext,
+                      struct ip_set_ext *mext, u32 flags)
+{
+                mext->skbmark = skbinfo->skbmark;
+                mext->skbmarkmask = skbinfo->skbmarkmask;
+                mext->skbprio = skbinfo->skbprio;
+                mext->skbqueue = skbinfo->skbqueue;
+}
+static inline bool
+ip_set_put_skbinfo(struct sk_buff *skb, struct ip_set_skbinfo *skbinfo)
+{
+        /* Send nonzero parameters only */
+        return ((skbinfo->skbmark || skbinfo->skbmarkmask) &&
+                nla_put_net64(skb, IPSET_ATTR_SKBMARK,
+                              cpu_to_be64((u64)skbinfo->skbmark << 32 |
+                                          skbinfo->skbmarkmask))) ||
+               (skbinfo->skbprio &&
+                nla_put_net32(skb, IPSET_ATTR_SKBPRIO,
+                              cpu_to_be32(skbinfo->skbprio))) ||
+               (skbinfo->skbqueue &&
+                nla_put_net16(skb, IPSET_ATTR_SKBQUEUE,
+                             cpu_to_be16(skbinfo->skbqueue)));
+
+}
+
+static inline void
+ip_set_init_skbinfo(struct ip_set_skbinfo *skbinfo,
+                    const struct ip_set_ext *ext)
+{
+        skbinfo->skbmark = ext->skbmark;
+        skbinfo->skbmarkmask = ext->skbmarkmask;
+        skbinfo->skbprio = ext->skbprio;
+        skbinfo->skbqueue = ext->skbqueue;
+}
+
 static inline bool
 ip_set_put_counter(struct sk_buff *skb, struct ip_set_counter *counter)
 {
@@ -497,6 +552,9 @@ ip_set_put_extensions(struct sk_buff *skb, const struct ip_set *set,
         if (SET_WITH_COMMENT(set) &&
             ip_set_put_comment(skb, ext_comment(e, set)))
                 return -EMSGSIZE;
+        if (SET_WITH_SKBINFO(set) &&
+            ip_set_put_skbinfo(skb, ext_skbinfo(e, set)))
+                return -EMSGSIZE;
         return 0;
 }
 
diff --git a/include/linux/netfilter/ipset/ip_set_list.h b/include/linux/netfilter/ipset/ip_set_list.h
index 68c2aea897f5..fe2622a00151 100644
--- a/include/linux/netfilter/ipset/ip_set_list.h
+++ b/include/linux/netfilter/ipset/ip_set_list.h
@@ -6,5 +6,6 @@
 
 #define IP_SET_LIST_DEFAULT_SIZE        8
 #define IP_SET_LIST_MIN_SIZE            4
+#define IP_SET_LIST_MAX_SIZE            65536
 
 #endif /* __IP_SET_LIST_H */
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
index 8ab1c278b66d..c755e4971fa3 100644
--- a/include/linux/netfilter_bridge.h
+++ b/include/linux/netfilter_bridge.h
@@ -15,7 +15,7 @@ enum nf_br_hook_priorities {
         NF_BR_PRI_LAST = INT_MAX,
 };
 
-#ifdef CONFIG_BRIDGE_NETFILTER
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
 
 #define BRNF_PKT_TYPE                   0x01
 #define BRNF_BRIDGED_DNAT               0x02
@@ -24,16 +24,6 @@ enum nf_br_hook_priorities {
 #define BRNF_8021Q                      0x10
 #define BRNF_PPPoE                      0x20
 
-/* Only used in br_forward.c */
-int nf_bridge_copy_header(struct sk_buff *skb);
-static inline int nf_bridge_maybe_copy_header(struct sk_buff *skb)
-{
-        if (skb->nf_bridge &&
-            skb->nf_bridge->mask & (BRNF_BRIDGED | BRNF_BRIDGED_DNAT))
-                return nf_bridge_copy_header(skb);
-        return 0;
-}
-
 static inline unsigned int nf_bridge_encap_header_len(const struct sk_buff *skb)
 {
         switch (skb->protocol) {
@@ -46,6 +36,44 @@ static inline unsigned int nf_bridge_encap_header_len(const struct sk_buff *skb)
         }
 }
 
+static inline void nf_bridge_update_protocol(struct sk_buff *skb)
+{
+        if (skb->nf_bridge->mask & BRNF_8021Q)
+                skb->protocol = htons(ETH_P_8021Q);
+        else if (skb->nf_bridge->mask & BRNF_PPPoE)
+                skb->protocol = htons(ETH_P_PPP_SES);
+}
+
+/* Fill in the header for fragmented IP packets handled by
+ * the IPv4 connection tracking code.
+ *
+ * Only used in br_forward.c
+ */
+static inline int nf_bridge_copy_header(struct sk_buff *skb)
+{
+        int err;
+        unsigned int header_size;
+
+        nf_bridge_update_protocol(skb);
+        header_size = ETH_HLEN + nf_bridge_encap_header_len(skb);
+        err = skb_cow_head(skb, header_size);
+        if (err)
+                return err;
+
+        skb_copy_to_linear_data_offset(skb, -header_size,
+                                       skb->nf_bridge->data, header_size);
+        __skb_push(skb, nf_bridge_encap_header_len(skb));
+        return 0;
+}
+
+static inline int nf_bridge_maybe_copy_header(struct sk_buff *skb)
+{
+        if (skb->nf_bridge &&
+            skb->nf_bridge->mask & (BRNF_BRIDGED | BRNF_BRIDGED_DNAT))
+                return nf_bridge_copy_header(skb);
+        return 0;
+}
+
 static inline unsigned int nf_bridge_mtu_reduction(const struct sk_buff *skb)
 {
         if (unlikely(skb->nf_bridge->mask & BRNF_PPPoE))
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 9e572daa15d5..02fc86d2348e 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -46,8 +46,8 @@ struct netlink_kernel_cfg {
         unsigned int    flags;
         void            (*input)(struct sk_buff *skb);
         struct mutex    *cb_mutex;
-        int             (*bind)(int group);
-        void            (*unbind)(int group);
+        int             (*bind)(struct net *net, int group);
+        void            (*unbind)(struct net *net, int group);
         bool            (*compare)(struct net *net, struct sock *sk);
 };
 
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index a1e3064a8d99..022b761dbf0a 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -110,6 +110,20 @@ enum nfs_opnum4 {
         OP_DESTROY_CLIENTID = 57,
         OP_RECLAIM_COMPLETE = 58,
 
+        /* nfs42 */
+        OP_ALLOCATE = 59,
+        OP_COPY = 60,
+        OP_COPY_NOTIFY = 61,
+        OP_DEALLOCATE = 62,
+        OP_IO_ADVISE = 63,
+        OP_LAYOUTERROR = 64,
+        OP_LAYOUTSTATS = 65,
+        OP_OFFLOAD_CANCEL = 66,
+        OP_OFFLOAD_STATUS = 67,
+        OP_READ_PLUS = 68,
+        OP_SEEK = 69,
+        OP_WRITE_SAME = 70,
+
         OP_ILLEGAL = 10044,
 };
 
@@ -117,10 +131,10 @@ enum nfs_opnum4 {
 Needs to be updated if more operations are defined in future.*/
 
 #define FIRST_NFS4_OP   OP_ACCESS
-#define LAST_NFS4_OP    OP_RECLAIM_COMPLETE
+#define LAST_NFS4_OP    OP_WRITE_SAME
 #define LAST_NFS40_OP   OP_RELEASE_LOCKOWNER
 #define LAST_NFS41_OP   OP_RECLAIM_COMPLETE
-#define LAST_NFS42_OP   OP_RECLAIM_COMPLETE
+#define LAST_NFS42_OP   OP_WRITE_SAME
 
 enum nfsstat4 {
         NFS4_OK = 0,
@@ -235,10 +249,11 @@ enum nfsstat4 {
         /* nfs42 */
         NFS4ERR_PARTNER_NOTSUPP = 10088,
         NFS4ERR_PARTNER_NO_AUTH = 10089,
-        NFS4ERR_METADATA_NOTSUPP = 10090,
+        NFS4ERR_UNION_NOTSUPP = 10090,
         NFS4ERR_OFFLOAD_DENIED = 10091,
         NFS4ERR_WRONG_LFS = 10092,
         NFS4ERR_BADLABEL = 10093,
+        NFS4ERR_OFFLOAD_NO_REQS = 10094,
 };
 
 static inline bool seqid_mutating_err(u32 err)
@@ -472,6 +487,11 @@ enum {
         NFSPROC4_CLNT_GETDEVICELIST,
         NFSPROC4_CLNT_BIND_CONN_TO_SESSION,
         NFSPROC4_CLNT_DESTROY_CLIENTID,
+
+        /* nfs42 */
+        NFSPROC4_CLNT_SEEK,
+        NFSPROC4_CLNT_ALLOCATE,
+        NFSPROC4_CLNT_DEALLOCATE,
 };
 
 /* nfs41 types */
@@ -535,4 +555,9 @@ struct nfs4_deviceid {
         char data[NFS4_DEVICEID4_SIZE];
 };
 
+enum data_content4 {
+        NFS4_CONTENT_DATA               = 0,
+        NFS4_CONTENT_HOLE               = 1,
+};
+
 #endif
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 5180a7ededec..6d627b92df53 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -163,7 +163,7 @@ struct nfs_inode {
          */
         __be32                  cookieverf[2];
 
-        unsigned long           npages;
+        unsigned long           nrequests;
         struct nfs_mds_commit_info commit_info;
 
         /* Open contexts for shared mmap writes */
@@ -443,31 +443,15 @@ static inline struct rpc_cred *nfs_file_cred(struct file *file)
 }
 
 /*
- * linux/fs/nfs/xattr.c
- */
-#ifdef CONFIG_NFS_V3_ACL
-extern ssize_t nfs3_listxattr(struct dentry *, char *, size_t);
-extern ssize_t nfs3_getxattr(struct dentry *, const char *, void *, size_t);
-extern int nfs3_setxattr(struct dentry *, const char *,
-                        const void *, size_t, int);
-extern int nfs3_removexattr (struct dentry *, const char *name);
-#else
-# define nfs3_listxattr NULL
-# define nfs3_getxattr NULL
-# define nfs3_setxattr NULL
-# define nfs3_removexattr NULL
-#endif
-
-/*
  * linux/fs/nfs/direct.c
  */
 extern ssize_t nfs_direct_IO(int, struct kiocb *, struct iov_iter *, loff_t);
 extern ssize_t nfs_file_direct_read(struct kiocb *iocb,
                         struct iov_iter *iter,
-                        loff_t pos, bool uio);
+                        loff_t pos);
 extern ssize_t nfs_file_direct_write(struct kiocb *iocb,
                         struct iov_iter *iter,
-                        loff_t pos, bool uio);
+                        loff_t pos);
 
 /*
  * linux/fs/nfs/dir.c
@@ -529,22 +513,14 @@ extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned
 extern int nfs_wb_all(struct inode *inode);
 extern int nfs_wb_page(struct inode *inode, struct page* page);
 extern int nfs_wb_page_cancel(struct inode *inode, struct page* page);
-#if IS_ENABLED(CONFIG_NFS_V3) || IS_ENABLED(CONFIG_NFS_V4)
 extern int  nfs_commit_inode(struct inode *, int);
 extern struct nfs_commit_data *nfs_commitdata_alloc(void);
 extern void nfs_commit_free(struct nfs_commit_data *data);
-#else
-static inline int
-nfs_commit_inode(struct inode *inode, int how)
-{
-        return 0;
-}
-#endif
 
 static inline int
 nfs_have_writebacks(struct inode *inode)
 {
-        return NFS_I(inode)->npages != 0;
+        return NFS_I(inode)->nrequests != 0;
 }
 
 /*
@@ -557,23 +533,6 @@ extern int  nfs_readpage_async(struct nfs_open_context *, struct inode *,
                                struct page *);
 
 /*
- * linux/fs/nfs3proc.c
- */
-#ifdef CONFIG_NFS_V3_ACL
-extern struct posix_acl *nfs3_get_acl(struct inode *inode, int type);
-extern int nfs3_set_acl(struct inode *inode, struct posix_acl *acl, int type);
-extern int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
-                struct posix_acl *dfacl);
-extern const struct xattr_handler *nfs3_xattr_handlers[];
-#else
-static inline int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
-                struct posix_acl *dfacl)
-{
-        return 0;
-}
-#endif /* CONFIG_NFS_V3_ACL */
-
-/*
  * inline functions
  */
 
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 922be2e050f5..1e37fbb78f7a 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -230,5 +230,8 @@ struct nfs_server {
 #define NFS_CAP_STATEID_NFSV41  (1U << 16)
 #define NFS_CAP_ATOMIC_OPEN_V1  (1U << 17)
 #define NFS_CAP_SECURITY_LABEL  (1U << 18)
+#define NFS_CAP_SEEK            (1U << 19)
+#define NFS_CAP_ALLOCATE        (1U << 20)
+#define NFS_CAP_DEALLOCATE      (1U << 21)
 
 #endif
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 0040629894df..467c84efb596 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -252,17 +252,6 @@ struct nfs4_layoutget {
         gfp_t gfp_flags;
 };
 
-struct nfs4_getdevicelist_args {
-        struct nfs4_sequence_args seq_args;
-        const struct nfs_fh *fh;
-        u32 layoutclass;
-};
-
-struct nfs4_getdevicelist_res {
-        struct nfs4_sequence_res seq_res;
-        struct pnfs_devicelist *devlist;
-};
-
 struct nfs4_getdeviceinfo_args {
         struct nfs4_sequence_args seq_args;
         struct pnfs_device *pdev;
@@ -279,6 +268,9 @@ struct nfs4_layoutcommit_args {
         __u64 lastbytewritten;
         struct inode *inode;
         const u32 *bitmask;
+        size_t layoutupdate_len;
+        struct page *layoutupdate_page;
+        struct page **layoutupdate_pages;
 };
 
 struct nfs4_layoutcommit_res {
@@ -1232,13 +1224,57 @@ struct nfs41_free_stateid_res {
         unsigned int                    status;
 };
 
+static inline void
+nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
+{
+        kfree(cinfo->buckets);
+}
+
 #else
 
 struct pnfs_ds_commit_info {
 };
 
+static inline void
+nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
+{
+}
+
 #endif /* CONFIG_NFS_V4_1 */
 
+#ifdef CONFIG_NFS_V4_2
+struct nfs42_falloc_args {
+        struct nfs4_sequence_args       seq_args;
+
+        struct nfs_fh                   *falloc_fh;
+        nfs4_stateid                     falloc_stateid;
+        u64                              falloc_offset;
+        u64                              falloc_length;
+};
+
+struct nfs42_falloc_res {
+        struct nfs4_sequence_res        seq_res;
+        unsigned int                    status;
+};
+
+struct nfs42_seek_args {
+        struct nfs4_sequence_args       seq_args;
+
+        struct nfs_fh                   *sa_fh;
+        nfs4_stateid                    sa_stateid;
+        u64                             sa_offset;
+        u32                             sa_what;
+};
+
+struct nfs42_seek_res {
+        struct nfs4_sequence_res        seq_res;
+        unsigned int                    status;
+
+        u32     sr_eof;
+        u64     sr_offset;
+};
+#endif
+
 struct nfs_page;
 
 #define NFS_PAGEVEC_SIZE        (8U)
@@ -1328,6 +1364,7 @@ struct nfs_commit_data {
         struct pnfs_layout_segment *lseg;
         struct nfs_client       *ds_clp;        /* pNFS data server */
         int                     ds_commit_index;
+        loff_t                  lwb;
         const struct rpc_call_ops *mds_ops;
         const struct nfs_commit_completion_ops *completion_ops;
         int (*commit_done_cb) (struct rpc_task *task, struct nfs_commit_data *data);
@@ -1346,6 +1383,7 @@ struct nfs_unlinkdata {
         struct inode *dir;
         struct rpc_cred *cred;
         struct nfs_fattr dir_attr;
+        long timeout;
 };
 
 struct nfs_renamedata {
@@ -1359,6 +1397,7 @@ struct nfs_renamedata {
         struct dentry           *new_dentry;
         struct nfs_fattr        new_fattr;
         void (*complete)(struct rpc_task *, struct nfs_renamedata *);
+        long timeout;
 };
 
 struct nfs_access_entry;
diff --git a/include/linux/nl802154.h b/include/linux/nl802154.h
index 20163b9a0eae..167342c2ce6b 100644
--- a/include/linux/nl802154.h
+++ b/include/linux/nl802154.h
@@ -12,10 +12,6 @@
  * 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 Street, Fifth Floor, Boston, MA 02110-1301 USA.
- *
  */
 
 #ifndef NL802154_H
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index 1d2a6ab6b8bb..9b2022ab4d85 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -24,6 +24,19 @@ static inline void touch_nmi_watchdog(void)
 }
 #endif
 
+#if defined(CONFIG_HARDLOCKUP_DETECTOR)
+extern void watchdog_enable_hardlockup_detector(bool val);
+extern bool watchdog_hardlockup_detector_is_enabled(void);
+#else
+static inline void watchdog_enable_hardlockup_detector(bool val)
+{
+}
+static inline bool watchdog_hardlockup_detector_is_enabled(void)
+{
+        return true;
+}
+#endif
+
 /*
  * Create trigger_all_cpu_backtrace() out of the arch-provided
  * base function. Return whether such support was available,
diff --git a/include/linux/ns_common.h b/include/linux/ns_common.h
new file mode 100644
index 000000000000..85a5c8c16be9
--- /dev/null
+++ b/include/linux/ns_common.h
@@ -0,0 +1,12 @@
+#ifndef _LINUX_NS_COMMON_H
+#define _LINUX_NS_COMMON_H
+
+struct proc_ns_operations;
+
+struct ns_common {
+        atomic_long_t stashed;
+        const struct proc_ns_operations *ops;
+        unsigned int inum;
+};
+
+#endif
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 2bf403195c09..258945fcabf1 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -19,6 +19,7 @@
 #include <linux/pci.h>
 #include <linux/miscdevice.h>
 #include <linux/kref.h>
+#include <linux/blk-mq.h>
 
 struct nvme_bar {
         __u64                   cap;    /* Controller Capabilities */
@@ -38,6 +39,7 @@ struct nvme_bar {
 #define NVME_CAP_TIMEOUT(cap)   (((cap) >> 24) & 0xff)
 #define NVME_CAP_STRIDE(cap)    (((cap) >> 32) & 0xf)
 #define NVME_CAP_MPSMIN(cap)    (((cap) >> 48) & 0xf)
+#define NVME_CAP_MPSMAX(cap)    (((cap) >> 52) & 0xf)
 
 enum {
         NVME_CC_ENABLE          = 1 << 0,
@@ -70,8 +72,10 @@ extern unsigned char nvme_io_timeout;
  */
 struct nvme_dev {
         struct list_head node;
-        struct nvme_queue __rcu **queues;
-        unsigned short __percpu *io_queue;
+        struct nvme_queue **queues;
+        struct request_queue *admin_q;
+        struct blk_mq_tag_set tagset;
+        struct blk_mq_tag_set admin_tagset;
         u32 __iomem *dbs;
         struct pci_dev *pci_dev;
         struct dma_pool *prp_page_pool;
@@ -90,15 +94,16 @@ struct nvme_dev {
         struct miscdevice miscdev;
         work_func_t reset_workfn;
         struct work_struct reset_work;
-        struct work_struct cpu_work;
         char name[12];
         char serial[20];
         char model[40];
         char firmware_rev[8];
         u32 max_hw_sectors;
         u32 stripe_size;
+        u32 page_size;
         u16 oncs;
         u16 abort_limit;
+        u8 event_limit;
         u8 vwc;
         u8 initialized;
 };
@@ -132,7 +137,6 @@ struct nvme_iod {
         int offset;             /* Of PRP list */
         int nents;              /* Used in scatterlist */
         int length;             /* Of data, in bytes */
-        unsigned long start_time;
         dma_addr_t first_dma;
         struct list_head node;
         struct scatterlist sg[0];
@@ -150,12 +154,14 @@ static inline u64 nvme_block_nr(struct nvme_ns *ns, sector_t sector)
  */
 void nvme_free_iod(struct nvme_dev *dev, struct nvme_iod *iod);
 
-int nvme_setup_prps(struct nvme_dev *, struct nvme_iod *, int , gfp_t);
+int nvme_setup_prps(struct nvme_dev *, struct nvme_iod *, int, gfp_t);
 struct nvme_iod *nvme_map_user_pages(struct nvme_dev *dev, int write,
                                 unsigned long addr, unsigned length);
 void nvme_unmap_user_pages(struct nvme_dev *dev, int write,
                         struct nvme_iod *iod);
-int nvme_submit_io_cmd(struct nvme_dev *, struct nvme_command *, u32 *);
+int nvme_submit_io_cmd(struct nvme_dev *, struct nvme_ns *,
+                                                struct nvme_command *, u32 *);
+int nvme_submit_flush_data(struct nvme_queue *nvmeq, struct nvme_ns *ns);
 int nvme_submit_admin_cmd(struct nvme_dev *, struct nvme_command *,
                                                         u32 *result);
 int nvme_identify(struct nvme_dev *, unsigned nsid, unsigned cns,
diff --git a/include/linux/of.h b/include/linux/of.h
index 6c4363b8ddc3..dfde07e77a63 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -23,6 +23,8 @@
 #include <linux/spinlock.h>
 #include <linux/topology.h>
 #include <linux/notifier.h>
+#include <linux/property.h>
+#include <linux/list.h>
 
 #include <asm/byteorder.h>
 #include <asm/errno.h>
@@ -49,14 +51,13 @@ struct device_node {
         const char *type;
         phandle phandle;
         const char *full_name;
+        struct fwnode_handle fwnode;
 
         struct  property *properties;
         struct  property *deadprops;    /* removed properties */
         struct  device_node *parent;
         struct  device_node *child;
         struct  device_node *sibling;
-        struct  device_node *next;      /* next device of same type */
-        struct  device_node *allnext;   /* next in list of all nodes */
         struct  kobject kobj;
         unsigned long _flags;
         void    *data;
@@ -74,11 +75,18 @@ struct of_phandle_args {
         uint32_t args[MAX_PHANDLE_ARGS];
 };
 
+struct of_reconfig_data {
+        struct device_node      *dn;
+        struct property         *prop;
+        struct property         *old_prop;
+};
+
 /* 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);
+        node->fwnode.type = FWNODE_OF;
 }
 
 /* true when node is initialized */
@@ -105,18 +113,27 @@ static inline struct device_node *of_node_get(struct device_node *node)
 static inline void of_node_put(struct device_node *node) { }
 #endif /* !CONFIG_OF_DYNAMIC */
 
-#ifdef CONFIG_OF
-
 /* Pointer for first entry in chain of all nodes. */
-extern struct device_node *of_allnodes;
+extern struct device_node *of_root;
 extern struct device_node *of_chosen;
 extern struct device_node *of_aliases;
 extern struct device_node *of_stdout;
 extern raw_spinlock_t devtree_lock;
 
+#ifdef CONFIG_OF
+static inline bool is_of_node(struct fwnode_handle *fwnode)
+{
+        return fwnode && fwnode->type == FWNODE_OF;
+}
+
+static inline struct device_node *of_node(struct fwnode_handle *fwnode)
+{
+        return fwnode ? container_of(fwnode, struct device_node, fwnode) : NULL;
+}
+
 static inline bool of_have_populated_dt(void)
 {
-        return of_allnodes != NULL;
+        return of_root != NULL;
 }
 
 static inline bool of_node_is_root(const struct device_node *node)
@@ -160,6 +177,7 @@ 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);
 extern struct device_node *of_find_all_nodes(struct device_node *prev);
 
 /*
@@ -215,8 +233,9 @@ 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)
+#define for_each_of_allnodes_from(from, dn) \
+        for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn))
+#define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn)
 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,
@@ -228,7 +247,13 @@ extern struct device_node *of_find_matching_node_and_match(
         const struct of_device_id *matches,
         const struct of_device_id **match);
 
-extern struct device_node *of_find_node_by_path(const char *path);
+extern struct device_node *of_find_node_opts_by_path(const char *path,
+        const char **opts);
+static inline struct device_node *of_find_node_by_path(const char *path)
+{
+        return of_find_node_opts_by_path(path, NULL);
+}
+
 extern struct device_node *of_find_node_by_phandle(phandle handle);
 extern struct device_node *of_get_parent(const struct device_node *node);
 extern struct device_node *of_get_next_parent(struct device_node *node);
@@ -263,21 +288,23 @@ extern int of_property_read_u32_array(const struct device_node *np,
                                       size_t sz);
 extern int of_property_read_u64(const struct device_node *np,
                                 const char *propname, u64 *out_value);
+extern int of_property_read_u64_array(const struct device_node *np,
+                                      const char *propname,
+                                      u64 *out_values,
+                                      size_t sz);
 
 extern int of_property_read_string(struct device_node *np,
                                    const char *propname,
                                    const char **out_string);
-extern int of_property_read_string_index(struct device_node *np,
-                                         const char *propname,
-                                         int index, const char **output);
 extern int of_property_match_string(struct device_node *np,
                                     const char *propname,
                                     const char *string);
-extern int of_property_count_strings(struct device_node *np,
-                                     const char *propname);
+extern int of_property_read_string_helper(struct device_node *np,
+                                              const char *propname,
+                                              const char **out_strs, size_t sz, int index);
 extern int of_device_is_compatible(const struct device_node *device,
                                    const char *);
-extern int of_device_is_available(const struct device_node *device);
+extern bool of_device_is_available(const struct device_node *device);
 extern const void *of_get_property(const struct device_node *node,
                                 const char *name,
                                 int *lenp);
@@ -319,16 +346,6 @@ extern int of_update_property(struct device_node *np, struct property *newprop);
 #define OF_RECONFIG_REMOVE_PROPERTY     0x0004
 #define OF_RECONFIG_UPDATE_PROPERTY     0x0005
 
-struct of_prop_reconfig {
-        struct device_node      *dn;
-        struct property         *prop;
-        struct property         *old_prop;
-};
-
-extern int of_reconfig_notifier_register(struct notifier_block *);
-extern int of_reconfig_notifier_unregister(struct notifier_block *);
-extern int of_reconfig_notify(unsigned long, void *);
-
 extern int of_attach_node(struct device_node *);
 extern int of_detach_node(struct device_node *);
 
@@ -357,6 +374,16 @@ bool of_console_check(struct device_node *dn, char *name, int index);
 
 #else /* CONFIG_OF */
 
+static inline bool is_of_node(struct fwnode_handle *fwnode)
+{
+        return false;
+}
+
+static inline struct device_node *of_node(struct fwnode_handle *fwnode)
+{
+        return NULL;
+}
+
 static inline const char* of_node_full_name(const struct device_node *np)
 {
         return "<no-node>";
@@ -387,6 +414,12 @@ static inline struct device_node *of_find_node_by_path(const char *path)
         return NULL;
 }
 
+static inline struct device_node *of_find_node_opts_by_path(const char *path,
+        const char **opts)
+{
+        return NULL;
+}
+
 static inline struct device_node *of_get_parent(const struct device_node *node)
 {
         return NULL;
@@ -428,9 +461,9 @@ static inline int of_device_is_compatible(const struct device_node *device,
         return 0;
 }
 
-static inline int of_device_is_available(const struct device_node *device)
+static inline bool of_device_is_available(const struct device_node *device)
 {
-        return 0;
+        return false;
 }
 
 static inline struct property *of_find_property(const struct device_node *np,
@@ -479,22 +512,23 @@ static inline int of_property_read_u32_array(const struct device_node *np,
         return -ENOSYS;
 }
 
-static inline int of_property_read_string(struct device_node *np,
-                                          const char *propname,
-                                          const char **out_string)
+static inline int of_property_read_u64_array(const struct device_node *np,
+                                             const char *propname,
+                                             u64 *out_values, size_t sz)
 {
         return -ENOSYS;
 }
 
-static inline int of_property_read_string_index(struct device_node *np,
-                                                const char *propname, int index,
-                                                const char **out_string)
+static inline int of_property_read_string(struct device_node *np,
+                                          const char *propname,
+                                          const char **out_string)
 {
         return -ENOSYS;
 }
 
-static inline int of_property_count_strings(struct device_node *np,
-                                            const char *propname)
+static inline int of_property_read_string_helper(struct device_node *np,
+                                                 const char *propname,
+                                                 const char **out_strs, size_t sz, int index)
 {
         return -ENOSYS;
 }
@@ -668,6 +702,70 @@ static inline int of_property_count_u64_elems(const struct device_node *np,
 }
 
 /**
+ * of_property_read_string_array() - Read an array of strings from a multiple
+ * strings property.
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @out_strs:   output array of string pointers.
+ * @sz:         number of array elements to read.
+ *
+ * Search for a property in a device tree node and retrieve a list of
+ * terminated string values (pointer to data, not a copy) in that property.
+ *
+ * If @out_strs is NULL, the number of strings in the property is returned.
+ */
+static inline int of_property_read_string_array(struct device_node *np,
+                                                const char *propname, const char **out_strs,
+                                                size_t sz)
+{
+        return of_property_read_string_helper(np, propname, out_strs, sz, 0);
+}
+
+/**
+ * of_property_count_strings() - Find and return the number of strings from a
+ * multiple strings 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 tree node and retrieve the number of null
+ * terminated string contain in it. Returns the number of strings on
+ * success, -EINVAL if the property does not exist, -ENODATA if property
+ * does not have a value, and -EILSEQ if the string is not null-terminated
+ * within the length of the property data.
+ */
+static inline int of_property_count_strings(struct device_node *np,
+                                            const char *propname)
+{
+        return of_property_read_string_helper(np, propname, NULL, 0, 0);
+}
+
+/**
+ * of_property_read_string_index() - Find and read a string from a multiple
+ * strings property.
+ * @np:         device node from which the property value is to be read.
+ * @propname:   name of the property to be searched.
+ * @index:      index of the string in the list of strings
+ * @out_string: pointer to null terminated return string, modified only if
+ *              return value is 0.
+ *
+ * Search for a property in a device tree node and retrieve a null
+ * terminated string value (pointer to data, not a copy) in the list of strings
+ * contained in that property.
+ * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
+ * property does not have a value, and -EILSEQ if the string is not
+ * null-terminated within the length of the property data.
+ *
+ * The out_string pointer is modified only if a valid string can be decoded.
+ */
+static inline int of_property_read_string_index(struct device_node *np,
+                                                const char *propname,
+                                                int index, const char **output)
+{
+        int rc = of_property_read_string_helper(np, propname, output, 1, index);
+        return rc < 0 ? rc : 0;
+}
+
+/**
  * 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.
@@ -704,6 +802,13 @@ static inline int of_property_read_u32(const struct device_node *np,
         return of_property_read_u32_array(np, propname, out_value, 1);
 }
 
+static inline int of_property_read_s32(const struct device_node *np,
+                                       const char *propname,
+                                       s32 *out_value)
+{
+        return of_property_read_u32(np, propname, (u32*) out_value);
+}
+
 #define of_property_for_each_u32(np, propname, prop, p, u)      \
         for (prop = of_find_property(np, propname, NULL),       \
                 p = of_prop_next_u32(prop, NULL, &u);           \
@@ -772,7 +877,7 @@ static inline int of_get_available_child_count(const struct device_node *np)
                  = { .compatible = compat,                              \
                      .data = (fn == (fn_type)NULL) ? fn : fn  }
 #else
-#define _OF_DECLARE(table, name, compat, fn, fn_type)                                   \
+#define _OF_DECLARE(table, name, compat, fn, fn_type)                   \
         static const struct of_device_id __of_table_##name              \
                 __attribute__((unused))                                 \
                  = { .compatible = compat,                              \
@@ -823,7 +928,19 @@ struct of_changeset {
         struct list_head entries;
 };
 
+enum of_reconfig_change {
+        OF_RECONFIG_NO_CHANGE = 0,
+        OF_RECONFIG_CHANGE_ADD,
+        OF_RECONFIG_CHANGE_REMOVE,
+};
+
 #ifdef CONFIG_OF_DYNAMIC
+extern int of_reconfig_notifier_register(struct notifier_block *);
+extern int of_reconfig_notifier_unregister(struct notifier_block *);
+extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
+extern int of_reconfig_get_state_change(unsigned long action,
+                                        struct of_reconfig_data *arg);
+
 extern void of_changeset_init(struct of_changeset *ocs);
 extern void of_changeset_destroy(struct of_changeset *ocs);
 extern int of_changeset_apply(struct of_changeset *ocs);
@@ -861,6 +978,69 @@ static inline int of_changeset_update_property(struct of_changeset *ocs,
 {
         return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
 }
+#else /* CONFIG_OF_DYNAMIC */
+static inline int of_reconfig_notifier_register(struct notifier_block *nb)
+{
+        return -EINVAL;
+}
+static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
+{
+        return -EINVAL;
+}
+static inline int of_reconfig_notify(unsigned long action,
+                                     struct of_reconfig_data *arg)
+{
+        return -EINVAL;
+}
+static inline int of_reconfig_get_state_change(unsigned long action,
+                                                struct of_reconfig_data *arg)
+{
+        return -EINVAL;
+}
+#endif /* CONFIG_OF_DYNAMIC */
+
+/* CONFIG_OF_RESOLVE api */
+extern int of_resolve_phandles(struct device_node *tree);
+
+/**
+ * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node
+ * @np: Pointer to the given device_node
+ *
+ * return true if present false otherwise
+ */
+static inline bool of_device_is_system_power_controller(const struct device_node *np)
+{
+        return of_property_read_bool(np, "system-power-controller");
+}
+
+/**
+ * Overlay support
+ */
+
+#ifdef CONFIG_OF_OVERLAY
+
+/* ID based overlays; the API for external users */
+int of_overlay_create(struct device_node *tree);
+int of_overlay_destroy(int id);
+int of_overlay_destroy_all(void);
+
+#else
+
+static inline int of_overlay_create(struct device_node *tree)
+{
+        return -ENOTSUPP;
+}
+
+static inline int of_overlay_destroy(int id)
+{
+        return -ENOTSUPP;
+}
+
+static inline int of_overlay_destroy_all(void)
+{
+        return -ENOTSUPP;
+}
+
 #endif
 
 #endif /* _LINUX_OF_H */
diff --git a/include/linux/of_address.h b/include/linux/of_address.h
index fb7b7221e063..d88e81be6368 100644
--- a/include/linux/of_address.h
+++ b/include/linux/of_address.h
@@ -23,17 +23,6 @@ struct of_pci_range {
 #define for_each_of_pci_range(parser, range) \
         for (; of_pci_range_parser_one(parser, range);)
 
-static inline void of_pci_range_to_resource(struct of_pci_range *range,
-                                            struct device_node *np,
-                                            struct resource *res)
-{
-        res->flags = range->flags;
-        res->start = range->cpu_addr;
-        res->end = range->cpu_addr + range->size - 1;
-        res->parent = res->child = res->sibling = NULL;
-        res->name = np->full_name;
-}
-
 /* Translate a DMA address from device space to CPU space */
 extern u64 of_translate_dma_address(struct device_node *dev,
                                     const __be32 *in_addr);
@@ -55,7 +44,9 @@ extern void __iomem *of_iomap(struct device_node *device, int index);
 extern const __be32 *of_get_address(struct device_node *dev, int index,
                            u64 *size, unsigned int *flags);
 
+extern int pci_register_io_range(phys_addr_t addr, resource_size_t size);
 extern unsigned long pci_address_to_pio(phys_addr_t addr);
+extern phys_addr_t pci_pio_to_address(unsigned long pio);
 
 extern int of_pci_range_parser_init(struct of_pci_range_parser *parser,
                         struct device_node *node);
@@ -80,6 +71,11 @@ static inline const __be32 *of_get_address(struct device_node *dev, int index,
         return NULL;
 }
 
+static inline phys_addr_t pci_pio_to_address(unsigned long pio)
+{
+        return 0;
+}
+
 static inline int of_pci_range_parser_init(struct of_pci_range_parser *parser,
                         struct device_node *node)
 {
@@ -110,7 +106,7 @@ extern int of_address_to_resource(struct device_node *dev, int index,
                                   struct resource *r);
 void __iomem *of_iomap(struct device_node *node, int index);
 void __iomem *of_io_request_and_map(struct device_node *device,
-                                        int index, char *name);
+                                        int index, const char *name);
 #else
 
 #include <linux/io.h>
@@ -127,7 +123,7 @@ static inline void __iomem *of_iomap(struct device_node *device, int index)
 }
 
 static inline void __iomem *of_io_request_and_map(struct device_node *device,
-                                        int index, char *name)
+                                        int index, const char *name)
 {
         return IOMEM_ERR_PTR(-EINVAL);
 }
@@ -138,6 +134,9 @@ extern const __be32 *of_get_pci_address(struct device_node *dev, int bar_no,
                                u64 *size, unsigned int *flags);
 extern int of_pci_address_to_resource(struct device_node *dev, int bar,
                                       struct resource *r);
+extern int of_pci_range_to_resource(struct of_pci_range *range,
+                                    struct device_node *np,
+                                    struct resource *res);
 #else /* CONFIG_OF_ADDRESS && CONFIG_PCI */
 static inline int of_pci_address_to_resource(struct device_node *dev, int bar,
                                              struct resource *r)
@@ -150,6 +149,12 @@ static inline const __be32 *of_get_pci_address(struct device_node *dev,
 {
         return NULL;
 }
+static inline int of_pci_range_to_resource(struct of_pci_range *range,
+                                           struct device_node *np,
+                                           struct resource *res)
+{
+        return -ENOSYS;
+}
 #endif /* CONFIG_OF_ADDRESS && CONFIG_PCI */
 
 #endif /* __OF_ADDRESS_H */
diff --git a/include/linux/of_iommu.h b/include/linux/of_iommu.h
index 51a560f34bca..16c75547d725 100644
--- a/include/linux/of_iommu.h
+++ b/include/linux/of_iommu.h
@@ -1,12 +1,19 @@
 #ifndef __OF_IOMMU_H
 #define __OF_IOMMU_H
 
+#include <linux/device.h>
+#include <linux/iommu.h>
+#include <linux/of.h>
+
 #ifdef CONFIG_OF_IOMMU
 
 extern int of_get_dma_window(struct device_node *dn, const char *prefix,
                              int index, unsigned long *busno, dma_addr_t *addr,
                              size_t *size);
 
+extern void of_iommu_init(void);
+extern struct iommu_ops *of_iommu_configure(struct device *dev);
+
 #else
 
 static inline int of_get_dma_window(struct device_node *dn, const char *prefix,
@@ -16,6 +23,22 @@ static inline int of_get_dma_window(struct device_node *dn, const char *prefix,
         return -EINVAL;
 }
 
+static inline void of_iommu_init(void) { }
+static inline struct iommu_ops *of_iommu_configure(struct device *dev)
+{
+        return NULL;
+}
+
 #endif  /* CONFIG_OF_IOMMU */
 
+void of_iommu_set_ops(struct device_node *np, struct iommu_ops *ops);
+struct iommu_ops *of_iommu_get_ops(struct device_node *np);
+
+extern struct of_device_id __iommu_of_table;
+
+typedef int (*of_iommu_init_fn)(struct device_node *);
+
+#define IOMMU_OF_DECLARE(name, compat, fn) \
+        _OF_DECLARE(iommu, name, compat, fn, of_iommu_init_fn)
+
 #endif /* __OF_IOMMU_H */
diff --git a/include/linux/of_pci.h b/include/linux/of_pci.h
index dde3a4a0fa5d..ce0e5abeb454 100644
--- a/include/linux/of_pci.h
+++ b/include/linux/of_pci.h
@@ -15,6 +15,7 @@ struct device_node *of_pci_find_child_device(struct device_node *parent,
 int of_pci_get_devfn(struct device_node *np);
 int of_irq_parse_and_map_pci(const struct pci_dev *dev, u8 slot, u8 pin);
 int of_pci_parse_bus_range(struct device_node *node, struct resource *res);
+int of_get_pci_domain_nr(struct device_node *node);
 #else
 static inline int of_irq_parse_pci(const struct pci_dev *pdev, struct of_phandle_args *out_irq)
 {
@@ -43,16 +44,28 @@ of_pci_parse_bus_range(struct device_node *node, struct resource *res)
 {
         return -EINVAL;
 }
+
+static inline int
+of_get_pci_domain_nr(struct device_node *node)
+{
+        return -1;
+}
+#endif
+
+#if defined(CONFIG_OF_ADDRESS)
+int of_pci_get_host_bridge_resources(struct device_node *dev,
+                        unsigned char busno, unsigned char bus_max,
+                        struct list_head *resources, resource_size_t *io_base);
 #endif
 
 #if defined(CONFIG_OF) && defined(CONFIG_PCI_MSI)
-int of_pci_msi_chip_add(struct msi_chip *chip);
-void of_pci_msi_chip_remove(struct msi_chip *chip);
-struct msi_chip *of_pci_find_msi_chip_by_node(struct device_node *of_node);
+int of_pci_msi_chip_add(struct msi_controller *chip);
+void of_pci_msi_chip_remove(struct msi_controller *chip);
+struct msi_controller *of_pci_find_msi_chip_by_node(struct device_node *of_node);
 #else
-static inline int of_pci_msi_chip_add(struct msi_chip *chip) { return -EINVAL; }
-static inline void of_pci_msi_chip_remove(struct msi_chip *chip) { }
-static inline struct msi_chip *
+static inline int of_pci_msi_chip_add(struct msi_controller *chip) { return -EINVAL; }
+static inline void of_pci_msi_chip_remove(struct msi_controller *chip) { }
+static inline struct msi_controller *
 of_pci_find_msi_chip_by_node(struct device_node *of_node) { return NULL; }
 #endif
 
diff --git a/include/linux/of_pdt.h b/include/linux/of_pdt.h
index c65a18a0cfdf..7e09244bb679 100644
--- a/include/linux/of_pdt.h
+++ b/include/linux/of_pdt.h
@@ -39,7 +39,6 @@ extern void *prom_early_alloc(unsigned long size);
 /* for building the device tree */
 extern void of_pdt_build_devicetree(phandle root_node, struct of_pdt_ops *ops);
 
-extern void (*of_pdt_build_more)(struct device_node *dp,
-                struct device_node ***nextp);
+extern void (*of_pdt_build_more)(struct device_node *dp);
 
 #endif /* _LINUX_OF_PDT_H */
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index c2b0627a2317..8a860f096c35 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -84,4 +84,10 @@ static inline int of_platform_populate(struct device_node *root,
 static inline void of_platform_depopulate(struct device *parent) { }
 #endif
 
+#ifdef CONFIG_OF_DYNAMIC
+extern void of_platform_register_reconfig_notifier(void);
+#else
+static inline void of_platform_register_reconfig_notifier(void) { }
+#endif
+
 #endif  /* _LINUX_OF_PLATFORM_H */
diff --git a/include/linux/of_reserved_mem.h b/include/linux/of_reserved_mem.h
index 5b5efae09135..ad2f67054372 100644
--- a/include/linux/of_reserved_mem.h
+++ b/include/linux/of_reserved_mem.h
@@ -16,7 +16,7 @@ struct reserved_mem {
 };
 
 struct reserved_mem_ops {
-        void    (*device_init)(struct reserved_mem *rmem,
+        int     (*device_init)(struct reserved_mem *rmem,
                                struct device *dev);
         void    (*device_release)(struct reserved_mem *rmem,
                                   struct device *dev);
@@ -28,14 +28,17 @@ typedef int (*reservedmem_of_init_fn)(struct reserved_mem *rmem);
         _OF_DECLARE(reservedmem, name, compat, init, reservedmem_of_init_fn)
 
 #ifdef CONFIG_OF_RESERVED_MEM
-void of_reserved_mem_device_init(struct device *dev);
+int of_reserved_mem_device_init(struct device *dev);
 void of_reserved_mem_device_release(struct device *dev);
 
 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);
 #else
-static inline void of_reserved_mem_device_init(struct device *dev) { }
+static inline int of_reserved_mem_device_init(struct device *dev)
+{
+        return -ENOSYS;
+}
 static inline void of_reserved_mem_device_release(struct device *pdev) { }
 
 static inline void fdt_init_reserved_mem(void) { }
diff --git a/include/linux/omap-dma.h b/include/linux/omap-dma.h
index 6f06f8bc612c..e5a70132a240 100644
--- a/include/linux/omap-dma.h
+++ b/include/linux/omap-dma.h
@@ -306,15 +306,12 @@ extern void omap_set_dma_transfer_params(int lch, int data_type,
                                          int elem_count, int frame_count,
                                          int sync_mode,
                                          int dma_trigger, int src_or_dst_synch);
-extern void omap_set_dma_color_mode(int lch, enum omap_dma_color_mode mode,
-                                    u32 color);
 extern void omap_set_dma_write_mode(int lch, enum omap_dma_write_mode mode);
 extern void omap_set_dma_channel_mode(int lch, enum omap_dma_channel_mode mode);
 
 extern void omap_set_dma_src_params(int lch, int src_port, int src_amode,
                                     unsigned long src_start,
                                     int src_ei, int src_fi);
-extern void omap_set_dma_src_index(int lch, int eidx, int fidx);
 extern void omap_set_dma_src_data_pack(int lch, int enable);
 extern void omap_set_dma_src_burst_mode(int lch,
                                         enum omap_dma_burst_mode burst_mode);
@@ -322,7 +319,6 @@ extern void omap_set_dma_src_burst_mode(int lch,
 extern void omap_set_dma_dest_params(int lch, int dest_port, int dest_amode,
                                      unsigned long dest_start,
                                      int dst_ei, int dst_fi);
-extern void omap_set_dma_dest_index(int lch, int eidx, int fidx);
 extern void omap_set_dma_dest_data_pack(int lch, int enable);
 extern void omap_set_dma_dest_burst_mode(int lch,
                                          enum omap_dma_burst_mode burst_mode);
@@ -331,52 +327,19 @@ extern void omap_set_dma_params(int lch,
                                 struct omap_dma_channel_params *params);
 
 extern void omap_dma_link_lch(int lch_head, int lch_queue);
-extern void omap_dma_unlink_lch(int lch_head, int lch_queue);
 
 extern int omap_set_dma_callback(int lch,
                         void (*callback)(int lch, u16 ch_status, void *data),
                         void *data);
 extern dma_addr_t omap_get_dma_src_pos(int lch);
 extern dma_addr_t omap_get_dma_dst_pos(int lch);
-extern void omap_clear_dma(int lch);
 extern int omap_get_dma_active_status(int lch);
 extern int omap_dma_running(void);
 extern void omap_dma_set_global_params(int arb_rate, int max_fifo_depth,
                                        int tparams);
-extern int omap_dma_set_prio_lch(int lch, unsigned char read_prio,
-                                 unsigned char write_prio);
-extern void omap_set_dma_dst_endian_type(int lch, enum end_type etype);
-extern void omap_set_dma_src_endian_type(int lch, enum end_type etype);
-extern int omap_get_dma_index(int lch, int *ei, int *fi);
-
 void omap_dma_global_context_save(void);
 void omap_dma_global_context_restore(void);
 
-extern void omap_dma_disable_irq(int lch);
-
-/* Chaining APIs */
-#ifndef CONFIG_ARCH_OMAP1
-extern int omap_request_dma_chain(int dev_id, const char *dev_name,
-                                  void (*callback) (int lch, u16 ch_status,
-                                                    void *data),
-                                  int *chain_id, int no_of_chans,
-                                  int chain_mode,
-                                  struct omap_dma_channel_params params);
-extern int omap_free_dma_chain(int chain_id);
-extern int omap_dma_chain_a_transfer(int chain_id, int src_start,
-                                     int dest_start, int elem_count,
-                                     int frame_count, void *callbk_data);
-extern int omap_start_dma_chain_transfers(int chain_id);
-extern int omap_stop_dma_chain_transfers(int chain_id);
-extern int omap_get_dma_chain_index(int chain_id, int *ei, int *fi);
-extern int omap_get_dma_chain_dst_pos(int chain_id);
-extern int omap_get_dma_chain_src_pos(int chain_id);
-
-extern int omap_modify_dma_chain_params(int chain_id,
-                                        struct omap_dma_channel_params params);
-extern int omap_dma_chain_status(int chain_id);
-#endif
-
 #if defined(CONFIG_ARCH_OMAP1) && IS_ENABLED(CONFIG_FB_OMAP)
 #include <mach/lcd_dma.h>
 #else
diff --git a/include/linux/omap-gpmc.h b/include/linux/omap-gpmc.h
new file mode 100644
index 000000000000..c2080eebbb47
--- /dev/null
+++ b/include/linux/omap-gpmc.h
@@ -0,0 +1,199 @@
+/*
+ *  OMAP GPMC (General Purpose Memory Controller) defines
+ *
+ *  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.
+ */
+
+/* Maximum Number of Chip Selects */
+#define GPMC_CS_NUM             8
+
+#define GPMC_CONFIG_WP          0x00000005
+
+#define GPMC_IRQ_FIFOEVENTENABLE        0x01
+#define GPMC_IRQ_COUNT_EVENT            0x02
+
+#define GPMC_BURST_4                    4       /* 4 word burst */
+#define GPMC_BURST_8                    8       /* 8 word burst */
+#define GPMC_BURST_16                   16      /* 16 word burst */
+#define GPMC_DEVWIDTH_8BIT              1       /* 8-bit device width */
+#define GPMC_DEVWIDTH_16BIT             2       /* 16-bit device width */
+#define GPMC_MUX_AAD                    1       /* Addr-Addr-Data multiplex */
+#define GPMC_MUX_AD                     2       /* Addr-Data multiplex */
+
+/* bool type time settings */
+struct gpmc_bool_timings {
+        bool cycle2cyclediffcsen;
+        bool cycle2cyclesamecsen;
+        bool we_extra_delay;
+        bool oe_extra_delay;
+        bool adv_extra_delay;
+        bool cs_extra_delay;
+        bool time_para_granularity;
+};
+
+/*
+ * Note that all values in this struct are in nanoseconds except sync_clk
+ * (which is in picoseconds), while the register values are in gpmc_fck cycles.
+ */
+struct gpmc_timings {
+        /* Minimum clock period for synchronous mode (in picoseconds) */
+        u32 sync_clk;
+
+        /* Chip-select signal timings corresponding to GPMC_CS_CONFIG2 */
+        u32 cs_on;              /* Assertion time */
+        u32 cs_rd_off;          /* Read deassertion time */
+        u32 cs_wr_off;          /* Write deassertion time */
+
+        /* ADV signal timings corresponding to GPMC_CONFIG3 */
+        u32 adv_on;             /* Assertion time */
+        u32 adv_rd_off;         /* Read deassertion time */
+        u32 adv_wr_off;         /* Write deassertion time */
+
+        /* WE signals timings corresponding to GPMC_CONFIG4 */
+        u32 we_on;              /* WE assertion time */
+        u32 we_off;             /* WE deassertion time */
+
+        /* OE signals timings corresponding to GPMC_CONFIG4 */
+        u32 oe_on;              /* OE assertion time */
+        u32 oe_off;             /* OE deassertion time */
+
+        /* Access time and cycle time timings corresponding to GPMC_CONFIG5 */
+        u32 page_burst_access;  /* Multiple access word delay */
+        u32 access;             /* Start-cycle to first data valid delay */
+        u32 rd_cycle;           /* Total read cycle time */
+        u32 wr_cycle;           /* Total write cycle time */
+
+        u32 bus_turnaround;
+        u32 cycle2cycle_delay;
+
+        u32 wait_monitoring;
+        u32 clk_activation;
+
+        /* The following are only on OMAP3430 */
+        u32 wr_access;          /* WRACCESSTIME */
+        u32 wr_data_mux_bus;    /* WRDATAONADMUXBUS */
+
+        struct gpmc_bool_timings bool_timings;
+};
+
+/* Device timings in picoseconds */
+struct gpmc_device_timings {
+        u32 t_ceasu;    /* address setup to CS valid */
+        u32 t_avdasu;   /* address setup to ADV valid */
+        /* XXX: try to combine t_avdp_r & t_avdp_w. Issue is
+         * of tusb using these timings even for sync whilst
+         * ideally for adv_rd/(wr)_off it should have considered
+         * t_avdh instead. This indirectly necessitates r/w
+         * variations of t_avdp as it is possible to have one
+         * sync & other async
+         */
+        u32 t_avdp_r;   /* ADV low time (what about t_cer ?) */
+        u32 t_avdp_w;
+        u32 t_aavdh;    /* address hold time */
+        u32 t_oeasu;    /* address setup to OE valid */
+        u32 t_aa;       /* access time from ADV assertion */
+        u32 t_iaa;      /* initial access time */
+        u32 t_oe;       /* access time from OE assertion */
+        u32 t_ce;       /* access time from CS asertion */
+        u32 t_rd_cycle; /* read cycle time */
+        u32 t_cez_r;    /* read CS deassertion to high Z */
+        u32 t_cez_w;    /* write CS deassertion to high Z */
+        u32 t_oez;      /* OE deassertion to high Z */
+        u32 t_weasu;    /* address setup to WE valid */
+        u32 t_wpl;      /* write assertion time */
+        u32 t_wph;      /* write deassertion time */
+        u32 t_wr_cycle; /* write cycle time */
+
+        u32 clk;
+        u32 t_bacc;     /* burst access valid clock to output delay */
+        u32 t_ces;      /* CS setup time to clk */
+        u32 t_avds;     /* ADV setup time to clk */
+        u32 t_avdh;     /* ADV hold time from clk */
+        u32 t_ach;      /* address hold time from clk */
+        u32 t_rdyo;     /* clk to ready valid */
+
+        u32 t_ce_rdyz;  /* XXX: description ?, or use t_cez instead */
+        u32 t_ce_avd;   /* CS on to ADV on delay */
+
+        /* XXX: check the possibility of combining
+         * cyc_aavhd_oe & cyc_aavdh_we
+         */
+        u8 cyc_aavdh_oe;/* read address hold time in cycles */
+        u8 cyc_aavdh_we;/* write address hold time in cycles */
+        u8 cyc_oe;      /* access time from OE assertion in cycles */
+        u8 cyc_wpl;     /* write deassertion time in cycles */
+        u32 cyc_iaa;    /* initial access time in cycles */
+
+        /* extra delays */
+        bool ce_xdelay;
+        bool avd_xdelay;
+        bool oe_xdelay;
+        bool we_xdelay;
+};
+
+struct gpmc_settings {
+        bool burst_wrap;        /* enables wrap bursting */
+        bool burst_read;        /* enables read page/burst mode */
+        bool burst_write;       /* enables write page/burst mode */
+        bool device_nand;       /* device is NAND */
+        bool sync_read;         /* enables synchronous reads */
+        bool sync_write;        /* enables synchronous writes */
+        bool wait_on_read;      /* monitor wait on reads */
+        bool wait_on_write;     /* monitor wait on writes */
+        u32 burst_len;          /* page/burst length */
+        u32 device_width;       /* device bus width (8 or 16 bit) */
+        u32 mux_add_data;       /* multiplex address & data */
+        u32 wait_pin;           /* wait-pin to be used */
+};
+
+extern int gpmc_calc_timings(struct gpmc_timings *gpmc_t,
+                             struct gpmc_settings *gpmc_s,
+                             struct gpmc_device_timings *dev_t);
+
+struct gpmc_nand_regs;
+struct device_node;
+
+extern void gpmc_update_nand_reg(struct gpmc_nand_regs *reg, int cs);
+extern int gpmc_get_client_irq(unsigned irq_config);
+
+extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
+
+extern void gpmc_cs_write_reg(int cs, int idx, u32 val);
+extern int gpmc_calc_divider(unsigned int sync_clk);
+extern int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t);
+extern int gpmc_cs_program_settings(int cs, struct gpmc_settings *p);
+extern int gpmc_cs_request(int cs, unsigned long size, unsigned long *base);
+extern void gpmc_cs_free(int cs);
+extern int gpmc_configure(int cmd, int wval);
+extern void gpmc_read_settings_dt(struct device_node *np,
+                                  struct gpmc_settings *p);
+
+extern void omap3_gpmc_save_context(void);
+extern void omap3_gpmc_restore_context(void);
+
+struct gpmc_timings;
+struct omap_nand_platform_data;
+struct omap_onenand_platform_data;
+
+#if IS_ENABLED(CONFIG_MTD_NAND_OMAP2)
+extern int gpmc_nand_init(struct omap_nand_platform_data *d,
+                          struct gpmc_timings *gpmc_t);
+#else
+static inline int gpmc_nand_init(struct omap_nand_platform_data *d,
+                                 struct gpmc_timings *gpmc_t)
+{
+        return 0;
+}
+#endif
+
+#if IS_ENABLED(CONFIG_MTD_ONENAND_OMAP2)
+extern void gpmc_onenand_init(struct omap_onenand_platform_data *d);
+#else
+#define board_onenand_data      NULL
+static inline void gpmc_onenand_init(struct omap_onenand_platform_data *d)
+{
+}
+#endif
diff --git a/include/linux/omap-mailbox.h b/include/linux/omap-mailbox.h
index f8322d9cd235..587bbdd31f5a 100644
--- a/include/linux/omap-mailbox.h
+++ b/include/linux/omap-mailbox.h
@@ -10,20 +10,20 @@
 #define OMAP_MAILBOX_H
 
 typedef u32 mbox_msg_t;
-struct omap_mbox;
 
 typedef int __bitwise omap_mbox_irq_t;
 #define IRQ_TX ((__force omap_mbox_irq_t) 1)
 #define IRQ_RX ((__force omap_mbox_irq_t) 2)
 
-int omap_mbox_msg_send(struct omap_mbox *, mbox_msg_t msg);
+struct mbox_chan;
+struct mbox_client;
 
-struct omap_mbox *omap_mbox_get(const char *, struct notifier_block *nb);
-void omap_mbox_put(struct omap_mbox *mbox, struct notifier_block *nb);
+struct mbox_chan *omap_mbox_request_channel(struct mbox_client *cl,
+                                            const char *chan_name);
 
-void omap_mbox_save_ctx(struct omap_mbox *mbox);
-void omap_mbox_restore_ctx(struct omap_mbox *mbox);
-void omap_mbox_enable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq);
-void omap_mbox_disable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq);
+void omap_mbox_save_ctx(struct mbox_chan *chan);
+void omap_mbox_restore_ctx(struct mbox_chan *chan);
+void omap_mbox_enable_irq(struct mbox_chan *chan, omap_mbox_irq_t irq);
+void omap_mbox_disable_irq(struct mbox_chan *chan, omap_mbox_irq_t irq);
 
 #endif /* OMAP_MAILBOX_H */
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 647395a1a550..853698c721f7 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -50,6 +50,9 @@ static inline bool oom_task_origin(const struct task_struct *p)
 extern unsigned long oom_badness(struct task_struct *p,
                 struct mem_cgroup *memcg, const nodemask_t *nodemask,
                 unsigned long totalpages);
+
+extern int oom_kills_count(void);
+extern void note_oom_kill(void);
 extern void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
                              unsigned int points, unsigned long totalpages,
                              struct mem_cgroup *memcg, nodemask_t *nodemask,
@@ -89,6 +92,17 @@ static inline bool oom_gfp_allowed(gfp_t gfp_mask)
 
 extern struct task_struct *find_lock_task_mm(struct task_struct *p);
 
+static inline bool task_will_free_mem(struct task_struct *task)
+{
+        /*
+         * A coredumping process may sleep for an extended period in exit_mm(),
+         * so the oom killer cannot assume that the process will promptly exit
+         * and release memory.
+         */
+        return (task->flags & PF_EXITING) &&
+                !(task->signal->flags & SIGNAL_GROUP_COREDUMP);
+}
+
 /* sysctls */
 extern int sysctl_oom_dump_tasks;
 extern int sysctl_oom_kill_allocating_task;
diff --git a/include/linux/page-debug-flags.h b/include/linux/page-debug-flags.h
deleted file mode 100644
index 22691f614043..000000000000
--- a/include/linux/page-debug-flags.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef LINUX_PAGE_DEBUG_FLAGS_H
-#define  LINUX_PAGE_DEBUG_FLAGS_H
-
-/*
- * page->debug_flags bits:
- *
- * PAGE_DEBUG_FLAG_POISON is set for poisoned pages. This is used to
- * implement generic debug pagealloc feature. The pages are filled with
- * poison patterns and set this flag after free_pages(). The poisoned
- * pages are verified whether the patterns are not corrupted and clear
- * the flag before alloc_pages().
- */
-
-enum page_debug_flags {
-        PAGE_DEBUG_FLAG_POISON,         /* Page is poisoned */
-        PAGE_DEBUG_FLAG_GUARD,
-};
-
-/*
- * Ensure that CONFIG_WANT_PAGE_DEBUG_FLAGS reliably
- * gets turned off when no debug features are enabling it!
- */
-
-#ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
-#if !defined(CONFIG_PAGE_POISONING) && \
-    !defined(CONFIG_PAGE_GUARD) \
-/* && !defined(CONFIG_PAGE_DEBUG_SOMETHING_ELSE) && ... */
-#error WANT_PAGE_DEBUG_FLAGS is turned on with no debug features!
-#endif
-#endif /* CONFIG_WANT_PAGE_DEBUG_FLAGS */
-
-#endif /* LINUX_PAGE_DEBUG_FLAGS_H */
diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h
index 3fff8e774067..2dc1e1697b45 100644
--- a/include/linux/page-isolation.h
+++ b/include/linux/page-isolation.h
@@ -2,6 +2,10 @@
 #define __LINUX_PAGEISOLATION_H
 
 #ifdef CONFIG_MEMORY_ISOLATION
+static inline bool has_isolate_pageblock(struct zone *zone)
+{
+        return zone->nr_isolate_pageblock;
+}
 static inline bool is_migrate_isolate_page(struct page *page)
 {
         return get_pageblock_migratetype(page) == MIGRATE_ISOLATE;
@@ -11,6 +15,10 @@ static inline bool is_migrate_isolate(int migratetype)
         return migratetype == MIGRATE_ISOLATE;
 }
 #else
+static inline bool has_isolate_pageblock(struct zone *zone)
+{
+        return false;
+}
 static inline bool is_migrate_isolate_page(struct page *page)
 {
         return false;
diff --git a/include/linux/page_cgroup.h b/include/linux/page_cgroup.h
deleted file mode 100644
index 5c831f1eca79..000000000000
--- a/include/linux/page_cgroup.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef __LINUX_PAGE_CGROUP_H
-#define __LINUX_PAGE_CGROUP_H
-
-enum {
-        /* flags for mem_cgroup */
-        PCG_USED = 0x01,        /* This page is charged to a memcg */
-        PCG_MEM = 0x02,         /* This page holds a memory charge */
-        PCG_MEMSW = 0x04,       /* This page holds a memory+swap charge */
-};
-
-struct pglist_data;
-
-#ifdef CONFIG_MEMCG
-struct mem_cgroup;
-
-/*
- * Page Cgroup can be considered as an extended mem_map.
- * A page_cgroup page is associated with every page descriptor. The
- * page_cgroup helps us identify information about the cgroup
- * All page cgroups are allocated at boot or memory hotplug event,
- * then the page cgroup for pfn always exists.
- */
-struct page_cgroup {
-        unsigned long flags;
-        struct mem_cgroup *mem_cgroup;
-};
-
-extern void pgdat_page_cgroup_init(struct pglist_data *pgdat);
-
-#ifdef CONFIG_SPARSEMEM
-static inline void page_cgroup_init_flatmem(void)
-{
-}
-extern void page_cgroup_init(void);
-#else
-extern void page_cgroup_init_flatmem(void);
-static inline void page_cgroup_init(void)
-{
-}
-#endif
-
-struct page_cgroup *lookup_page_cgroup(struct page *page);
-
-static inline int PageCgroupUsed(struct page_cgroup *pc)
-{
-        return !!(pc->flags & PCG_USED);
-}
-#else /* !CONFIG_MEMCG */
-struct page_cgroup;
-
-static inline void pgdat_page_cgroup_init(struct pglist_data *pgdat)
-{
-}
-
-static inline struct page_cgroup *lookup_page_cgroup(struct page *page)
-{
-        return NULL;
-}
-
-static inline void page_cgroup_init(void)
-{
-}
-
-static inline void page_cgroup_init_flatmem(void)
-{
-}
-#endif /* CONFIG_MEMCG */
-
-#include <linux/swap.h>
-
-#ifdef CONFIG_MEMCG_SWAP
-extern unsigned short swap_cgroup_cmpxchg(swp_entry_t ent,
-                                        unsigned short old, unsigned short new);
-extern unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id);
-extern unsigned short lookup_swap_cgroup_id(swp_entry_t ent);
-extern int swap_cgroup_swapon(int type, unsigned long max_pages);
-extern void swap_cgroup_swapoff(int type);
-#else
-
-static inline
-unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id)
-{
-        return 0;
-}
-
-static inline
-unsigned short lookup_swap_cgroup_id(swp_entry_t ent)
-{
-        return 0;
-}
-
-static inline int
-swap_cgroup_swapon(int type, unsigned long max_pages)
-{
-        return 0;
-}
-
-static inline void swap_cgroup_swapoff(int type)
-{
-        return;
-}
-
-#endif /* CONFIG_MEMCG_SWAP */
-
-#endif /* __LINUX_PAGE_CGROUP_H */
diff --git a/include/linux/page_counter.h b/include/linux/page_counter.h
new file mode 100644
index 000000000000..955421575d16
--- /dev/null
+++ b/include/linux/page_counter.h
@@ -0,0 +1,51 @@
+#ifndef _LINUX_PAGE_COUNTER_H
+#define _LINUX_PAGE_COUNTER_H
+
+#include <linux/atomic.h>
+#include <linux/kernel.h>
+#include <asm/page.h>
+
+struct page_counter {
+        atomic_long_t count;
+        unsigned long limit;
+        struct page_counter *parent;
+
+        /* legacy */
+        unsigned long watermark;
+        unsigned long failcnt;
+};
+
+#if BITS_PER_LONG == 32
+#define PAGE_COUNTER_MAX LONG_MAX
+#else
+#define PAGE_COUNTER_MAX (LONG_MAX / PAGE_SIZE)
+#endif
+
+static inline void page_counter_init(struct page_counter *counter,
+                                     struct page_counter *parent)
+{
+        atomic_long_set(&counter->count, 0);
+        counter->limit = PAGE_COUNTER_MAX;
+        counter->parent = parent;
+}
+
+static inline unsigned long page_counter_read(struct page_counter *counter)
+{
+        return atomic_long_read(&counter->count);
+}
+
+void page_counter_cancel(struct page_counter *counter, unsigned long nr_pages);
+void page_counter_charge(struct page_counter *counter, unsigned long nr_pages);
+int page_counter_try_charge(struct page_counter *counter,
+                            unsigned long nr_pages,
+                            struct page_counter **fail);
+void page_counter_uncharge(struct page_counter *counter, unsigned long nr_pages);
+int page_counter_limit(struct page_counter *counter, unsigned long limit);
+int page_counter_memparse(const char *buf, unsigned long *nr_pages);
+
+static inline void page_counter_reset_watermark(struct page_counter *counter)
+{
+        counter->watermark = page_counter_read(counter);
+}
+
+#endif /* _LINUX_PAGE_COUNTER_H */
diff --git a/include/linux/page_ext.h b/include/linux/page_ext.h
new file mode 100644
index 000000000000..d2a2c84c72d0
--- /dev/null
+++ b/include/linux/page_ext.h
@@ -0,0 +1,84 @@
+#ifndef __LINUX_PAGE_EXT_H
+#define __LINUX_PAGE_EXT_H
+
+#include <linux/types.h>
+#include <linux/stacktrace.h>
+
+struct pglist_data;
+struct page_ext_operations {
+        bool (*need)(void);
+        void (*init)(void);
+};
+
+#ifdef CONFIG_PAGE_EXTENSION
+
+/*
+ * page_ext->flags bits:
+ *
+ * PAGE_EXT_DEBUG_POISON is set for poisoned pages. This is used to
+ * implement generic debug pagealloc feature. The pages are filled with
+ * poison patterns and set this flag after free_pages(). The poisoned
+ * pages are verified whether the patterns are not corrupted and clear
+ * the flag before alloc_pages().
+ */
+
+enum page_ext_flags {
+        PAGE_EXT_DEBUG_POISON,          /* Page is poisoned */
+        PAGE_EXT_DEBUG_GUARD,
+        PAGE_EXT_OWNER,
+};
+
+/*
+ * Page Extension can be considered as an extended mem_map.
+ * A page_ext page is associated with every page descriptor. The
+ * page_ext helps us add more information about the page.
+ * All page_ext are allocated at boot or memory hotplug event,
+ * then the page_ext for pfn always exists.
+ */
+struct page_ext {
+        unsigned long flags;
+#ifdef CONFIG_PAGE_OWNER
+        unsigned int order;
+        gfp_t gfp_mask;
+        struct stack_trace trace;
+        unsigned long trace_entries[8];
+#endif
+};
+
+extern void pgdat_page_ext_init(struct pglist_data *pgdat);
+
+#ifdef CONFIG_SPARSEMEM
+static inline void page_ext_init_flatmem(void)
+{
+}
+extern void page_ext_init(void);
+#else
+extern void page_ext_init_flatmem(void);
+static inline void page_ext_init(void)
+{
+}
+#endif
+
+struct page_ext *lookup_page_ext(struct page *page);
+
+#else /* !CONFIG_PAGE_EXTENSION */
+struct page_ext;
+
+static inline void pgdat_page_ext_init(struct pglist_data *pgdat)
+{
+}
+
+static inline struct page_ext *lookup_page_ext(struct page *page)
+{
+        return NULL;
+}
+
+static inline void page_ext_init(void)
+{
+}
+
+static inline void page_ext_init_flatmem(void)
+{
+}
+#endif /* CONFIG_PAGE_EXTENSION */
+#endif /* __LINUX_PAGE_EXT_H */
diff --git a/include/linux/page_owner.h b/include/linux/page_owner.h
new file mode 100644
index 000000000000..b48c3471c254
--- /dev/null
+++ b/include/linux/page_owner.h
@@ -0,0 +1,38 @@
+#ifndef __LINUX_PAGE_OWNER_H
+#define __LINUX_PAGE_OWNER_H
+
+#ifdef CONFIG_PAGE_OWNER
+extern bool page_owner_inited;
+extern struct page_ext_operations page_owner_ops;
+
+extern void __reset_page_owner(struct page *page, unsigned int order);
+extern void __set_page_owner(struct page *page,
+                        unsigned int order, gfp_t gfp_mask);
+
+static inline void reset_page_owner(struct page *page, unsigned int order)
+{
+        if (likely(!page_owner_inited))
+                return;
+
+        __reset_page_owner(page, order);
+}
+
+static inline void set_page_owner(struct page *page,
+                        unsigned int order, gfp_t gfp_mask)
+{
+        if (likely(!page_owner_inited))
+                return;
+
+        __set_page_owner(page, order, gfp_mask);
+}
+#else
+static inline void reset_page_owner(struct page *page, unsigned int order)
+{
+}
+static inline void set_page_owner(struct page *page,
+                        unsigned int order, gfp_t gfp_mask)
+{
+}
+
+#endif /* CONFIG_PAGE_OWNER */
+#endif /* __LINUX_PAGE_OWNER_H */
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 3df8c7db7a4e..4b3736f7065c 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -24,8 +24,7 @@ enum mapping_flags {
         AS_ENOSPC       = __GFP_BITS_SHIFT + 1, /* ENOSPC on async write */
         AS_MM_ALL_LOCKS = __GFP_BITS_SHIFT + 2, /* under mm_take_all_locks() */
         AS_UNEVICTABLE  = __GFP_BITS_SHIFT + 3, /* e.g., ramdisk, SHM_LOCK */
-        AS_BALLOON_MAP  = __GFP_BITS_SHIFT + 4, /* balloon page special map */
-        AS_EXITING      = __GFP_BITS_SHIFT + 5, /* final truncate in progress */
+        AS_EXITING      = __GFP_BITS_SHIFT + 4, /* final truncate in progress */
 };
 
 static inline void mapping_set_error(struct address_space *mapping, int error)
@@ -55,21 +54,6 @@ static inline int mapping_unevictable(struct address_space *mapping)
         return !!mapping;
 }
 
-static inline void mapping_set_balloon(struct address_space *mapping)
-{
-        set_bit(AS_BALLOON_MAP, &mapping->flags);
-}
-
-static inline void mapping_clear_balloon(struct address_space *mapping)
-{
-        clear_bit(AS_BALLOON_MAP, &mapping->flags);
-}
-
-static inline int mapping_balloon(struct address_space *mapping)
-{
-        return mapping && test_bit(AS_BALLOON_MAP, &mapping->flags);
-}
-
 static inline void mapping_set_exiting(struct address_space *mapping)
 {
         set_bit(AS_EXITING, &mapping->flags);
@@ -96,7 +80,7 @@ static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
 }
 
 /*
- * The page cache can done in larger chunks than
+ * The page cache can be done in larger chunks than
  * one page, because it allows for more efficient
  * throughput (it can then be mapped into user
  * space in smaller chunks for same flexibility).
@@ -267,7 +251,7 @@ pgoff_t page_cache_prev_hole(struct address_space *mapping,
 #define FGP_NOWAIT              0x00000020
 
 struct page *pagecache_get_page(struct address_space *mapping, pgoff_t offset,
-                int fgp_flags, gfp_t cache_gfp_mask, gfp_t radix_gfp_mask);
+                int fgp_flags, gfp_t cache_gfp_mask);
 
 /**
  * find_get_page - find and get a page reference
@@ -282,13 +266,13 @@ struct page *pagecache_get_page(struct address_space *mapping, pgoff_t offset,
 static inline struct page *find_get_page(struct address_space *mapping,
                                         pgoff_t offset)
 {
-        return pagecache_get_page(mapping, offset, 0, 0, 0);
+        return pagecache_get_page(mapping, offset, 0, 0);
 }
 
 static inline struct page *find_get_page_flags(struct address_space *mapping,
                                         pgoff_t offset, int fgp_flags)
 {
-        return pagecache_get_page(mapping, offset, fgp_flags, 0, 0);
+        return pagecache_get_page(mapping, offset, fgp_flags, 0);
 }
 
 /**
@@ -308,7 +292,7 @@ static inline struct page *find_get_page_flags(struct address_space *mapping,
 static inline struct page *find_lock_page(struct address_space *mapping,
                                         pgoff_t offset)
 {
-        return pagecache_get_page(mapping, offset, FGP_LOCK, 0, 0);
+        return pagecache_get_page(mapping, offset, FGP_LOCK, 0);
 }
 
 /**
@@ -335,7 +319,7 @@ static inline struct page *find_or_create_page(struct address_space *mapping,
 {
         return pagecache_get_page(mapping, offset,
                                         FGP_LOCK|FGP_ACCESSED|FGP_CREAT,
-                                        gfp_mask, gfp_mask & GFP_RECLAIM_MASK);
+                                        gfp_mask);
 }
 
 /**
@@ -356,8 +340,7 @@ static inline struct page *grab_cache_page_nowait(struct address_space *mapping,
 {
         return pagecache_get_page(mapping, index,
                         FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
-                        mapping_gfp_mask(mapping),
-                        GFP_NOFS);
+                        mapping_gfp_mask(mapping));
 }
 
 struct page *find_get_entry(struct address_space *mapping, pgoff_t offset);
@@ -496,12 +479,14 @@ static inline int lock_page_or_retry(struct page *page, struct mm_struct *mm,
 }
 
 /*
- * This is exported only for wait_on_page_locked/wait_on_page_writeback.
- * Never use this directly!
+ * This is exported only for wait_on_page_locked/wait_on_page_writeback,
+ * and for filesystems which need to wait on PG_private.
  */
 extern void wait_on_page_bit(struct page *page, int bit_nr);
 
 extern int wait_on_page_bit_killable(struct page *page, int bit_nr);
+extern int wait_on_page_bit_killable_timeout(struct page *page,
+                                             int bit_nr, unsigned long timeout);
 
 static inline int wait_on_page_locked_killable(struct page *page)
 {
@@ -510,6 +495,12 @@ static inline int wait_on_page_locked_killable(struct page *page)
         return 0;
 }
 
+extern wait_queue_head_t *page_waitqueue(struct page *page);
+static inline void wake_up_page(struct page *page, int bit)
+{
+        __wake_up_bit(page_waitqueue(page), &page->flags, bit);
+}
+
 /* 
  * Wait for a page to be unlocked.
  *
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h
index 64dacb7288a6..24c7728ca681 100644
--- a/include/linux/pci-acpi.h
+++ b/include/linux/pci-acpi.h
@@ -41,8 +41,13 @@ static inline acpi_handle acpi_pci_get_bridge_handle(struct pci_bus *pbus)
 
         if (pci_is_root_bus(pbus))
                 dev = pbus->bridge;
-        else
+        else {
+                /* If pbus is a virtual bus, there is no bridge to it */
+                if (!pbus->self)
+                        return NULL;
+
                 dev = &pbus->self->dev;
+        }
 
         return ACPI_HANDLE(dev);
 }
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 96453f9bc8ba..360a966a97a5 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -45,7 +45,7 @@
  * In the interest of not exposing interfaces to user-space unnecessarily,
  * the following kernel-only defines are being added here.
  */
-#define PCI_DEVID(bus, devfn)  ((((u16)bus) << 8) | devfn)
+#define PCI_DEVID(bus, devfn)  ((((u16)(bus)) << 8) | (devfn))
 /* return bus from PCI devid = ((u16)bus_number) << 8) | devfn */
 #define PCI_BUS_NUM(x) (((x) >> 8) & 0xff)
 
@@ -331,6 +331,7 @@ struct pci_dev {
         unsigned int    is_added:1;
         unsigned int    is_busmaster:1; /* device is busmaster */
         unsigned int    no_msi:1;       /* device may not use msi */
+        unsigned int    no_64bit_msi:1; /* device may only use 32-bit MSIs */
         unsigned int    block_cfg_access:1;     /* config space access is blocked */
         unsigned int    broken_parity_status:1; /* Device generates false positive parity */
         unsigned int    irq_reroute_variant:2;  /* device needs IRQ rerouting variant */
@@ -348,6 +349,7 @@ struct pci_dev {
         unsigned int    __aer_firmware_first:1;
         unsigned int    broken_intx_masking:1;
         unsigned int    io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
+        unsigned int    irq_managed:1;
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
@@ -449,7 +451,7 @@ struct pci_bus {
         struct resource busn_res;       /* bus numbers routed to this bus */
 
         struct pci_ops  *ops;           /* configuration access functions */
-        struct msi_chip *msi;           /* MSI controller */
+        struct msi_controller *msi;     /* MSI controller */
         void            *sysdata;       /* hook for sys-specific extension */
         struct proc_dir_entry *procdir; /* directory entry in /proc/bus/pci */
 
@@ -457,6 +459,9 @@ struct pci_bus {
         unsigned char   primary;        /* number of primary bridge */
         unsigned char   max_bus_speed;  /* enum pci_bus_speed */
         unsigned char   cur_bus_speed;  /* enum pci_bus_speed */
+#ifdef CONFIG_PCI_DOMAINS_GENERIC
+        int             domain_nr;
+#endif
 
         char            name[48];
 
@@ -1000,6 +1005,8 @@ void __iomem __must_check *pci_platform_rom(struct pci_dev *pdev, size_t *size);
 int pci_save_state(struct pci_dev *dev);
 void pci_restore_state(struct pci_dev *dev);
 struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
+int pci_load_saved_state(struct pci_dev *dev,
+                         struct pci_saved_state *state);
 int pci_load_and_free_saved_state(struct pci_dev *dev,
                                   struct pci_saved_state **state);
 struct pci_cap_saved_state *pci_find_saved_cap(struct pci_dev *dev, char cap);
@@ -1103,6 +1110,9 @@ int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
                                                   resource_size_t),
                         void *alignf_data);
 
+
+int pci_remap_iospace(const struct resource *res, phys_addr_t phys_addr);
+
 static inline dma_addr_t pci_bus_address(struct pci_dev *pdev, int bar)
 {
         struct pci_bus_region region;
@@ -1288,12 +1298,32 @@ void pci_cfg_access_unlock(struct pci_dev *dev);
  */
 #ifdef CONFIG_PCI_DOMAINS
 extern int pci_domains_supported;
+int pci_get_new_domain_nr(void);
 #else
 enum { pci_domains_supported = 0 };
 static inline int pci_domain_nr(struct pci_bus *bus) { return 0; }
 static inline int pci_proc_domain(struct pci_bus *bus) { return 0; }
+static inline int pci_get_new_domain_nr(void) { return -ENOSYS; }
 #endif /* CONFIG_PCI_DOMAINS */
 
+/*
+ * Generic implementation for PCI domain support. If your
+ * architecture does not need custom management of PCI
+ * domains then this implementation will be used
+ */
+#ifdef CONFIG_PCI_DOMAINS_GENERIC
+static inline int pci_domain_nr(struct pci_bus *bus)
+{
+        return bus->domain_nr;
+}
+void pci_bus_assign_domain_nr(struct pci_bus *bus, struct device *parent);
+#else
+static inline void pci_bus_assign_domain_nr(struct pci_bus *bus,
+                                        struct device *parent)
+{
+}
+#endif
+
 /* some architectures require additional setup to direct VGA traffic */
 typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
                       unsigned int command_bits, u32 flags);
@@ -1402,6 +1432,7 @@ static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
 
 static inline int pci_domain_nr(struct pci_bus *bus) { return 0; }
 static inline struct pci_dev *pci_dev_get(struct pci_dev *dev) { return NULL; }
+static inline int pci_get_new_domain_nr(void) { return -ENOSYS; }
 
 #define dev_is_pci(d) (false)
 #define dev_is_pf(d) (false)
@@ -1563,16 +1594,11 @@ enum pci_fixup_pass {
 
 #ifdef CONFIG_PCI_QUIRKS
 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) { }
-static inline struct pci_dev *pci_get_dma_source(struct pci_dev *dev)
-{
-        return pci_dev_get(dev);
-}
 static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
                                                u16 acs_flags)
 {
@@ -1707,7 +1733,7 @@ bool pci_acs_path_enabled(struct pci_dev *start,
                           struct pci_dev *end, u16 acs_flags);
 
 #define PCI_VPD_LRDT                    0x80    /* Large Resource Data Type */
-#define PCI_VPD_LRDT_ID(x)              (x | PCI_VPD_LRDT)
+#define PCI_VPD_LRDT_ID(x)              ((x) | PCI_VPD_LRDT)
 
 /* Large Resource Data Type Tag Item Names */
 #define PCI_VPD_LTIN_ID_STRING          0x02    /* Identifier String */
@@ -1834,15 +1860,17 @@ int pci_for_each_dma_alias(struct pci_dev *pdev,
                            int (*fn)(struct pci_dev *pdev,
                                      u16 alias, void *data), void *data);
 
-/**
- * pci_find_upstream_pcie_bridge - find upstream PCIe-to-PCI bridge of a device
- * @pdev: the PCI device
- *
- * if the device is PCIE, return NULL
- * if the device isn't connected to a PCIe bridge (that is its parent is a
- * legacy PCI bridge and the bridge is directly connected to bus 0), return its
- * parent
- */
-struct pci_dev *pci_find_upstream_pcie_bridge(struct pci_dev *pdev);
-
+/* helper functions for operation of device flag */
+static inline void pci_set_dev_assigned(struct pci_dev *pdev)
+{
+        pdev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED;
+}
+static inline void pci_clear_dev_assigned(struct pci_dev *pdev)
+{
+        pdev->dev_flags &= ~PCI_DEV_FLAGS_ASSIGNED;
+}
+static inline bool pci_is_dev_assigned(struct pci_dev *pdev)
+{
+        return (pdev->dev_flags & PCI_DEV_FLAGS_ASSIGNED) == PCI_DEV_FLAGS_ASSIGNED;
+}
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index 5f2e559af6b0..8c7895061121 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -109,7 +109,6 @@ struct hotplug_slot {
         struct list_head                slot_list;
         struct pci_slot                 *pci_slot;
 };
-#define to_hotplug_slot(n) container_of(n, struct hotplug_slot, kobj)
 
 static inline const char *hotplug_slot_name(const struct hotplug_slot *slot)
 {
@@ -187,6 +186,4 @@ static inline int pci_get_hp_params(struct pci_dev *dev,
         return -ENODEV;
 }
 #endif
-
-void pci_configure_slot(struct pci_dev *dev);
 #endif
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 6ed0bb73a864..e63c02a93f6b 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -522,6 +522,8 @@
 #define PCI_DEVICE_ID_AMD_15H_M10H_F3   0x1403
 #define PCI_DEVICE_ID_AMD_15H_M30H_NB_F3 0x141d
 #define PCI_DEVICE_ID_AMD_15H_M30H_NB_F4 0x141e
+#define PCI_DEVICE_ID_AMD_15H_M60H_NB_F3 0x1573
+#define PCI_DEVICE_ID_AMD_15H_M60H_NB_F4 0x1574
 #define PCI_DEVICE_ID_AMD_15H_NB_F0     0x1600
 #define PCI_DEVICE_ID_AMD_15H_NB_F1     0x1601
 #define PCI_DEVICE_ID_AMD_15H_NB_F2     0x1602
@@ -562,6 +564,7 @@
 #define PCI_DEVICE_ID_AMD_8131_BRIDGE   0x7450
 #define PCI_DEVICE_ID_AMD_8131_APIC     0x7451
 #define PCI_DEVICE_ID_AMD_8132_BRIDGE   0x7458
+#define PCI_DEVICE_ID_AMD_NL_USB        0x7912
 #define PCI_DEVICE_ID_AMD_CS5535_IDE    0x208F
 #define PCI_DEVICE_ID_AMD_CS5536_ISA    0x2090
 #define PCI_DEVICE_ID_AMD_CS5536_FLASH  0x2091
@@ -2245,6 +2248,8 @@
 #define PCI_VENDOR_ID_MORETON           0x15aa
 #define PCI_DEVICE_ID_RASTEL_2PORT      0x2000
 
+#define PCI_VENDOR_ID_VMWARE            0x15ad
+
 #define PCI_VENDOR_ID_ZOLTRIX           0x15b0
 #define PCI_DEVICE_ID_ZOLTRIX_2BD0      0x2bd0
 
@@ -2536,6 +2541,7 @@
 #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_IVB_E3_IMC  0x0150
 #define PCI_DEVICE_ID_INTEL_HSW_IMC     0x0c00
 #define PCI_DEVICE_ID_INTEL_PXHD_0      0x0320
 #define PCI_DEVICE_ID_INTEL_PXHD_1      0x0321
@@ -2557,6 +2563,7 @@
 #define PCI_DEVICE_ID_INTEL_MFD_EMMC0   0x0823
 #define PCI_DEVICE_ID_INTEL_MFD_EMMC1   0x0824
 #define PCI_DEVICE_ID_INTEL_MRST_SD2    0x084F
+#define PCI_DEVICE_ID_INTEL_QUARK_X1000_ILB     0x095E
 #define PCI_DEVICE_ID_INTEL_I960        0x0960
 #define PCI_DEVICE_ID_INTEL_I960RM      0x0962
 #define PCI_DEVICE_ID_INTEL_CENTERTON_ILB       0x0c60
@@ -2818,7 +2825,22 @@
 #define PCI_DEVICE_ID_INTEL_UNC_R2PCIE  0x3c43
 #define PCI_DEVICE_ID_INTEL_UNC_R3QPI0  0x3c44
 #define PCI_DEVICE_ID_INTEL_UNC_R3QPI1  0x3c45
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_RAS     0x3c71  /* 15.1 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_ERR0    0x3c72  /* 16.2 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_ERR1    0x3c73  /* 16.3 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_ERR2    0x3c76  /* 16.6 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_ERR3    0x3c77  /* 16.7 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_HA0     0x3ca0  /* 14.0 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_TA      0x3ca8  /* 15.0 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_TAD0    0x3caa  /* 15.2 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_TAD1    0x3cab  /* 15.3 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_TAD2    0x3cac  /* 15.4 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_TAD3    0x3cad  /* 15.5 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_IMC_DDRIO   0x3cb8  /* 17.0 */
 #define PCI_DEVICE_ID_INTEL_JAKETOWN_UBOX       0x3ce0
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_SAD0        0x3cf4  /* 12.6 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_BR          0x3cf5  /* 13.6 */
+#define PCI_DEVICE_ID_INTEL_SBRIDGE_SAD1        0x3cf6  /* 12.7 */
 #define PCI_DEVICE_ID_INTEL_IOAT_SNB    0x402f
 #define PCI_DEVICE_ID_INTEL_5100_16     0x65f0
 #define PCI_DEVICE_ID_INTEL_5100_19     0x65f3
@@ -2860,6 +2882,7 @@
 #define PCI_DEVICE_ID_INTEL_82372FB_1   0x7601
 #define PCI_DEVICE_ID_INTEL_SCH_LPC     0x8119
 #define PCI_DEVICE_ID_INTEL_SCH_IDE     0x811a
+#define PCI_DEVICE_ID_INTEL_E6XX_CU     0x8183
 #define PCI_DEVICE_ID_INTEL_ITC_LPC     0x8186
 #define PCI_DEVICE_ID_INTEL_82454GX     0x84c4
 #define PCI_DEVICE_ID_INTEL_82450GX     0x84c5
diff --git a/include/linux/percpu-defs.h b/include/linux/percpu-defs.h
index cfd56046ecec..57f3a1c550dc 100644
--- a/include/linux/percpu-defs.h
+++ b/include/linux/percpu-defs.h
@@ -254,11 +254,6 @@ do {									\
 #endif  /* CONFIG_SMP */
 
 #define per_cpu(var, cpu)       (*per_cpu_ptr(&(var), cpu))
-#define __raw_get_cpu_var(var)  (*raw_cpu_ptr(&(var)))
-#define __get_cpu_var(var)      (*this_cpu_ptr(&(var)))
-
-/* keep until we have removed all uses of __this_cpu_ptr */
-#define __this_cpu_ptr(ptr)     raw_cpu_ptr(ptr)
 
 /*
  * Must be an lvalue. Since @var must be a simple identifier,
diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
index ef5894ca8e50..b4337646388b 100644
--- a/include/linux/percpu-refcount.h
+++ b/include/linux/percpu-refcount.h
@@ -13,7 +13,7 @@
  *
  * The refcount will have a range of 0 to ((1U << 31) - 1), i.e. one bit less
  * than an atomic_t - this is because of the way shutdown works, see
- * percpu_ref_kill()/PCPU_COUNT_BIAS.
+ * percpu_ref_kill()/PERCPU_COUNT_BIAS.
  *
  * Before you call percpu_ref_kill(), percpu_ref_put() does not check for the
  * refcount hitting 0 - it can't, if it was in percpu mode. percpu_ref_kill()
@@ -29,7 +29,7 @@
  * calls io_destroy() or the process exits.
  *
  * In the aio code, kill_ioctx() is called when we wish to destroy a kioctx; it
- * calls percpu_ref_kill(), then hlist_del_rcu() and sychronize_rcu() to remove
+ * calls percpu_ref_kill(), then hlist_del_rcu() and synchronize_rcu() to remove
  * the kioctx from the proccess's list of kioctxs - after that, there can't be
  * any new users of the kioctx (from lookup_ioctx()) and it's then safe to drop
  * the initial ref with percpu_ref_put().
@@ -49,29 +49,60 @@
 #include <linux/kernel.h>
 #include <linux/percpu.h>
 #include <linux/rcupdate.h>
+#include <linux/gfp.h>
 
 struct percpu_ref;
 typedef void (percpu_ref_func_t)(struct percpu_ref *);
 
+/* flags set in the lower bits of percpu_ref->percpu_count_ptr */
+enum {
+        __PERCPU_REF_ATOMIC     = 1LU << 0,     /* operating in atomic mode */
+        __PERCPU_REF_DEAD       = 1LU << 1,     /* (being) killed */
+        __PERCPU_REF_ATOMIC_DEAD = __PERCPU_REF_ATOMIC | __PERCPU_REF_DEAD,
+
+        __PERCPU_REF_FLAG_BITS  = 2,
+};
+
+/* @flags for percpu_ref_init() */
+enum {
+        /*
+         * Start w/ ref == 1 in atomic mode.  Can be switched to percpu
+         * operation using percpu_ref_switch_to_percpu().  If initialized
+         * with this flag, the ref will stay in atomic mode until
+         * percpu_ref_switch_to_percpu() is invoked on it.
+         */
+        PERCPU_REF_INIT_ATOMIC  = 1 << 0,
+
+        /*
+         * Start dead w/ ref == 0 in atomic mode.  Must be revived with
+         * percpu_ref_reinit() before used.  Implies INIT_ATOMIC.
+         */
+        PERCPU_REF_INIT_DEAD    = 1 << 1,
+};
+
 struct percpu_ref {
-        atomic_t                count;
+        atomic_long_t           count;
         /*
          * The low bit of the pointer indicates whether the ref is in percpu
          * mode; if set, then get/put will manipulate the atomic_t.
          */
-        unsigned long           pcpu_count_ptr;
+        unsigned long           percpu_count_ptr;
         percpu_ref_func_t       *release;
-        percpu_ref_func_t       *confirm_kill;
+        percpu_ref_func_t       *confirm_switch;
+        bool                    force_atomic:1;
         struct rcu_head         rcu;
 };
 
 int __must_check percpu_ref_init(struct percpu_ref *ref,
-                                 percpu_ref_func_t *release);
-void percpu_ref_reinit(struct percpu_ref *ref);
+                                 percpu_ref_func_t *release, unsigned int flags,
+                                 gfp_t gfp);
 void percpu_ref_exit(struct percpu_ref *ref);
+void percpu_ref_switch_to_atomic(struct percpu_ref *ref,
+                                 percpu_ref_func_t *confirm_switch);
+void percpu_ref_switch_to_percpu(struct percpu_ref *ref);
 void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
                                  percpu_ref_func_t *confirm_kill);
-void __percpu_ref_kill_expedited(struct percpu_ref *ref);
+void percpu_ref_reinit(struct percpu_ref *ref);
 
 /**
  * percpu_ref_kill - drop the initial ref
@@ -88,70 +119,88 @@ static inline void percpu_ref_kill(struct percpu_ref *ref)
         return percpu_ref_kill_and_confirm(ref, NULL);
 }
 
-#define PCPU_REF_DEAD           1
-
 /*
  * Internal helper.  Don't use outside percpu-refcount proper.  The
  * function doesn't return the pointer and let the caller test it for NULL
  * because doing so forces the compiler to generate two conditional
- * branches as it can't assume that @ref->pcpu_count is not NULL.
+ * branches as it can't assume that @ref->percpu_count is not NULL.
  */
-static inline bool __pcpu_ref_alive(struct percpu_ref *ref,
-                                    unsigned __percpu **pcpu_countp)
+static inline bool __ref_is_percpu(struct percpu_ref *ref,
+                                          unsigned long __percpu **percpu_countp)
 {
-        unsigned long pcpu_ptr = ACCESS_ONCE(ref->pcpu_count_ptr);
-
         /* paired with smp_store_release() in percpu_ref_reinit() */
-        smp_read_barrier_depends();
+        unsigned long percpu_ptr = lockless_dereference(ref->percpu_count_ptr);
 
-        if (unlikely(pcpu_ptr & PCPU_REF_DEAD))
+        /*
+         * Theoretically, the following could test just ATOMIC; however,
+         * then we'd have to mask off DEAD separately as DEAD may be
+         * visible without ATOMIC if we race with percpu_ref_kill().  DEAD
+         * implies ATOMIC anyway.  Test them together.
+         */
+        if (unlikely(percpu_ptr & __PERCPU_REF_ATOMIC_DEAD))
                 return false;
 
-        *pcpu_countp = (unsigned __percpu *)pcpu_ptr;
+        *percpu_countp = (unsigned long __percpu *)percpu_ptr;
         return true;
 }
 
 /**
- * percpu_ref_get - increment a percpu refcount
+ * percpu_ref_get_many - increment a percpu refcount
  * @ref: percpu_ref to get
+ * @nr: number of references to get
  *
- * Analagous to atomic_inc().
-  */
-static inline void percpu_ref_get(struct percpu_ref *ref)
+ * Analogous to atomic_long_add().
+ *
+ * This function is safe to call as long as @ref is between init and exit.
+ */
+static inline void percpu_ref_get_many(struct percpu_ref *ref, unsigned long nr)
 {
-        unsigned __percpu *pcpu_count;
+        unsigned long __percpu *percpu_count;
 
         rcu_read_lock_sched();
 
-        if (__pcpu_ref_alive(ref, &pcpu_count))
-                this_cpu_inc(*pcpu_count);
+        if (__ref_is_percpu(ref, &percpu_count))
+                this_cpu_add(*percpu_count, nr);
         else
-                atomic_inc(&ref->count);
+                atomic_long_add(nr, &ref->count);
 
         rcu_read_unlock_sched();
 }
 
 /**
+ * percpu_ref_get - increment a percpu refcount
+ * @ref: percpu_ref to get
+ *
+ * Analagous to atomic_long_inc().
+ *
+ * This function is safe to call as long as @ref is between init and exit.
+ */
+static inline void percpu_ref_get(struct percpu_ref *ref)
+{
+        percpu_ref_get_many(ref, 1);
+}
+
+/**
  * percpu_ref_tryget - try to increment a percpu refcount
  * @ref: percpu_ref to try-get
  *
  * Increment a percpu refcount unless its count already reached zero.
  * Returns %true on success; %false on failure.
  *
- * The caller is responsible for ensuring that @ref stays accessible.
+ * This function is safe to call as long as @ref is between init and exit.
  */
 static inline bool percpu_ref_tryget(struct percpu_ref *ref)
 {
-        unsigned __percpu *pcpu_count;
-        int ret = false;
+        unsigned long __percpu *percpu_count;
+        int ret;
 
         rcu_read_lock_sched();
 
-        if (__pcpu_ref_alive(ref, &pcpu_count)) {
-                this_cpu_inc(*pcpu_count);
+        if (__ref_is_percpu(ref, &percpu_count)) {
+                this_cpu_inc(*percpu_count);
                 ret = true;
         } else {
-                ret = atomic_inc_not_zero(&ref->count);
+                ret = atomic_long_inc_not_zero(&ref->count);
         }
 
         rcu_read_unlock_sched();
@@ -166,23 +215,26 @@ static inline bool percpu_ref_tryget(struct percpu_ref *ref)
  * Increment a percpu refcount unless it has already been killed.  Returns
  * %true on success; %false on failure.
  *
- * Completion of percpu_ref_kill() in itself doesn't guarantee that tryget
- * will fail.  For such guarantee, percpu_ref_kill_and_confirm() should be
- * used.  After the confirm_kill callback is invoked, it's guaranteed that
- * no new reference will be given out by percpu_ref_tryget().
+ * Completion of percpu_ref_kill() in itself doesn't guarantee that this
+ * function will fail.  For such guarantee, percpu_ref_kill_and_confirm()
+ * should be used.  After the confirm_kill callback is invoked, it's
+ * guaranteed that no new reference will be given out by
+ * percpu_ref_tryget_live().
  *
- * The caller is responsible for ensuring that @ref stays accessible.
+ * This function is safe to call as long as @ref is between init and exit.
  */
 static inline bool percpu_ref_tryget_live(struct percpu_ref *ref)
 {
-        unsigned __percpu *pcpu_count;
+        unsigned long __percpu *percpu_count;
         int ret = false;
 
         rcu_read_lock_sched();
 
-        if (__pcpu_ref_alive(ref, &pcpu_count)) {
-                this_cpu_inc(*pcpu_count);
+        if (__ref_is_percpu(ref, &percpu_count)) {
+                this_cpu_inc(*percpu_count);
                 ret = true;
+        } else if (!(ACCESS_ONCE(ref->percpu_count_ptr) & __PERCPU_REF_DEAD)) {
+                ret = atomic_long_inc_not_zero(&ref->count);
         }
 
         rcu_read_unlock_sched();
@@ -191,39 +243,58 @@ static inline bool percpu_ref_tryget_live(struct percpu_ref *ref)
 }
 
 /**
- * percpu_ref_put - decrement a percpu refcount
+ * percpu_ref_put_many - decrement a percpu refcount
  * @ref: percpu_ref to put
+ * @nr: number of references to put
  *
  * Decrement the refcount, and if 0, call the release function (which was passed
  * to percpu_ref_init())
+ *
+ * This function is safe to call as long as @ref is between init and exit.
  */
-static inline void percpu_ref_put(struct percpu_ref *ref)
+static inline void percpu_ref_put_many(struct percpu_ref *ref, unsigned long nr)
 {
-        unsigned __percpu *pcpu_count;
+        unsigned long __percpu *percpu_count;
 
         rcu_read_lock_sched();
 
-        if (__pcpu_ref_alive(ref, &pcpu_count))
-                this_cpu_dec(*pcpu_count);
-        else if (unlikely(atomic_dec_and_test(&ref->count)))
+        if (__ref_is_percpu(ref, &percpu_count))
+                this_cpu_sub(*percpu_count, nr);
+        else if (unlikely(atomic_long_sub_and_test(nr, &ref->count)))
                 ref->release(ref);
 
         rcu_read_unlock_sched();
 }
 
 /**
+ * percpu_ref_put - decrement a percpu refcount
+ * @ref: percpu_ref to put
+ *
+ * Decrement the refcount, and if 0, call the release function (which was passed
+ * to percpu_ref_init())
+ *
+ * This function is safe to call as long as @ref is between init and exit.
+ */
+static inline void percpu_ref_put(struct percpu_ref *ref)
+{
+        percpu_ref_put_many(ref, 1);
+}
+
+/**
  * percpu_ref_is_zero - test whether a percpu refcount reached zero
  * @ref: percpu_ref to test
  *
  * Returns %true if @ref reached zero.
+ *
+ * This function is safe to call as long as @ref is between init and exit.
  */
 static inline bool percpu_ref_is_zero(struct percpu_ref *ref)
 {
-        unsigned __percpu *pcpu_count;
+        unsigned long __percpu *percpu_count;
 
-        if (__pcpu_ref_alive(ref, &pcpu_count))
+        if (__ref_is_percpu(ref, &percpu_count))
                 return false;
-        return !atomic_read(&ref->count);
+        return !atomic_long_read(&ref->count);
 }
 
 #endif
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 6f61b61b7996..caebf2a758dc 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -5,6 +5,7 @@
 #include <linux/preempt.h>
 #include <linux/smp.h>
 #include <linux/cpumask.h>
+#include <linux/printk.h>
 #include <linux/pfn.h>
 #include <linux/init.h>
 
@@ -48,9 +49,9 @@
  * intelligent way to determine this would be nice.
  */
 #if BITS_PER_LONG > 32
-#define PERCPU_DYNAMIC_RESERVE          (20 << 10)
+#define PERCPU_DYNAMIC_RESERVE          (28 << 10)
 #else
-#define PERCPU_DYNAMIC_RESERVE          (12 << 10)
+#define PERCPU_DYNAMIC_RESERVE          (20 << 10)
 #endif
 
 extern void *pcpu_base_addr;
@@ -122,11 +123,19 @@ extern void __init setup_per_cpu_areas(void);
 #endif
 extern void __init percpu_init_late(void);
 
+extern void __percpu *__alloc_percpu_gfp(size_t size, size_t align, gfp_t gfp);
 extern void __percpu *__alloc_percpu(size_t size, size_t align);
 extern void free_percpu(void __percpu *__pdata);
 extern phys_addr_t per_cpu_ptr_to_phys(void *addr);
 
-#define alloc_percpu(type)      \
-        (typeof(type) __percpu *)__alloc_percpu(sizeof(type), __alignof__(type))
+#define alloc_percpu_gfp(type, gfp)                                     \
+        (typeof(type) __percpu *)__alloc_percpu_gfp(sizeof(type),       \
+                                                __alignof__(type), gfp)
+#define alloc_percpu(type)                                              \
+        (typeof(type) __percpu *)__alloc_percpu(sizeof(type),           \
+                                                __alignof__(type))
+
+/* To avoid include hell, as printk can not declare this, we declare it here */
+DECLARE_PER_CPU(printk_func_t, printk_func);
 
 #endif /* __LINUX_PERCPU_H */
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index d5dd4657c8d6..50e50095c8d1 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -12,6 +12,7 @@
 #include <linux/threads.h>
 #include <linux/percpu.h>
 #include <linux/types.h>
+#include <linux/gfp.h>
 
 #ifdef CONFIG_SMP
 
@@ -26,14 +27,14 @@ struct percpu_counter {
 
 extern int percpu_counter_batch;
 
-int __percpu_counter_init(struct percpu_counter *fbc, s64 amount,
+int __percpu_counter_init(struct percpu_counter *fbc, s64 amount, gfp_t gfp,
                           struct lock_class_key *key);
 
-#define percpu_counter_init(fbc, value)                                 \
+#define percpu_counter_init(fbc, value, gfp)                            \
         ({                                                              \
                 static struct lock_class_key __key;                     \
                                                                         \
-                __percpu_counter_init(fbc, value, &__key);              \
+                __percpu_counter_init(fbc, value, gfp, &__key);         \
         })
 
 void percpu_counter_destroy(struct percpu_counter *fbc);
@@ -89,7 +90,8 @@ struct percpu_counter {
         s64 count;
 };
 
-static inline int percpu_counter_init(struct percpu_counter *fbc, s64 amount)
+static inline int percpu_counter_init(struct percpu_counter *fbc, s64 amount,
+                                      gfp_t gfp)
 {
         fbc->count = amount;
         return 0;
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 707617a8c0f6..4f7a61ca4b39 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -52,6 +52,7 @@ struct perf_guest_info_callbacks {
 #include <linux/atomic.h>
 #include <linux/sysfs.h>
 #include <linux/perf_regs.h>
+#include <linux/workqueue.h>
 #include <asm/local.h>
 
 struct perf_callchain_entry {
@@ -78,11 +79,6 @@ struct perf_branch_stack {
         struct perf_branch_entry        entries[0];
 };
 
-struct perf_regs_user {
-        __u64           abi;
-        struct pt_regs  *regs;
-};
-
 struct task_struct;
 
 /*
@@ -268,6 +264,7 @@ struct pmu {
  * enum perf_event_active_state - the states of a event
  */
 enum perf_event_active_state {
+        PERF_EVENT_STATE_EXIT           = -3,
         PERF_EVENT_STATE_ERROR          = -2,
         PERF_EVENT_STATE_OFF            = -1,
         PERF_EVENT_STATE_INACTIVE       =  0,
@@ -507,6 +504,9 @@ struct perf_event_context {
         int                             nr_cgroups;      /* cgroup evts */
         int                             nr_branch_stack; /* branch_stack evt */
         struct rcu_head                 rcu_head;
+
+        struct delayed_work             orphans_remove;
+        bool                            orphans_remove_sched;
 };
 
 /*
@@ -575,34 +575,54 @@ extern u64 perf_event_read_value(struct perf_event *event,
 
 
 struct perf_sample_data {
-        u64                             type;
+        /*
+         * Fields set by perf_sample_data_init(), group so as to
+         * minimize the cachelines touched.
+         */
+        u64                             addr;
+        struct perf_raw_record          *raw;
+        struct perf_branch_stack        *br_stack;
+        u64                             period;
+        u64                             weight;
+        u64                             txn;
+        union  perf_mem_data_src        data_src;
 
+        /*
+         * The other fields, optionally {set,used} by
+         * perf_{prepare,output}_sample().
+         */
+        u64                             type;
         u64                             ip;
         struct {
                 u32     pid;
                 u32     tid;
         }                               tid_entry;
         u64                             time;
-        u64                             addr;
         u64                             id;
         u64                             stream_id;
         struct {
                 u32     cpu;
                 u32     reserved;
         }                               cpu_entry;
-        u64                             period;
-        union  perf_mem_data_src        data_src;
         struct perf_callchain_entry     *callchain;
-        struct perf_raw_record          *raw;
-        struct perf_branch_stack        *br_stack;
-        struct perf_regs_user           regs_user;
-        u64                             stack_user_size;
-        u64                             weight;
+
         /*
-         * Transaction flags for abort events:
+         * regs_user may point to task_pt_regs or to regs_user_copy, depending
+         * on arch details.
          */
-        u64                             txn;
-};
+        struct perf_regs                regs_user;
+        struct pt_regs                  regs_user_copy;
+
+        struct perf_regs                regs_intr;
+        u64                             stack_user_size;
+} ____cacheline_aligned;
+
+/* default value for data source */
+#define PERF_MEM_NA (PERF_MEM_S(OP, NA)   |\
+                    PERF_MEM_S(LVL, NA)   |\
+                    PERF_MEM_S(SNOOP, NA) |\
+                    PERF_MEM_S(LOCK, NA)  |\
+                    PERF_MEM_S(TLB, NA))
 
 static inline void perf_sample_data_init(struct perf_sample_data *data,
                                          u64 addr, u64 period)
@@ -612,11 +632,8 @@ static inline void perf_sample_data_init(struct perf_sample_data *data,
         data->raw  = NULL;
         data->br_stack = NULL;
         data->period = period;
-        data->regs_user.abi = PERF_SAMPLE_REGS_ABI_NONE;
-        data->regs_user.regs = NULL;
-        data->stack_user_size = 0;
         data->weight = 0;
-        data->data_src.val = 0;
+        data->data_src.val = PERF_MEM_NA;
         data->txn = 0;
 }
 
diff --git a/include/linux/perf_regs.h b/include/linux/perf_regs.h
index 3c73d5fe18be..a5f98d53d732 100644
--- a/include/linux/perf_regs.h
+++ b/include/linux/perf_regs.h
@@ -1,11 +1,19 @@
 #ifndef _LINUX_PERF_REGS_H
 #define _LINUX_PERF_REGS_H
 
+struct perf_regs {
+        __u64           abi;
+        struct pt_regs  *regs;
+};
+
 #ifdef CONFIG_HAVE_PERF_REGS
 #include <asm/perf_regs.h>
 u64 perf_reg_value(struct pt_regs *regs, int idx);
 int perf_reg_validate(u64 mask);
 u64 perf_reg_abi(struct task_struct *task);
+void perf_get_regs_user(struct perf_regs *regs_user,
+                        struct pt_regs *regs,
+                        struct pt_regs *regs_user_copy);
 #else
 static inline u64 perf_reg_value(struct pt_regs *regs, int idx)
 {
@@ -21,5 +29,13 @@ static inline u64 perf_reg_abi(struct task_struct *task)
 {
         return PERF_SAMPLE_REGS_ABI_NONE;
 }
+
+static inline void perf_get_regs_user(struct perf_regs *regs_user,
+                                      struct pt_regs *regs,
+                                      struct pt_regs *regs_user_copy)
+{
+        regs_user->regs = task_pt_regs(current);
+        regs_user->abi = perf_reg_abi(current);
+}
 #endif /* CONFIG_HAVE_PERF_REGS */
 #endif /* _LINUX_PERF_REGS_H */
diff --git a/include/linux/phonedev.h b/include/linux/phonedev.h
deleted file mode 100644
index 4269de99e320..000000000000
--- a/include/linux/phonedev.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef __LINUX_PHONEDEV_H
-#define __LINUX_PHONEDEV_H
-
-#include <linux/types.h>
-
-#ifdef __KERNEL__
-
-#include <linux/poll.h>
-
-struct phone_device {
-        struct phone_device *next;
-        const struct file_operations *f_op;
-        int (*open) (struct phone_device *, struct file *);
-        int board;              /* Device private index */
-        int minor;
-};
-
-extern int phonedev_init(void);
-#define PHONE_MAJOR     100
-extern int phone_register_device(struct phone_device *, int unit);
-#define PHONE_UNIT_ANY  -1
-extern void phone_unregister_device(struct phone_device *);
-
-#endif
-#endif
diff --git a/include/linux/phy.h b/include/linux/phy.h
index ed39956b5613..22af8f8f5802 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -433,6 +433,7 @@ struct phy_device {
  *   by this PHY
  * flags: A bitfield defining certain other features this PHY
  *   supports (like interrupts)
+ * driver_data: static driver data
  *
  * The drivers must implement config_aneg and read_status.  All
  * other functions are optional. Note that none of these
@@ -448,6 +449,7 @@ struct phy_driver {
         unsigned int phy_id_mask;
         u32 features;
         u32 flags;
+        const void *driver_data;
 
         /*
          * Called to issue a PHY software reset
@@ -598,6 +600,19 @@ static inline int phy_read_mmd(struct phy_device *phydev, int devad, u32 regnum)
 }
 
 /**
+ * phy_read_mmd_indirect - reads data from the MMD registers
+ * @phydev: The PHY device bus
+ * @prtad: MMD Address
+ * @devad: MMD DEVAD
+ * @addr: PHY address on the MII bus
+ *
+ * Description: it reads data from the MMD registers (clause 22 to access to
+ * clause 45) of the specified phy address.
+ */
+int phy_read_mmd_indirect(struct phy_device *phydev, int prtad,
+                          int devad, int addr);
+
+/**
  * phy_read - Convenience function for reading a given PHY register
  * @phydev: the phy_device struct
  * @regnum: register number to read
@@ -668,6 +683,20 @@ static inline int phy_write_mmd(struct phy_device *phydev, int devad,
         return mdiobus_write(phydev->bus, phydev->addr, regnum, val);
 }
 
+/**
+ * phy_write_mmd_indirect - writes data to the MMD registers
+ * @phydev: The PHY device
+ * @prtad: MMD Address
+ * @devad: MMD DEVAD
+ * @addr: PHY address on the MII bus
+ * @data: data to write in the MMD register
+ *
+ * Description: Write data from the MMD registers of the specified
+ * phy address.
+ */
+void phy_write_mmd_indirect(struct phy_device *phydev, int prtad,
+                            int devad, int addr, u32 data);
+
 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
                                      bool is_c45,
                                      struct phy_c45_device_ids *c45_ids);
@@ -745,4 +774,28 @@ int __init mdio_bus_init(void);
 void mdio_bus_exit(void);
 
 extern struct bus_type mdio_bus_type;
+
+/**
+ * module_phy_driver() - Helper macro for registering PHY drivers
+ * @__phy_drivers: array of PHY drivers to register
+ *
+ * Helper macro for PHY drivers which do not do anything special in module
+ * init/exit. Each module may only use this macro once, and calling it
+ * replaces module_init() and module_exit().
+ */
+#define phy_module_driver(__phy_drivers, __count)                       \
+static int __init phy_module_init(void)                                 \
+{                                                                       \
+        return phy_drivers_register(__phy_drivers, __count);            \
+}                                                                       \
+module_init(phy_module_init);                                           \
+static void __exit phy_module_exit(void)                                \
+{                                                                       \
+        phy_drivers_unregister(__phy_drivers, __count);                 \
+}                                                                       \
+module_exit(phy_module_exit)
+
+#define module_phy_driver(__phy_drivers)                                \
+        phy_module_driver(__phy_drivers, ARRAY_SIZE(__phy_drivers))
+
 #endif /* __PHY_H */
diff --git a/include/linux/phy/phy.h b/include/linux/phy/phy.h
index 8cb6f815475b..a0197fa1b116 100644
--- a/include/linux/phy/phy.h
+++ b/include/linux/phy/phy.h
@@ -61,7 +61,6 @@ struct phy {
         struct device           dev;
         int                     id;
         const struct phy_ops    *ops;
-        struct phy_init_data    *init_data;
         struct mutex            mutex;
         int                     init_count;
         int                     power_count;
@@ -84,33 +83,14 @@ struct phy_provider {
                 struct of_phandle_args *args);
 };
 
-/**
- * struct phy_consumer - represents the phy consumer
- * @dev_name: the device name of the controller that will use this PHY device
- * @port: name given to the consumer port
- */
-struct phy_consumer {
-        const char *dev_name;
-        const char *port;
-};
-
-/**
- * struct phy_init_data - contains the list of PHY consumers
- * @num_consumers: number of consumers for this PHY device
- * @consumers: list of PHY consumers
- */
-struct phy_init_data {
-        unsigned int num_consumers;
-        struct phy_consumer *consumers;
+struct phy_lookup {
+        struct list_head node;
+        const char *dev_id;
+        const char *con_id;
+        struct phy *phy;
 };
 
-#define PHY_CONSUMER(_dev_name, _port)                          \
-{                                                               \
-        .dev_name       = _dev_name,                            \
-        .port           = _port,                                \
-}
-
-#define to_phy(dev)     (container_of((dev), struct phy, dev))
+#define to_phy(a)       (container_of((a), struct phy, dev))
 
 #define of_phy_provider_register(dev, xlate)    \
         __of_phy_provider_register((dev), THIS_MODULE, (xlate))
@@ -159,10 +139,9 @@ 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, struct device_node *node,
-                       const struct phy_ops *ops,
-                       struct phy_init_data *init_data);
+                       const struct phy_ops *ops);
 struct phy *devm_phy_create(struct device *dev, struct device_node *node,
-        const struct phy_ops *ops, struct phy_init_data *init_data);
+                            const struct phy_ops *ops);
 void phy_destroy(struct phy *phy);
 void devm_phy_destroy(struct device *dev, struct phy *phy);
 struct phy_provider *__of_phy_provider_register(struct device *dev,
@@ -174,6 +153,8 @@ struct phy_provider *__devm_of_phy_provider_register(struct device *dev,
 void of_phy_provider_unregister(struct phy_provider *phy_provider);
 void devm_of_phy_provider_unregister(struct device *dev,
         struct phy_provider *phy_provider);
+int phy_create_lookup(struct phy *phy, const char *con_id, const char *dev_id);
+void phy_remove_lookup(struct phy *phy, const char *con_id, const char *dev_id);
 #else
 static inline int phy_pm_runtime_get(struct phy *phy)
 {
@@ -301,16 +282,14 @@ static inline struct phy *of_phy_simple_xlate(struct device *dev,
 
 static inline struct phy *phy_create(struct device *dev,
                                      struct device_node *node,
-                                     const struct phy_ops *ops,
-                                     struct phy_init_data *init_data)
+                                     const struct phy_ops *ops)
 {
         return ERR_PTR(-ENOSYS);
 }
 
 static inline struct phy *devm_phy_create(struct device *dev,
                                           struct device_node *node,
-                                          const struct phy_ops *ops,
-                                          struct phy_init_data *init_data)
+                                          const struct phy_ops *ops)
 {
         return ERR_PTR(-ENOSYS);
 }
@@ -345,6 +324,13 @@ static inline void devm_of_phy_provider_unregister(struct device *dev,
         struct phy_provider *phy_provider)
 {
 }
+static inline int
+phy_create_lookup(struct phy *phy, const char *con_id, const char *dev_id)
+{
+        return 0;
+}
+static inline void phy_remove_lookup(struct phy *phy, const char *con_id,
+                                     const char *dev_id) { }
 #endif
 
 #endif /* __DRIVERS_PHY_H */
diff --git a/include/linux/phy_fixed.h b/include/linux/phy_fixed.h
index ae612acebb53..7e75bfe37cc7 100644
--- a/include/linux/phy_fixed.h
+++ b/include/linux/phy_fixed.h
@@ -11,37 +11,38 @@ struct fixed_phy_status {
 
 struct device_node;
 
-#ifdef CONFIG_FIXED_PHY
+#if IS_ENABLED(CONFIG_FIXED_PHY)
 extern int fixed_phy_add(unsigned int irq, int phy_id,
                          struct fixed_phy_status *status);
-extern int fixed_phy_register(unsigned int irq,
-                              struct fixed_phy_status *status,
-                              struct device_node *np);
+extern struct phy_device *fixed_phy_register(unsigned int irq,
+                                             struct fixed_phy_status *status,
+                                             struct device_node *np);
 extern void fixed_phy_del(int phy_addr);
+extern int fixed_phy_set_link_update(struct phy_device *phydev,
+                        int (*link_update)(struct net_device *,
+                                           struct fixed_phy_status *));
 #else
 static inline int fixed_phy_add(unsigned int irq, int phy_id,
                                 struct fixed_phy_status *status)
 {
         return -ENODEV;
 }
-static inline int fixed_phy_register(unsigned int irq,
-                                     struct fixed_phy_status *status,
-                                     struct device_node *np)
+static inline struct phy_device *fixed_phy_register(unsigned int irq,
+                                                struct fixed_phy_status *status,
+                                                struct device_node *np)
 {
-        return -ENODEV;
+        return ERR_PTR(-ENODEV);
 }
 static inline int fixed_phy_del(int phy_addr)
 {
         return -ENODEV;
 }
-#endif /* CONFIG_FIXED_PHY */
-
-/*
- * This function issued only by fixed_phy-aware drivers, no need
- * protect it with #ifdef
- */
-extern int fixed_phy_set_link_update(struct phy_device *phydev,
+static inline int fixed_phy_set_link_update(struct phy_device *phydev,
                         int (*link_update)(struct net_device *,
-                                           struct fixed_phy_status *));
+                                           struct fixed_phy_status *))
+{
+        return -ENODEV;
+}
+#endif /* CONFIG_FIXED_PHY */
 
 #endif /* __PHY_FIXED_H */
diff --git a/include/linux/pid_namespace.h b/include/linux/pid_namespace.h
index 1997ffc295a7..b9cf6c51b181 100644
--- a/include/linux/pid_namespace.h
+++ b/include/linux/pid_namespace.h
@@ -8,6 +8,7 @@
 #include <linux/threads.h>
 #include <linux/nsproxy.h>
 #include <linux/kref.h>
+#include <linux/ns_common.h>
 
 struct pidmap {
        atomic_t nr_free;
@@ -43,7 +44,7 @@ struct pid_namespace {
         kgid_t pid_gid;
         int hide_pid;
         int reboot;     /* group exit code if this pidns was rebooted */
-        unsigned int proc_inum;
+        struct ns_common ns;
 };
 
 extern struct pid_namespace init_pid_ns;
diff --git a/include/linux/pinctrl/pinconf-generic.h b/include/linux/pinctrl/pinconf-generic.h
index a15f10727eb8..d578a60eff23 100644
--- a/include/linux/pinctrl/pinconf-generic.h
+++ b/include/linux/pinctrl/pinconf-generic.h
@@ -57,7 +57,7 @@
  *      which are then pulled up with an external resistor. Setting this
  *      config will enable open drain mode, the argument is ignored.
  * @PIN_CONFIG_DRIVE_OPEN_SOURCE: the pin will be driven with open source
- *      (open emitter). Setting this config will enable open drain mode, the
+ *      (open emitter). Setting this config will enable open source mode, the
  *      argument is ignored.
  * @PIN_CONFIG_DRIVE_STRENGTH: the pin will sink or source at most the current
  *      passed as argument. The argument is in mA.
diff --git a/include/linux/pinctrl/pinmux.h b/include/linux/pinctrl/pinmux.h
index 3097aafbeb24..511bda9ed4bf 100644
--- a/include/linux/pinctrl/pinmux.h
+++ b/include/linux/pinctrl/pinmux.h
@@ -39,13 +39,12 @@ struct pinctrl_dev;
  *      name can be used with the generic @pinctrl_ops to retrieve the
  *      actual pins affected. The applicable groups will be returned in
  *      @groups and the number of groups in @num_groups
- * @enable: enable a certain muxing function with a certain pin group. The
+ * @set_mux: enable a certain muxing function with a certain pin group. The
  *      driver does not need to figure out whether enabling this function
  *      conflicts some other use of the pins in that group, such collisions
  *      are handled by the pinmux subsystem. The @func_selector selects a
  *      certain function whereas @group_selector selects a certain set of pins
  *      to be used. On simple controllers the latter argument may be ignored
- * @disable: disable a certain muxing selector with a certain pin group
  * @gpio_request_enable: requests and enables GPIO on a certain pin.
  *      Implement this only if you can mux every pin individually as GPIO. The
  *      affected GPIO range is passed along with an offset(pin number) into that
@@ -68,8 +67,8 @@ struct pinmux_ops {
                                   unsigned selector,
                                   const char * const **groups,
                                   unsigned * const num_groups);
-        int (*enable) (struct pinctrl_dev *pctldev, unsigned func_selector,
-                       unsigned group_selector);
+        int (*set_mux) (struct pinctrl_dev *pctldev, unsigned func_selector,
+                        unsigned group_selector);
         int (*gpio_request_enable) (struct pinctrl_dev *pctldev,
                                     struct pinctrl_gpio_range *range,
                                     unsigned offset);
diff --git a/include/linux/mailbox.h b/include/linux/pl320-ipc.h
index 5161f63ec1c8..5161f63ec1c8 100644
--- a/include/linux/mailbox.h
+++ b/include/linux/pl320-ipc.h
diff --git a/include/linux/platform_data/asoc-s3c.h b/include/linux/platform_data/asoc-s3c.h
index a6591c693ebb..5e0bc779e6c5 100644
--- a/include/linux/platform_data/asoc-s3c.h
+++ b/include/linux/platform_data/asoc-s3c.h
@@ -27,6 +27,7 @@ struct samsung_i2s {
 #define QUIRK_NO_MUXPSR         (1 << 2)
 #define QUIRK_NEED_RSTCLR       (1 << 3)
 #define QUIRK_SUPPORTS_TDM      (1 << 4)
+#define QUIRK_SUPPORTS_IDMA     (1 << 5)
         /* Quirks of the I2S controller */
         u32 quirks;
         dma_addr_t idma_addr;
diff --git a/include/linux/platform_data/bcmgenet.h b/include/linux/platform_data/bcmgenet.h
new file mode 100644
index 000000000000..26af54321958
--- /dev/null
+++ b/include/linux/platform_data/bcmgenet.h
@@ -0,0 +1,18 @@
+#ifndef __LINUX_PLATFORM_DATA_BCMGENET_H__
+#define __LINUX_PLATFORM_DATA_BCMGENET_H__
+
+#include <linux/types.h>
+#include <linux/if_ether.h>
+#include <linux/phy.h>
+
+struct bcmgenet_platform_data {
+        bool            mdio_enabled;
+        phy_interface_t phy_interface;
+        int             phy_address;
+        int             phy_speed;
+        int             phy_duplex;
+        u8              mac_address[ETH_ALEN];
+        int             genet_version;
+};
+
+#endif
diff --git a/include/linux/platform_data/dma-dw.h b/include/linux/platform_data/dma-dw.h
new file mode 100644
index 000000000000..d8155c005242
--- /dev/null
+++ b/include/linux/platform_data/dma-dw.h
@@ -0,0 +1,59 @@
+/*
+ * Driver for the Synopsys DesignWare DMA Controller
+ *
+ * Copyright (C) 2007 Atmel Corporation
+ * Copyright (C) 2010-2011 ST Microelectronics
+ *
+ * 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 _PLATFORM_DATA_DMA_DW_H
+#define _PLATFORM_DATA_DMA_DW_H
+
+#include <linux/device.h>
+
+/**
+ * struct dw_dma_slave - Controller-specific information about a slave
+ *
+ * @dma_dev: required DMA master device. Depricated.
+ * @src_id:     src request line
+ * @dst_id:     dst request line
+ * @src_master: src master for transfers on allocated channel.
+ * @dst_master: dest master for transfers on allocated channel.
+ */
+struct dw_dma_slave {
+        struct device           *dma_dev;
+        u8                      src_id;
+        u8                      dst_id;
+        u8                      src_master;
+        u8                      dst_master;
+};
+
+/**
+ * struct dw_dma_platform_data - Controller configuration parameters
+ * @nr_channels: Number of channels supported by hardware (max 8)
+ * @is_private: The device channels should be marked as private and not for
+ *      by the general purpose DMA channel allocator.
+ * @chan_allocation_order: Allocate channels starting from 0 or 7
+ * @chan_priority: Set channel priority increasing from 0 to 7 or 7 to 0.
+ * @block_size: Maximum block size supported by the controller
+ * @nr_masters: Number of AHB masters supported by the controller
+ * @data_width: Maximum data width supported by hardware per AHB master
+ *              (0 - 8bits, 1 - 16bits, ..., 5 - 256bits)
+ */
+struct dw_dma_platform_data {
+        unsigned int    nr_channels;
+        bool            is_private;
+#define CHAN_ALLOCATION_ASCENDING       0       /* zero to seven */
+#define CHAN_ALLOCATION_DESCENDING      1       /* seven to zero */
+        unsigned char   chan_allocation_order;
+#define CHAN_PRIORITY_ASCENDING         0       /* chan0 highest */
+#define CHAN_PRIORITY_DESCENDING        1       /* chan7 highest */
+        unsigned char   chan_priority;
+        unsigned short  block_size;
+        unsigned char   nr_masters;
+        unsigned char   data_width[4];
+};
+
+#endif /* _PLATFORM_DATA_DMA_DW_H */
diff --git a/include/linux/platform_data/dma-imx.h b/include/linux/platform_data/dma-imx.h
index 6a1357d31871..7d964e787299 100644
--- a/include/linux/platform_data/dma-imx.h
+++ b/include/linux/platform_data/dma-imx.h
@@ -41,6 +41,7 @@ enum sdma_peripheral_type {
         IMX_DMATYPE_ESAI,       /* ESAI */
         IMX_DMATYPE_SSI_DUAL,   /* SSI Dual FIFO */
         IMX_DMATYPE_ASRC_SP,    /* Shared ASRC */
+        IMX_DMATYPE_SAI,        /* SAI */
 };
 
 enum imx_dma_prio {
diff --git a/include/linux/platform_data/dwc3-exynos.h b/include/linux/platform_data/dwc3-exynos.h
deleted file mode 100644
index 5eb7da9b3772..000000000000
--- a/include/linux/platform_data/dwc3-exynos.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/**
- * dwc3-exynos.h - Samsung EXYNOS DWC3 Specific Glue layer, header.
- *
- * Copyright (c) 2012 Samsung Electronics Co., Ltd.
- *              http://www.samsung.com
- *
- * Author: Anton Tikhomirov <av.tikhomirov@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 _DWC3_EXYNOS_H_
-#define _DWC3_EXYNOS_H_
-
-struct dwc3_exynos_data {
-        int phy_type;
-        int (*phy_init)(struct platform_device *pdev, int type);
-        int (*phy_exit)(struct platform_device *pdev, int type);
-};
-
-#endif /* _DWC3_EXYNOS_H_ */
diff --git a/include/linux/platform_data/elm.h b/include/linux/platform_data/elm.h
index 780d1e97f620..b8686c00f15f 100644
--- a/include/linux/platform_data/elm.h
+++ b/include/linux/platform_data/elm.h
@@ -42,8 +42,24 @@ struct elm_errorvec {
         int error_loc[16];
 };
 
+#if IS_ENABLED(CONFIG_MTD_NAND_OMAP_BCH)
 void elm_decode_bch_error_page(struct device *dev, u8 *ecc_calc,
                 struct elm_errorvec *err_vec);
 int elm_config(struct device *dev, enum bch_ecc bch_type,
         int ecc_steps, int ecc_step_size, int ecc_syndrome_size);
+#else
+static inline void
+elm_decode_bch_error_page(struct device *dev, u8 *ecc_calc,
+                          struct elm_errorvec *err_vec)
+{
+}
+
+static inline int elm_config(struct device *dev, enum bch_ecc bch_type,
+                             int ecc_steps, int ecc_step_size,
+                             int ecc_syndrome_size)
+{
+        return -ENOSYS;
+}
+#endif /* CONFIG_MTD_NAND_ECC_BCH */
+
 #endif /* __ELM_H */
diff --git a/include/linux/platform_data/gpio-dwapb.h b/include/linux/platform_data/gpio-dwapb.h
new file mode 100644
index 000000000000..28702c849af1
--- /dev/null
+++ b/include/linux/platform_data/gpio-dwapb.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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 GPIO_DW_APB_H
+#define GPIO_DW_APB_H
+
+struct dwapb_port_property {
+        struct device_node *node;
+        const char      *name;
+        unsigned int    idx;
+        unsigned int    ngpio;
+        unsigned int    gpio_base;
+        unsigned int    irq;
+        bool            irq_shared;
+};
+
+struct dwapb_platform_data {
+        struct dwapb_port_property *properties;
+        unsigned int nports;
+};
+
+#endif
diff --git a/include/linux/platform_data/hsmmc-omap.h b/include/linux/platform_data/hsmmc-omap.h
new file mode 100644
index 000000000000..67bbcf0785f6
--- /dev/null
+++ b/include/linux/platform_data/hsmmc-omap.h
@@ -0,0 +1,90 @@
+/*
+ * MMC definitions for OMAP2
+ *
+ * Copyright (C) 2006 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.
+ */
+
+/*
+ * struct omap_hsmmc_dev_attr.flags possibilities
+ *
+ * OMAP_HSMMC_SUPPORTS_DUAL_VOLT: Some HSMMC controller instances can
+ *    operate with either 1.8Vdc or 3.0Vdc card voltages; this flag
+ *    should be set if this is the case.  See for example Section 22.5.3
+ *    "MMC/SD/SDIO1 Bus Voltage Selection" of the OMAP34xx Multimedia
+ *    Device Silicon Revision 3.1.x Revision ZR (July 2011) (SWPU223R).
+ *
+ * OMAP_HSMMC_BROKEN_MULTIBLOCK_READ: Multiple-block read transfers
+ *    don't work correctly on some MMC controller instances on some
+ *    OMAP3 SoCs; this flag should be set if this is the case.  See
+ *    for example Advisory 2.1.1.128 "MMC: Multiple Block Read
+ *    Operation Issue" in _OMAP3530/3525/3515/3503 Silicon Errata_
+ *    Revision F (October 2010) (SPRZ278F).
+ */
+#define OMAP_HSMMC_SUPPORTS_DUAL_VOLT           BIT(0)
+#define OMAP_HSMMC_BROKEN_MULTIBLOCK_READ       BIT(1)
+#define OMAP_HSMMC_SWAKEUP_MISSING              BIT(2)
+
+struct omap_hsmmc_dev_attr {
+        u8 flags;
+};
+
+struct mmc_card;
+
+struct omap_hsmmc_platform_data {
+        /* back-link to device */
+        struct device *dev;
+
+        /* set if your board has components or wiring that limits the
+         * maximum frequency on the MMC bus */
+        unsigned int max_freq;
+
+        /* Integrating attributes from the omap_hwmod layer */
+        u8 controller_flags;
+
+        /* Register offset deviation */
+        u16 reg_offset;
+
+        /*
+         * 4/8 wires and any additional host capabilities
+         * need to OR'd all capabilities (ref. linux/mmc/host.h)
+         */
+        u32 caps;       /* Used for the MMC driver on 2430 and later */
+        u32 pm_caps;    /* PM capabilities of the mmc */
+
+        /* switch pin can be for card detect (default) or card cover */
+        unsigned cover:1;
+
+        /* use the internal clock */
+        unsigned internal_clock:1;
+
+        /* nonremovable e.g. eMMC */
+        unsigned nonremovable:1;
+
+        /* eMMC does not handle power off when not in sleep state */
+        unsigned no_regulator_off_init:1;
+
+        /* we can put the features above into this variable */
+#define HSMMC_HAS_PBIAS         (1 << 0)
+#define HSMMC_HAS_UPDATED_RESET (1 << 1)
+#define HSMMC_HAS_HSPE_SUPPORT  (1 << 2)
+        unsigned features;
+
+        int switch_pin;                 /* gpio (card detect) */
+        int gpio_wp;                    /* gpio (write protect) */
+
+        int (*set_power)(struct device *dev, int power_on, int vdd);
+        void (*remux)(struct device *dev, int power_on);
+        /* Call back before enabling / disabling regulators */
+        void (*before_set_reg)(struct device *dev, int power_on, int vdd);
+        /* Call back after enabling / disabling regulators */
+        void (*after_set_reg)(struct device *dev, int power_on, int vdd);
+        /* if we have special card, init it using this callback */
+        void (*init_card)(struct mmc_card *card);
+
+        const char *name;
+        u32 ocr_mask;
+};
diff --git a/include/linux/platform_data/i2c-designware.h b/include/linux/platform_data/i2c-designware.h
new file mode 100644
index 000000000000..7a61fb27c25b
--- /dev/null
+++ b/include/linux/platform_data/i2c-designware.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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 I2C_DESIGNWARE_H
+#define I2C_DESIGNWARE_H
+
+struct dw_i2c_platform_data {
+        unsigned int i2c_scl_freq;
+};
+
+#endif
diff --git a/include/linux/platform_data/isl9305.h b/include/linux/platform_data/isl9305.h
new file mode 100644
index 000000000000..1419133fa69e
--- /dev/null
+++ b/include/linux/platform_data/isl9305.h
@@ -0,0 +1,30 @@
+/*
+ * isl9305 - Intersil ISL9305 DCDC regulator
+ *
+ * Copyright 2014 Linaro Ltd
+ *
+ * Author: Mark Brown <broonie@kernel.org>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#ifndef __ISL9305_H
+#define __ISL9305_H
+
+#define ISL9305_DCD1 0
+#define ISL9305_DCD2 1
+#define ISL9305_LDO1 2
+#define ISL9305_LDO2 3
+
+#define ISL9305_MAX_REGULATOR ISL9305_LDO2
+
+struct regulator_init_data;
+
+struct isl9305_pdata {
+        struct regulator_init_data *init_data[ISL9305_MAX_REGULATOR];
+};
+
+#endif
diff --git a/include/linux/platform_data/lp855x.h b/include/linux/platform_data/lp855x.h
index 1b2ba24e4e03..9c7fd1efe495 100644
--- a/include/linux/platform_data/lp855x.h
+++ b/include/linux/platform_data/lp855x.h
@@ -136,6 +136,7 @@ struct lp855x_rom_data {
                 Only valid when mode is PWM_BASED.
  * @size_program : total size of lp855x_rom_data
  * @rom_data : list of new eeprom/eprom registers
+ * @supply : regulator that supplies 3V input
  */
 struct lp855x_platform_data {
         const char *name;
@@ -144,6 +145,7 @@ struct lp855x_platform_data {
         unsigned int period_ns;
         int size_program;
         struct lp855x_rom_data *rom_data;
+        struct regulator *supply;
 };
 
 #endif
diff --git a/include/linux/platform_data/mmc-atmel-mci.h b/include/linux/platform_data/mmc-atmel-mci.h
new file mode 100644
index 000000000000..399a2d5a14bd
--- /dev/null
+++ b/include/linux/platform_data/mmc-atmel-mci.h
@@ -0,0 +1,22 @@
+#ifndef __MMC_ATMEL_MCI_H
+#define __MMC_ATMEL_MCI_H
+
+#include <linux/platform_data/dma-atmel.h>
+#include <linux/platform_data/dma-dw.h>
+
+/**
+ * struct mci_dma_data - DMA data for MCI interface
+ */
+struct mci_dma_data {
+#ifdef CONFIG_ARM
+        struct at_dma_slave     sdata;
+#else
+        struct dw_dma_slave     sdata;
+#endif
+};
+
+/* accessor macros */
+#define slave_data_ptr(s)       (&(s)->sdata)
+#define find_slave_dev(s)       ((s)->sdata.dma_dev)
+
+#endif /* __MMC_ATMEL_MCI_H */
diff --git a/include/linux/platform_data/mmc-omap.h b/include/linux/platform_data/mmc-omap.h
index 51e70cf25cbc..5c188f4e9bec 100644
--- a/include/linux/platform_data/mmc-omap.h
+++ b/include/linux/platform_data/mmc-omap.h
@@ -10,32 +10,8 @@
 
 #define OMAP_MMC_MAX_SLOTS      2
 
-/*
- * struct omap_mmc_dev_attr.flags possibilities
- *
- * OMAP_HSMMC_SUPPORTS_DUAL_VOLT: Some HSMMC controller instances can
- *    operate with either 1.8Vdc or 3.0Vdc card voltages; this flag
- *    should be set if this is the case.  See for example Section 22.5.3
- *    "MMC/SD/SDIO1 Bus Voltage Selection" of the OMAP34xx Multimedia
- *    Device Silicon Revision 3.1.x Revision ZR (July 2011) (SWPU223R).
- *
- * OMAP_HSMMC_BROKEN_MULTIBLOCK_READ: Multiple-block read transfers
- *    don't work correctly on some MMC controller instances on some
- *    OMAP3 SoCs; this flag should be set if this is the case.  See
- *    for example Advisory 2.1.1.128 "MMC: Multiple Block Read
- *    Operation Issue" in _OMAP3530/3525/3515/3503 Silicon Errata_
- *    Revision F (October 2010) (SPRZ278F).
- */
-#define OMAP_HSMMC_SUPPORTS_DUAL_VOLT           BIT(0)
-#define OMAP_HSMMC_BROKEN_MULTIBLOCK_READ       BIT(1)
-#define OMAP_HSMMC_SWAKEUP_MISSING              BIT(2)
-
 struct mmc_card;
 
-struct omap_mmc_dev_attr {
-        u8 flags;
-};
-
 struct omap_mmc_platform_data {
         /* back-link to device */
         struct device *dev;
@@ -106,9 +82,6 @@ struct omap_mmc_platform_data {
                 unsigned vcc_aux_disable_is_sleep:1;
 
                 /* we can put the features above into this variable */
-#define HSMMC_HAS_PBIAS         (1 << 0)
-#define HSMMC_HAS_UPDATED_RESET (1 << 1)
-#define HSMMC_HAS_HSPE_SUPPORT  (1 << 2)
 #define MMC_OMAP7XX             (1 << 3)
 #define MMC_OMAP15XX            (1 << 4)
 #define MMC_OMAP16XX            (1 << 5)
diff --git a/include/linux/platform_data/mtd-nand-omap2.h b/include/linux/platform_data/mtd-nand-omap2.h
index 16ec262dfcc8..090bbab0130a 100644
--- a/include/linux/platform_data/mtd-nand-omap2.h
+++ b/include/linux/platform_data/mtd-nand-omap2.h
@@ -71,6 +71,7 @@ struct omap_nand_platform_data {
         struct mtd_partition    *parts;
         int                     nr_parts;
         bool                    dev_ready;
+        bool                    flash_bbt;
         enum nand_io            xfer_type;
         int                     devsize;
         enum omap_ecc           ecc_opt;
diff --git a/include/linux/platform_data/pxa_sdhci.h b/include/linux/platform_data/pxa_sdhci.h
index 27d3156d093a..9e20c2fb4ffd 100644
--- a/include/linux/platform_data/pxa_sdhci.h
+++ b/include/linux/platform_data/pxa_sdhci.h
@@ -55,9 +55,4 @@ struct sdhci_pxa_platdata {
         unsigned int    quirks2;
         unsigned int    pm_caps;
 };
-
-struct sdhci_pxa {
-        u8      clk_enable;
-        u8      power_mode;
-};
 #endif /* _PXA_SDHCI_H_ */
diff --git a/include/linux/platform_data/rcar-du.h b/include/linux/platform_data/rcar-du.h
deleted file mode 100644
index 1a2e9901a22e..000000000000
--- a/include/linux/platform_data/rcar-du.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * rcar_du.h  --  R-Car Display Unit DRM driver
- *
- * Copyright (C) 2013 Renesas Corporation
- *
- * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.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 __RCAR_DU_H__
-#define __RCAR_DU_H__
-
-#include <drm/drm_mode.h>
-
-enum rcar_du_output {
-        RCAR_DU_OUTPUT_DPAD0,
-        RCAR_DU_OUTPUT_DPAD1,
-        RCAR_DU_OUTPUT_LVDS0,
-        RCAR_DU_OUTPUT_LVDS1,
-        RCAR_DU_OUTPUT_TCON,
-        RCAR_DU_OUTPUT_MAX,
-};
-
-enum rcar_du_encoder_type {
-        RCAR_DU_ENCODER_UNUSED = 0,
-        RCAR_DU_ENCODER_NONE,
-        RCAR_DU_ENCODER_VGA,
-        RCAR_DU_ENCODER_LVDS,
-};
-
-struct rcar_du_panel_data {
-        unsigned int width_mm;          /* Panel width in mm */
-        unsigned int height_mm;         /* Panel height in mm */
-        struct drm_mode_modeinfo mode;
-};
-
-struct rcar_du_connector_lvds_data {
-        struct rcar_du_panel_data panel;
-};
-
-struct rcar_du_connector_vga_data {
-        /* TODO: Add DDC information for EDID retrieval */
-};
-
-/*
- * struct rcar_du_encoder_data - Encoder platform data
- * @type: the encoder type (RCAR_DU_ENCODER_*)
- * @output: the DU output the connector is connected to (RCAR_DU_OUTPUT_*)
- * @connector.lvds: platform data for LVDS connectors
- * @connector.vga: platform data for VGA connectors
- *
- * Encoder platform data describes an on-board encoder, its associated DU SoC
- * output, and the connector.
- */
-struct rcar_du_encoder_data {
-        enum rcar_du_encoder_type type;
-        enum rcar_du_output output;
-
-        union {
-                struct rcar_du_connector_lvds_data lvds;
-                struct rcar_du_connector_vga_data vga;
-        } connector;
-};
-
-struct rcar_du_platform_data {
-        struct rcar_du_encoder_data *encoders;
-        unsigned int num_encoders;
-};
-
-#endif /* __RCAR_DU_H__ */
diff --git a/include/linux/platform_data/samsung-usbphy.h b/include/linux/platform_data/samsung-usbphy.h
deleted file mode 100644
index 1bd24cba982b..000000000000
--- a/include/linux/platform_data/samsung-usbphy.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2012 Samsung Electronics Co.Ltd
- *              http://www.samsung.com/
- * Author: Praveen Paneri <p.paneri@samsung.com>
- *
- * Defines platform data for samsung usb phy driver.
- *
- * 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 __SAMSUNG_USBPHY_PLATFORM_H
-#define __SAMSUNG_USBPHY_PLATFORM_H
-
-/**
- * samsung_usbphy_data - Platform data for USB PHY driver.
- * @pmu_isolation: Function to control usb phy isolation in PMU.
- */
-struct samsung_usbphy_data {
-        void (*pmu_isolation)(int on);
-};
-
-extern void samsung_usbphy_set_pdata(struct samsung_usbphy_data *pd);
-
-#endif /* __SAMSUNG_USBPHY_PLATFORM_H */
diff --git a/include/linux/platform_data/serial-omap.h b/include/linux/platform_data/serial-omap.h
index c860c1b314c0..d09275f3cde3 100644
--- a/include/linux/platform_data/serial-omap.h
+++ b/include/linux/platform_data/serial-omap.h
@@ -38,9 +38,6 @@ struct omap_uart_port_info {
         unsigned int            dma_rx_timeout;
         unsigned int            autosuspend_timeout;
         unsigned int            dma_rx_poll_rate;
-        int                     DTR_gpio;
-        int                     DTR_inverted;
-        int                     DTR_present;
 
         int (*get_context_loss_count)(struct device *);
         void (*enable_wakeup)(struct device *, bool);
diff --git a/include/linux/platform_data/st21nfca.h b/include/linux/platform_data/st21nfca.h
index 1730312398ff..5087fff96d86 100644
--- a/include/linux/platform_data/st21nfca.h
+++ b/include/linux/platform_data/st21nfca.h
@@ -24,7 +24,6 @@
 #define ST21NFCA_HCI_DRIVER_NAME "st21nfca_hci"
 
 struct st21nfca_nfc_platform_data {
-        unsigned int gpio_irq;
         unsigned int gpio_ena;
         unsigned int irq_polarity;
 };
diff --git a/include/linux/platform_data/st21nfcb.h b/include/linux/platform_data/st21nfcb.h
index 2d11f1f5efab..c3b432f5b63e 100644
--- a/include/linux/platform_data/st21nfcb.h
+++ b/include/linux/platform_data/st21nfcb.h
@@ -24,7 +24,6 @@
 #define ST21NFCB_NCI_DRIVER_NAME "st21nfcb_nci"
 
 struct st21nfcb_nfc_platform_data {
-        unsigned int gpio_irq;
         unsigned int gpio_reset;
         unsigned int irq_polarity;
 };
diff --git a/include/linux/platform_data/tegra_emc.h b/include/linux/platform_data/tegra_emc.h
deleted file mode 100644
index df67505e98f8..000000000000
--- a/include/linux/platform_data/tegra_emc.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2011 Google, Inc.
- *
- * Author:
- *      Colin Cross <ccross@android.com>
- *      Olof Johansson <olof@lixom.net>
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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 __TEGRA_EMC_H_
-#define __TEGRA_EMC_H_
-
-#define TEGRA_EMC_NUM_REGS 46
-
-struct tegra_emc_table {
-        unsigned long rate;
-        u32 regs[TEGRA_EMC_NUM_REGS];
-};
-
-struct tegra_emc_pdata {
-        int num_tables;
-        struct tegra_emc_table *tables;
-};
-
-#endif
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 153d303af7eb..ae4882ca4a64 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -197,8 +197,10 @@ extern void platform_driver_unregister(struct platform_driver *);
 /* non-hotpluggable platform devices may use this so that probe() and
  * its support may live in __init sections, conserving runtime memory.
  */
-extern int platform_driver_probe(struct platform_driver *driver,
-                int (*probe)(struct platform_device *));
+#define platform_driver_probe(drv, probe) \
+        __platform_driver_probe(drv, probe, THIS_MODULE)
+extern int __platform_driver_probe(struct platform_driver *driver,
+                int (*probe)(struct platform_device *), struct module *module);
 
 static inline void *platform_get_drvdata(const struct platform_device *pdev)
 {
@@ -238,10 +240,12 @@ static void __exit __platform_driver##_exit(void) \
 } \
 module_exit(__platform_driver##_exit);
 
-extern struct platform_device *platform_create_bundle(
+#define platform_create_bundle(driver, probe, res, n_res, data, size) \
+        __platform_create_bundle(driver, probe, res, n_res, data, size, THIS_MODULE)
+extern struct platform_device *__platform_create_bundle(
         struct platform_driver *driver, int (*probe)(struct platform_device *),
         struct resource *res, unsigned int n_res,
-        const void *data, size_t size);
+        const void *data, size_t size, struct module *module);
 
 /* early platform driver interface */
 struct early_platform_driver {
diff --git a/include/linux/plist.h b/include/linux/plist.h
index 8b6c970cff6c..97883604a3c5 100644
--- a/include/linux/plist.h
+++ b/include/linux/plist.h
@@ -176,7 +176,7 @@ extern void plist_requeue(struct plist_node *node, struct plist_head *head);
  * plist_for_each_entry - iterate over list of given type
  * @pos:        the type * to use as a loop counter
  * @head:       the head for your list
- * @mem:        the name of the list_struct within the struct
+ * @mem:        the name of the list_head within the struct
  */
 #define plist_for_each_entry(pos, head, mem)    \
          list_for_each_entry(pos, &(head)->node_list, mem.node_list)
@@ -185,7 +185,7 @@ extern void plist_requeue(struct plist_node *node, struct plist_head *head);
  * plist_for_each_entry_continue - continue iteration over list of given type
  * @pos:        the type * to use as a loop cursor
  * @head:       the head for your list
- * @m:          the name of the list_struct within the struct
+ * @m:          the name of the list_head within the struct
  *
  * Continue to iterate over list of given type, continuing after
  * the current position.
@@ -198,7 +198,7 @@ extern void plist_requeue(struct plist_node *node, struct plist_head *head);
  * @pos:        the type * to use as a loop counter
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list
- * @m:          the name of the list_struct within the struct
+ * @m:          the name of the list_head within the struct
  *
  * Iterate over list of given type, safe against removal of list entry.
  */
@@ -229,7 +229,7 @@ static inline int plist_node_empty(const struct plist_node *node)
  * plist_first_entry - get the struct for the first entry
  * @head:       the &struct plist_head pointer
  * @type:       the type of the struct this is embedded in
- * @member:     the name of the list_struct within the struct
+ * @member:     the name of the list_head within the struct
  */
 #ifdef CONFIG_DEBUG_PI_LIST
 # define plist_first_entry(head, type, member)  \
@@ -246,7 +246,7 @@ static inline int plist_node_empty(const struct plist_node *node)
  * plist_last_entry - get the struct for the last entry
  * @head:       the &struct plist_head pointer
  * @type:       the type of the struct this is embedded in
- * @member:     the name of the list_struct within the struct
+ * @member:     the name of the list_head within the struct
  */
 #ifdef CONFIG_DEBUG_PI_LIST
 # define plist_last_entry(head, type, member)   \
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 72c0fe098a27..8b5976364619 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -342,7 +342,7 @@ struct dev_pm_ops {
 #define SET_LATE_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
 #endif
 
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 #define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
         .runtime_suspend = suspend_fn, \
         .runtime_resume = resume_fn, \
@@ -351,15 +351,6 @@ struct dev_pm_ops {
 #define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn)
 #endif
 
-#ifdef CONFIG_PM
-#define SET_PM_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
-        .runtime_suspend = suspend_fn, \
-        .runtime_resume = resume_fn, \
-        .runtime_idle = idle_fn,
-#else
-#define SET_PM_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn)
-#endif
-
 /*
  * Use this if you want to use the same suspend and resume callbacks for suspend
  * to RAM and hibernation.
@@ -538,11 +529,7 @@ enum rpm_request {
 };
 
 struct wakeup_source;
-
-struct pm_domain_data {
-        struct list_head list_node;
-        struct device *dev;
-};
+struct pm_domain_data;
 
 struct pm_subsys_data {
         spinlock_t lock;
@@ -576,7 +563,7 @@ struct dev_pm_info {
 #else
         unsigned int            should_wakeup:1;
 #endif
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         struct timer_list       suspend_timer;
         unsigned long           timer_expires;
         struct work_struct      work;
@@ -619,6 +606,7 @@ extern int dev_pm_put_subsys_data(struct device *dev);
  */
 struct dev_pm_domain {
         struct dev_pm_ops       ops;
+        void (*detach)(struct device *dev, bool power_off);
 };
 
 /*
@@ -679,12 +667,16 @@ struct dev_pm_domain {
 extern void device_pm_lock(void);
 extern void dpm_resume_start(pm_message_t state);
 extern void dpm_resume_end(pm_message_t state);
+extern void dpm_resume_noirq(pm_message_t state);
+extern void dpm_resume_early(pm_message_t state);
 extern void dpm_resume(pm_message_t state);
 extern void dpm_complete(pm_message_t state);
 
 extern void device_pm_unlock(void);
 extern int dpm_suspend_end(pm_message_t state);
 extern int dpm_suspend_start(pm_message_t state);
+extern int dpm_suspend_noirq(pm_message_t state);
+extern int dpm_suspend_late(pm_message_t state);
 extern int dpm_suspend(pm_message_t state);
 extern int dpm_prepare(pm_message_t state);
 
diff --git a/include/linux/pm_clock.h b/include/linux/pm_clock.h
index 8348866e7b05..0b0039634410 100644
--- a/include/linux/pm_clock.h
+++ b/include/linux/pm_clock.h
@@ -18,6 +18,8 @@ struct pm_clk_notifier_block {
         char *con_ids[];
 };
 
+struct clk;
+
 #ifdef CONFIG_PM_CLK
 static inline bool pm_clk_no_clocks(struct device *dev)
 {
@@ -29,6 +31,7 @@ extern void pm_clk_init(struct device *dev);
 extern int pm_clk_create(struct device *dev);
 extern void pm_clk_destroy(struct device *dev);
 extern int pm_clk_add(struct device *dev, const char *con_id);
+extern int pm_clk_add_clk(struct device *dev, struct clk *clk);
 extern void pm_clk_remove(struct device *dev, const char *con_id);
 extern int pm_clk_suspend(struct device *dev);
 extern int pm_clk_resume(struct device *dev);
@@ -51,6 +54,11 @@ static inline int pm_clk_add(struct device *dev, const char *con_id)
 {
         return -EINVAL;
 }
+
+static inline int pm_clk_add_clk(struct device *dev, struct clk *clk)
+{
+        return -EINVAL;
+}
 static inline void pm_clk_remove(struct device *dev, const char *con_id)
 {
 }
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index ebc4c76ffb73..a9edab2c787a 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -17,6 +17,9 @@
 #include <linux/notifier.h>
 #include <linux/cpuidle.h>
 
+/* Defines used for the flags field in the struct generic_pm_domain */
+#define GENPD_FLAG_PM_CLK       (1U << 0) /* PM domain uses PM clk */
+
 enum gpd_status {
         GPD_STATE_ACTIVE = 0,   /* PM domain is active */
         GPD_STATE_WAIT_MASTER,  /* PM domain's master is being waited for */
@@ -35,18 +38,10 @@ struct gpd_dev_ops {
         int (*stop)(struct device *dev);
         int (*save_state)(struct device *dev);
         int (*restore_state)(struct device *dev);
-        int (*suspend)(struct device *dev);
-        int (*suspend_late)(struct device *dev);
-        int (*resume_early)(struct device *dev);
-        int (*resume)(struct device *dev);
-        int (*freeze)(struct device *dev);
-        int (*freeze_late)(struct device *dev);
-        int (*thaw_early)(struct device *dev);
-        int (*thaw)(struct device *dev);
         bool (*active_wakeup)(struct device *dev);
 };
 
-struct gpd_cpu_data {
+struct gpd_cpuidle_data {
         unsigned int saved_exit_latency;
         struct cpuidle_state *idle_state;
 };
@@ -71,7 +66,6 @@ struct generic_pm_domain {
         unsigned int suspended_count;   /* System suspend device counter */
         unsigned int prepared_count;    /* Suspend counter of prepared devices */
         bool suspend_power_off; /* Power status before system suspend */
-        bool dev_irq_safe;      /* Device callbacks are IRQ-safe */
         int (*power_off)(struct generic_pm_domain *domain);
         s64 power_off_latency_ns;
         int (*power_on)(struct generic_pm_domain *domain);
@@ -80,8 +74,12 @@ struct generic_pm_domain {
         s64 max_off_time_ns;    /* Maximum allowed "suspended" time. */
         bool max_off_time_changed;
         bool cached_power_down_ok;
-        struct device_node *of_node; /* Node in device tree */
-        struct gpd_cpu_data *cpu_data;
+        struct gpd_cpuidle_data *cpuidle_data;
+        int (*attach_dev)(struct generic_pm_domain *domain,
+                          struct device *dev);
+        void (*detach_dev)(struct generic_pm_domain *domain,
+                           struct device *dev);
+        unsigned int flags;             /* Bit field of configs for genpd */
 };
 
 static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
@@ -106,14 +104,18 @@ struct gpd_timing_data {
         bool cached_stop_ok;
 };
 
+struct pm_domain_data {
+        struct list_head list_node;
+        struct device *dev;
+};
+
 struct generic_pm_domain_data {
         struct pm_domain_data base;
-        struct gpd_dev_ops ops;
         struct gpd_timing_data td;
         struct notifier_block nb;
         struct mutex lock;
         unsigned int refcount;
-        bool need_restore;
+        int need_restore;
 };
 
 #ifdef CONFIG_PM_GENERIC_DOMAINS
@@ -127,17 +129,11 @@ static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
         return to_gpd_data(dev->power.subsys_data->domain_data);
 }
 
-extern struct dev_power_governor simple_qos_governor;
-
 extern struct generic_pm_domain *dev_to_genpd(struct device *dev);
 extern int __pm_genpd_add_device(struct generic_pm_domain *genpd,
                                  struct device *dev,
                                  struct gpd_timing_data *td);
 
-extern int __pm_genpd_of_add_device(struct device_node *genpd_node,
-                                    struct device *dev,
-                                    struct gpd_timing_data *td);
-
 extern int __pm_genpd_name_add_device(const char *domain_name,
                                       struct device *dev,
                                       struct gpd_timing_data *td);
@@ -151,10 +147,6 @@ extern int pm_genpd_add_subdomain_names(const char *master_name,
                                         const char *subdomain_name);
 extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
                                      struct generic_pm_domain *target);
-extern int pm_genpd_add_callbacks(struct device *dev,
-                                  struct gpd_dev_ops *ops,
-                                  struct gpd_timing_data *td);
-extern int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td);
 extern int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int state);
 extern int pm_genpd_name_attach_cpuidle(const char *name, int state);
 extern int pm_genpd_detach_cpuidle(struct generic_pm_domain *genpd);
@@ -164,9 +156,9 @@ extern void pm_genpd_init(struct generic_pm_domain *genpd,
 
 extern int pm_genpd_poweron(struct generic_pm_domain *genpd);
 extern int pm_genpd_name_poweron(const char *domain_name);
+extern void pm_genpd_poweroff_unused(void);
 
-extern bool default_stop_ok(struct device *dev);
-
+extern struct dev_power_governor simple_qos_governor;
 extern struct dev_power_governor pm_domain_always_on_gov;
 #else
 
@@ -184,12 +176,6 @@ static inline int __pm_genpd_add_device(struct generic_pm_domain *genpd,
 {
         return -ENOSYS;
 }
-static inline int __pm_genpd_of_add_device(struct device_node *genpd_node,
-                                           struct device *dev,
-                                           struct gpd_timing_data *td)
-{
-        return -ENOSYS;
-}
 static inline int __pm_genpd_name_add_device(const char *domain_name,
                                              struct device *dev,
                                              struct gpd_timing_data *td)
@@ -217,16 +203,6 @@ static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
 {
         return -ENOSYS;
 }
-static inline int pm_genpd_add_callbacks(struct device *dev,
-                                         struct gpd_dev_ops *ops,
-                                         struct gpd_timing_data *td)
-{
-        return -ENOSYS;
-}
-static inline int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
-{
-        return -ENOSYS;
-}
 static inline int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int st)
 {
         return -ENOSYS;
@@ -255,10 +231,7 @@ static inline int pm_genpd_name_poweron(const char *domain_name)
 {
         return -ENOSYS;
 }
-static inline bool default_stop_ok(struct device *dev)
-{
-        return false;
-}
+static inline void pm_genpd_poweroff_unused(void) {}
 #define simple_qos_governor NULL
 #define pm_domain_always_on_gov NULL
 #endif
@@ -269,45 +242,89 @@ static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
         return __pm_genpd_add_device(genpd, dev, NULL);
 }
 
-static inline int pm_genpd_of_add_device(struct device_node *genpd_node,
-                                         struct device *dev)
-{
-        return __pm_genpd_of_add_device(genpd_node, dev, NULL);
-}
-
 static inline int pm_genpd_name_add_device(const char *domain_name,
                                            struct device *dev)
 {
         return __pm_genpd_name_add_device(domain_name, dev, NULL);
 }
 
-static inline int pm_genpd_remove_callbacks(struct device *dev)
+#ifdef CONFIG_PM_GENERIC_DOMAINS_SLEEP
+extern void pm_genpd_syscore_poweroff(struct device *dev);
+extern void pm_genpd_syscore_poweron(struct device *dev);
+#else
+static inline void pm_genpd_syscore_poweroff(struct device *dev) {}
+static inline void pm_genpd_syscore_poweron(struct device *dev) {}
+#endif
+
+/* OF PM domain providers */
+struct of_device_id;
+
+struct genpd_onecell_data {
+        struct generic_pm_domain **domains;
+        unsigned int num_domains;
+};
+
+typedef struct generic_pm_domain *(*genpd_xlate_t)(struct of_phandle_args *args,
+                                                void *data);
+
+#ifdef CONFIG_PM_GENERIC_DOMAINS_OF
+int __of_genpd_add_provider(struct device_node *np, genpd_xlate_t xlate,
+                        void *data);
+void of_genpd_del_provider(struct device_node *np);
+struct generic_pm_domain *of_genpd_get_from_provider(
+                        struct of_phandle_args *genpdspec);
+
+struct generic_pm_domain *__of_genpd_xlate_simple(
+                                        struct of_phandle_args *genpdspec,
+                                        void *data);
+struct generic_pm_domain *__of_genpd_xlate_onecell(
+                                        struct of_phandle_args *genpdspec,
+                                        void *data);
+
+int genpd_dev_pm_attach(struct device *dev);
+#else /* !CONFIG_PM_GENERIC_DOMAINS_OF */
+static inline int __of_genpd_add_provider(struct device_node *np,
+                                        genpd_xlate_t xlate, void *data)
 {
-        return __pm_genpd_remove_callbacks(dev, true);
+        return 0;
 }
+static inline void of_genpd_del_provider(struct device_node *np) {}
 
-#ifdef CONFIG_PM_GENERIC_DOMAINS_RUNTIME
-extern void genpd_queue_power_off_work(struct generic_pm_domain *genpd);
-extern void pm_genpd_poweroff_unused(void);
-#else
-static inline void genpd_queue_power_off_work(struct generic_pm_domain *gpd) {}
-static inline void pm_genpd_poweroff_unused(void) {}
-#endif
+static inline struct generic_pm_domain *of_genpd_get_from_provider(
+                        struct of_phandle_args *genpdspec)
+{
+        return NULL;
+}
 
-#ifdef CONFIG_PM_GENERIC_DOMAINS_SLEEP
-extern void pm_genpd_syscore_switch(struct device *dev, bool suspend);
-#else
-static inline void pm_genpd_syscore_switch(struct device *dev, bool suspend) {}
-#endif
+#define __of_genpd_xlate_simple         NULL
+#define __of_genpd_xlate_onecell        NULL
+
+static inline int genpd_dev_pm_attach(struct device *dev)
+{
+        return -ENODEV;
+}
+#endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
 
-static inline void pm_genpd_syscore_poweroff(struct device *dev)
+static inline int of_genpd_add_provider_simple(struct device_node *np,
+                                        struct generic_pm_domain *genpd)
+{
+        return __of_genpd_add_provider(np, __of_genpd_xlate_simple, genpd);
+}
+static inline int of_genpd_add_provider_onecell(struct device_node *np,
+                                        struct genpd_onecell_data *data)
 {
-        pm_genpd_syscore_switch(dev, true);
+        return __of_genpd_add_provider(np, __of_genpd_xlate_onecell, data);
 }
 
-static inline void pm_genpd_syscore_poweron(struct device *dev)
+#ifdef CONFIG_PM
+extern int dev_pm_domain_attach(struct device *dev, bool power_on);
+extern void dev_pm_domain_detach(struct device *dev, bool power_off);
+#else
+static inline int dev_pm_domain_attach(struct device *dev, bool power_on)
 {
-        pm_genpd_syscore_switch(dev, false);
+        return -ENODEV;
 }
+static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}
+#endif
 
 #endif /* _LINUX_PM_DOMAIN_H */
diff --git a/include/linux/pm_opp.h b/include/linux/pm_opp.h
index 0330217abfad..cec2d4540914 100644
--- a/include/linux/pm_opp.h
+++ b/include/linux/pm_opp.h
@@ -21,7 +21,7 @@ struct dev_pm_opp;
 struct device;
 
 enum dev_pm_opp_event {
-        OPP_EVENT_ADD, OPP_EVENT_ENABLE, OPP_EVENT_DISABLE,
+        OPP_EVENT_ADD, OPP_EVENT_REMOVE, OPP_EVENT_ENABLE, OPP_EVENT_DISABLE,
 };
 
 #if defined(CONFIG_PM_OPP)
@@ -44,6 +44,7 @@ struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
 
 int dev_pm_opp_add(struct device *dev, unsigned long freq,
                    unsigned long u_volt);
+void dev_pm_opp_remove(struct device *dev, unsigned long freq);
 
 int dev_pm_opp_enable(struct device *dev, unsigned long freq);
 
@@ -90,6 +91,10 @@ static inline int dev_pm_opp_add(struct device *dev, unsigned long freq,
         return -EINVAL;
 }
 
+static inline void dev_pm_opp_remove(struct device *dev, unsigned long freq)
+{
+}
+
 static inline int dev_pm_opp_enable(struct device *dev, unsigned long freq)
 {
         return 0;
@@ -109,11 +114,16 @@ static inline struct srcu_notifier_head *dev_pm_opp_get_notifier(
 
 #if defined(CONFIG_PM_OPP) && defined(CONFIG_OF)
 int of_init_opp_table(struct device *dev);
+void of_free_opp_table(struct device *dev);
 #else
 static inline int of_init_opp_table(struct device *dev)
 {
         return -EINVAL;
 }
+
+static inline void of_free_opp_table(struct device *dev)
+{
+}
 #endif
 
 #endif          /* __LINUX_OPP_H__ */
diff --git a/include/linux/pm_qos.h b/include/linux/pm_qos.h
index 9ab4bf7c4646..7b3ae0cffc05 100644
--- a/include/linux/pm_qos.h
+++ b/include/linux/pm_qos.h
@@ -15,6 +15,7 @@ enum {
         PM_QOS_CPU_DMA_LATENCY,
         PM_QOS_NETWORK_LATENCY,
         PM_QOS_NETWORK_THROUGHPUT,
+        PM_QOS_MEMORY_BANDWIDTH,
 
         /* insert new class ID */
         PM_QOS_NUM_CLASSES,
@@ -32,6 +33,7 @@ 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_MEMORY_BANDWIDTH_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)
@@ -69,7 +71,8 @@ struct dev_pm_qos_request {
 enum pm_qos_type {
         PM_QOS_UNITIALIZED,
         PM_QOS_MAX,             /* return the largest value */
-        PM_QOS_MIN              /* return the smallest value */
+        PM_QOS_MIN,             /* return the smallest value */
+        PM_QOS_SUM              /* return the sum */
 };
 
 /*
@@ -151,6 +154,23 @@ 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,
                                     enum dev_pm_qos_req_type type, s32 value);
+int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value);
+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_resume_latency(struct device *dev)
+{
+        return dev->power.qos->resume_latency_req->data.pnode.prio;
+}
+
+static inline s32 dev_pm_qos_requested_flags(struct device *dev)
+{
+        return dev->power.qos->flags_req->data.flr.flags;
+}
 #else
 static inline enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev,
                                                           s32 mask)
@@ -197,27 +217,6 @@ static inline int dev_pm_qos_add_ancestor_request(struct device *dev,
                                                   enum dev_pm_qos_req_type type,
                                                   s32 value)
                         { return 0; }
-#endif
-
-#ifdef CONFIG_PM_RUNTIME
-int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value);
-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_resume_latency(struct device *dev)
-{
-        return dev->power.qos->resume_latency_req->data.pnode.prio;
-}
-
-static inline s32 dev_pm_qos_requested_flags(struct device *dev)
-{
-        return dev->power.qos->flags_req->data.flr.flags;
-}
-#else
 static inline int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
                         { return 0; }
 static inline void dev_pm_qos_hide_latency_limit(struct device *dev) {}
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index 367f49b9a1c9..30e84d48bfea 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -35,16 +35,6 @@ 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 bool queue_pm_work(struct work_struct *work) { return false; }
-
-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
 
 extern int __pm_runtime_idle(struct device *dev, int rpmflags);
 extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
@@ -128,7 +118,19 @@ static inline void pm_runtime_mark_last_busy(struct device *dev)
         ACCESS_ONCE(dev->power.last_busy) = jiffies;
 }
 
-#else /* !CONFIG_PM_RUNTIME */
+static inline bool pm_runtime_is_irq_safe(struct device *dev)
+{
+        return dev->power.irq_safe;
+}
+
+#else /* !CONFIG_PM */
+
+static inline bool queue_pm_work(struct work_struct *work) { return false; }
+
+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; }
 
 static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
 {
@@ -167,6 +169,7 @@ static inline bool pm_runtime_enabled(struct device *dev) { return false; }
 
 static inline void pm_runtime_no_callbacks(struct device *dev) {}
 static inline void pm_runtime_irq_safe(struct device *dev) {}
+static inline bool pm_runtime_is_irq_safe(struct device *dev) { return false; }
 
 static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
 static inline void pm_runtime_mark_last_busy(struct device *dev) {}
@@ -179,7 +182,7 @@ static inline unsigned long pm_runtime_autosuspend_expiration(
 static inline void pm_runtime_set_memalloc_noio(struct device *dev,
                                                 bool enable){}
 
-#endif /* !CONFIG_PM_RUNTIME */
+#endif /* !CONFIG_PM */
 
 static inline int pm_runtime_idle(struct device *dev)
 {
diff --git a/include/linux/pnfs_osd_xdr.h b/include/linux/pnfs_osd_xdr.h
index fe25876c1a5d..17d7d0d20eca 100644
--- a/include/linux/pnfs_osd_xdr.h
+++ b/include/linux/pnfs_osd_xdr.h
@@ -5,7 +5,7 @@
  *  All rights reserved.
  *
  *  Benny Halevy <bhalevy@panasas.com>
- *  Boaz Harrosh <bharrosh@panasas.com>
+ *  Boaz Harrosh <ooo@electrozaur.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
diff --git a/include/linux/power/charger-manager.h b/include/linux/power/charger-manager.h
index 07e7945a1ff2..e97fc656a058 100644
--- a/include/linux/power/charger-manager.h
+++ b/include/linux/power/charger-manager.h
@@ -253,9 +253,6 @@ struct charger_manager {
         struct device *dev;
         struct charger_desc *desc;
 
-        struct power_supply *fuel_gauge;
-        struct power_supply **charger_stat;
-
 #ifdef CONFIG_THERMAL
         struct thermal_zone_device *tzd_batt;
 #endif
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index f3dea41dbcd2..096dbced02ac 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -18,8 +18,6 @@
 #include <linux/spinlock.h>
 #include <linux/notifier.h>
 
-struct device;
-
 /*
  * All voltages, currents, charges, energies, time and temperatures in uV,
  * µA, µAh, µWh, seconds and tenths of degree Celsius unless otherwise
@@ -102,9 +100,11 @@ enum power_supply_property {
         POWER_SUPPLY_PROP_VOLTAGE_NOW,
         POWER_SUPPLY_PROP_VOLTAGE_AVG,
         POWER_SUPPLY_PROP_VOLTAGE_OCV,
+        POWER_SUPPLY_PROP_VOLTAGE_BOOT,
         POWER_SUPPLY_PROP_CURRENT_MAX,
         POWER_SUPPLY_PROP_CURRENT_NOW,
         POWER_SUPPLY_PROP_CURRENT_AVG,
+        POWER_SUPPLY_PROP_CURRENT_BOOT,
         POWER_SUPPLY_PROP_POWER_NOW,
         POWER_SUPPLY_PROP_POWER_AVG,
         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
@@ -146,6 +146,7 @@ enum power_supply_property {
         POWER_SUPPLY_PROP_TYPE, /* use power_supply.type instead */
         POWER_SUPPLY_PROP_SCOPE,
         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
+        POWER_SUPPLY_PROP_CALIBRATE,
         /* Properties of type `const char *' */
         POWER_SUPPLY_PROP_MODEL_NAME,
         POWER_SUPPLY_PROP_MANUFACTURER,
@@ -172,6 +173,7 @@ union power_supply_propval {
         const char *strval;
 };
 
+struct device;
 struct device_node;
 
 struct power_supply {
@@ -198,6 +200,12 @@ struct power_supply {
         void (*external_power_changed)(struct power_supply *psy);
         void (*set_charged)(struct power_supply *psy);
 
+        /*
+         * Set if thermal zone should not be created for this power supply.
+         * For example for virtual supplies forwarding calls to actual
+         * sensors or other supplies.
+         */
+        bool no_thermal;
         /* For APM emulation, think legacy userspace. */
         int use_for_apm;
 
@@ -291,6 +299,7 @@ static inline bool power_supply_is_amp_property(enum power_supply_property psp)
         case POWER_SUPPLY_PROP_CURRENT_MAX:
         case POWER_SUPPLY_PROP_CURRENT_NOW:
         case POWER_SUPPLY_PROP_CURRENT_AVG:
+        case POWER_SUPPLY_PROP_CURRENT_BOOT:
                 return 1;
         default:
                 break;
@@ -315,6 +324,7 @@ static inline bool power_supply_is_watt_property(enum power_supply_property psp)
         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
         case POWER_SUPPLY_PROP_VOLTAGE_OCV:
+        case POWER_SUPPLY_PROP_VOLTAGE_BOOT:
         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
         case POWER_SUPPLY_PROP_POWER_NOW:
diff --git a/include/linux/printk.h b/include/linux/printk.h
index d78125f73ac4..c8f170324e64 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -118,12 +118,13 @@ int no_printk(const char *fmt, ...)
 #ifdef CONFIG_EARLY_PRINTK
 extern asmlinkage __printf(1, 2)
 void early_printk(const char *fmt, ...);
-void early_vprintk(const char *fmt, va_list ap);
 #else
 static inline __printf(1, 2) __cold
 void early_printk(const char *s, ...) { }
 #endif
 
+typedef int(*printk_func_t)(const char *fmt, va_list args);
+
 #ifdef CONFIG_PRINTK
 asmlinkage __printf(5, 0)
 int vprintk_emit(int facility, int level,
diff --git a/include/linux/prio_heap.h b/include/linux/prio_heap.h
deleted file mode 100644
index 08094350f26a..000000000000
--- a/include/linux/prio_heap.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef _LINUX_PRIO_HEAP_H
-#define _LINUX_PRIO_HEAP_H
-
-/*
- * Simple insertion-only static-sized priority heap containing
- * pointers, based on CLR, chapter 7
- */
-
-#include <linux/gfp.h>
-
-/**
- * struct ptr_heap - simple static-sized priority heap
- * @ptrs - pointer to data area
- * @max - max number of elements that can be stored in @ptrs
- * @size - current number of valid elements in @ptrs (in the range 0..@size-1
- * @gt: comparison operator, which should implement "greater than"
- */
-struct ptr_heap {
-        void **ptrs;
-        int max;
-        int size;
-        int (*gt)(void *, void *);
-};
-
-/**
- * heap_init - initialize an empty heap with a given memory size
- * @heap: the heap structure to be initialized
- * @size: amount of memory to use in bytes
- * @gfp_mask: mask to pass to kmalloc()
- * @gt: comparison operator, which should implement "greater than"
- */
-extern int heap_init(struct ptr_heap *heap, size_t size, gfp_t gfp_mask,
-                     int (*gt)(void *, void *));
-
-/**
- * heap_free - release a heap's storage
- * @heap: the heap structure whose data should be released
- */
-void heap_free(struct ptr_heap *heap);
-
-/**
- * heap_insert - insert a value into the heap and return any overflowed value
- * @heap: the heap to be operated on
- * @p: the pointer to be inserted
- *
- * Attempts to insert the given value into the priority heap. If the
- * heap is full prior to the insertion, then the resulting heap will
- * consist of the smallest @max elements of the original heap and the
- * new element; the greatest element will be removed from the heap and
- * returned. Note that the returned element will be the new element
- * (i.e. no change to the heap) if the new element is greater than all
- * elements currently in the heap.
- */
-extern void *heap_insert(struct ptr_heap *heap, void *p);
-
-
-
-#endif /* _LINUX_PRIO_HEAP_H */
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 9d117f61d976..b97bf2ef996e 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -74,6 +74,8 @@ static inline int remove_proc_subtree(const char *name, struct proc_dir_entry *p
 
 #endif /* CONFIG_PROC_FS */
 
+struct net;
+
 static inline struct proc_dir_entry *proc_net_mkdir(
         struct net *net, const char *name, struct proc_dir_entry *parent)
 {
diff --git a/include/linux/proc_ns.h b/include/linux/proc_ns.h
index 34a1e105bef4..42dfc615dbf8 100644
--- a/include/linux/proc_ns.h
+++ b/include/linux/proc_ns.h
@@ -4,21 +4,18 @@
 #ifndef _LINUX_PROC_NS_H
 #define _LINUX_PROC_NS_H
 
+#include <linux/ns_common.h>
+
 struct pid_namespace;
 struct nsproxy;
+struct path;
 
 struct proc_ns_operations {
         const char *name;
         int type;
-        void *(*get)(struct task_struct *task);
-        void (*put)(void *ns);
-        int (*install)(struct nsproxy *nsproxy, void *ns);
-        unsigned int (*inum)(void *ns);
-};
-
-struct proc_ns {
-        void *ns;
-        const struct proc_ns_operations *ns_ops;
+        struct ns_common *(*get)(struct task_struct *task);
+        void (*put)(struct ns_common *ns);
+        int (*install)(struct nsproxy *nsproxy, struct ns_common *ns);
 };
 
 extern const struct proc_ns_operations netns_operations;
@@ -43,32 +40,38 @@ enum {
 
 extern int pid_ns_prepare_proc(struct pid_namespace *ns);
 extern void pid_ns_release_proc(struct pid_namespace *ns);
-extern struct file *proc_ns_fget(int fd);
-extern struct proc_ns *get_proc_ns(struct inode *);
 extern int proc_alloc_inum(unsigned int *pino);
 extern void proc_free_inum(unsigned int inum);
-extern bool proc_ns_inode(struct inode *inode);
 
 #else /* CONFIG_PROC_FS */
 
 static inline int pid_ns_prepare_proc(struct pid_namespace *ns) { return 0; }
 static inline void pid_ns_release_proc(struct pid_namespace *ns) {}
 
-static inline struct file *proc_ns_fget(int fd)
-{
-        return ERR_PTR(-EINVAL);
-}
-
-static inline struct proc_ns *get_proc_ns(struct inode *inode) { return NULL; }
-
 static inline int proc_alloc_inum(unsigned int *inum)
 {
         *inum = 1;
         return 0;
 }
 static inline void proc_free_inum(unsigned int inum) {}
-static inline bool proc_ns_inode(struct inode *inode) { return false; }
 
 #endif /* CONFIG_PROC_FS */
 
+static inline int ns_alloc_inum(struct ns_common *ns)
+{
+        atomic_long_set(&ns->stashed, 0);
+        return proc_alloc_inum(&ns->inum);
+}
+
+#define ns_free_inum(ns) proc_free_inum((ns)->inum)
+
+extern struct file *proc_ns_fget(int fd);
+#define get_proc_ns(inode) ((struct ns_common *)(inode)->i_private)
+extern void *ns_get_path(struct path *path, struct task_struct *task,
+                        const struct proc_ns_operations *ns_ops);
+
+extern int ns_get_name(char *buf, size_t size, struct task_struct *task,
+                        const struct proc_ns_operations *ns_ops);
+extern void nsfs_init(void);
+
 #endif /* _LINUX_PROC_NS_H */
diff --git a/include/linux/property.h b/include/linux/property.h
new file mode 100644
index 000000000000..a6a3d98bd7e9
--- /dev/null
+++ b/include/linux/property.h
@@ -0,0 +1,143 @@
+/*
+ * property.h - Unified device property interface.
+ *
+ * Copyright (C) 2014, Intel Corporation
+ * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+ *          Mika Westerberg <mika.westerberg@linux.intel.com>
+ *
+ * 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_PROPERTY_H_
+#define _LINUX_PROPERTY_H_
+
+#include <linux/types.h>
+
+struct device;
+
+enum dev_prop_type {
+        DEV_PROP_U8,
+        DEV_PROP_U16,
+        DEV_PROP_U32,
+        DEV_PROP_U64,
+        DEV_PROP_STRING,
+        DEV_PROP_MAX,
+};
+
+bool device_property_present(struct device *dev, const char *propname);
+int device_property_read_u8_array(struct device *dev, const char *propname,
+                                  u8 *val, size_t nval);
+int device_property_read_u16_array(struct device *dev, const char *propname,
+                                   u16 *val, size_t nval);
+int device_property_read_u32_array(struct device *dev, const char *propname,
+                                   u32 *val, size_t nval);
+int device_property_read_u64_array(struct device *dev, const char *propname,
+                                   u64 *val, size_t nval);
+int device_property_read_string_array(struct device *dev, const char *propname,
+                                      const char **val, size_t nval);
+int device_property_read_string(struct device *dev, const char *propname,
+                                const char **val);
+
+enum fwnode_type {
+        FWNODE_INVALID = 0,
+        FWNODE_OF,
+        FWNODE_ACPI,
+};
+
+struct fwnode_handle {
+        enum fwnode_type type;
+};
+
+bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname);
+int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
+                                  const char *propname, u8 *val,
+                                  size_t nval);
+int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
+                                   const char *propname, u16 *val,
+                                   size_t nval);
+int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
+                                   const char *propname, u32 *val,
+                                   size_t nval);
+int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
+                                   const char *propname, u64 *val,
+                                   size_t nval);
+int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
+                                      const char *propname, const char **val,
+                                      size_t nval);
+int fwnode_property_read_string(struct fwnode_handle *fwnode,
+                                const char *propname, const char **val);
+
+struct fwnode_handle *device_get_next_child_node(struct device *dev,
+                                                 struct fwnode_handle *child);
+
+#define device_for_each_child_node(dev, child) \
+        for (child = device_get_next_child_node(dev, NULL); child; \
+             child = device_get_next_child_node(dev, child))
+
+void fwnode_handle_put(struct fwnode_handle *fwnode);
+
+unsigned int device_get_child_node_count(struct device *dev);
+
+static inline bool device_property_read_bool(struct device *dev,
+                                             const char *propname)
+{
+        return device_property_present(dev, propname);
+}
+
+static inline int device_property_read_u8(struct device *dev,
+                                          const char *propname, u8 *val)
+{
+        return device_property_read_u8_array(dev, propname, val, 1);
+}
+
+static inline int device_property_read_u16(struct device *dev,
+                                           const char *propname, u16 *val)
+{
+        return device_property_read_u16_array(dev, propname, val, 1);
+}
+
+static inline int device_property_read_u32(struct device *dev,
+                                           const char *propname, u32 *val)
+{
+        return device_property_read_u32_array(dev, propname, val, 1);
+}
+
+static inline int device_property_read_u64(struct device *dev,
+                                           const char *propname, u64 *val)
+{
+        return device_property_read_u64_array(dev, propname, val, 1);
+}
+
+static inline bool fwnode_property_read_bool(struct fwnode_handle *fwnode,
+                                             const char *propname)
+{
+        return fwnode_property_present(fwnode, propname);
+}
+
+static inline int fwnode_property_read_u8(struct fwnode_handle *fwnode,
+                                          const char *propname, u8 *val)
+{
+        return fwnode_property_read_u8_array(fwnode, propname, val, 1);
+}
+
+static inline int fwnode_property_read_u16(struct fwnode_handle *fwnode,
+                                           const char *propname, u16 *val)
+{
+        return fwnode_property_read_u16_array(fwnode, propname, val, 1);
+}
+
+static inline int fwnode_property_read_u32(struct fwnode_handle *fwnode,
+                                           const char *propname, u32 *val)
+{
+        return fwnode_property_read_u32_array(fwnode, propname, val, 1);
+}
+
+static inline int fwnode_property_read_u64(struct fwnode_handle *fwnode,
+                                           const char *propname, u64 *val)
+{
+        return fwnode_property_read_u64_array(fwnode, propname, val, 1);
+}
+
+#endif /* _LINUX_PROPERTY_H_ */
diff --git a/include/linux/proportions.h b/include/linux/proportions.h
index 26a8a4ed9b07..00e8e8fa7358 100644
--- a/include/linux/proportions.h
+++ b/include/linux/proportions.h
@@ -12,6 +12,7 @@
 #include <linux/percpu_counter.h>
 #include <linux/spinlock.h>
 #include <linux/mutex.h>
+#include <linux/gfp.h>
 
 struct prop_global {
         /*
@@ -40,7 +41,7 @@ struct prop_descriptor {
         struct mutex mutex;             /* serialize the prop_global switch */
 };
 
-int prop_descriptor_init(struct prop_descriptor *pd, int shift);
+int prop_descriptor_init(struct prop_descriptor *pd, int shift, gfp_t gfp);
 void prop_change_shift(struct prop_descriptor *pd, int new_shift);
 
 /*
@@ -61,7 +62,7 @@ struct prop_local_percpu {
         raw_spinlock_t lock;            /* protect the snapshot state */
 };
 
-int prop_local_init_percpu(struct prop_local_percpu *pl);
+int prop_local_init_percpu(struct prop_local_percpu *pl, gfp_t gfp);
 void prop_local_destroy_percpu(struct prop_local_percpu *pl);
 void __prop_inc_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl);
 void prop_fraction_percpu(struct prop_descriptor *pd, struct prop_local_percpu *pl,
diff --git a/include/linux/pstore_ram.h b/include/linux/pstore_ram.h
index 9974975d40db..4af3fdc85b01 100644
--- a/include/linux/pstore_ram.h
+++ b/include/linux/pstore_ram.h
@@ -53,7 +53,8 @@ struct persistent_ram_zone {
 };
 
 struct persistent_ram_zone *persistent_ram_new(phys_addr_t start, size_t size,
-                        u32 sig, struct persistent_ram_ecc_info *ecc_info);
+                        u32 sig, struct persistent_ram_ecc_info *ecc_info,
+                        unsigned int memtype);
 void persistent_ram_free(struct persistent_ram_zone *prz);
 void persistent_ram_zap(struct persistent_ram_zone *prz);
 
@@ -76,6 +77,7 @@ ssize_t persistent_ram_ecc_string(struct persistent_ram_zone *prz,
 struct ramoops_platform_data {
         unsigned long   mem_size;
         unsigned long   mem_address;
+        unsigned int    mem_type;
         unsigned long   record_size;
         unsigned long   console_size;
         unsigned long   ftrace_size;
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index cc79eff4a1ad..987a73a40ef8 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -52,7 +52,7 @@ extern void ptrace_notify(int exit_code);
 extern void __ptrace_link(struct task_struct *child,
                           struct task_struct *new_parent);
 extern void __ptrace_unlink(struct task_struct *child);
-extern void exit_ptrace(struct task_struct *tracer);
+extern void exit_ptrace(struct task_struct *tracer, struct list_head *dead);
 #define PTRACE_MODE_READ        0x01
 #define PTRACE_MODE_ATTACH      0x02
 #define PTRACE_MODE_NOAUDIT     0x04
diff --git a/include/linux/pxa168_eth.h b/include/linux/pxa168_eth.h
index 18d75e795606..e1ab6e86cdb3 100644
--- a/include/linux/pxa168_eth.h
+++ b/include/linux/pxa168_eth.h
@@ -4,6 +4,8 @@
 #ifndef __LINUX_PXA168_ETH_H
 #define __LINUX_PXA168_ETH_H
 
+#include <linux/phy.h>
+
 struct pxa168_eth_platform_data {
         int     port_number;
         int     phy_addr;
@@ -13,6 +15,7 @@ struct pxa168_eth_platform_data {
          */
         int     speed;          /* 0, SPEED_10, SPEED_100 */
         int     duplex;         /* DUPLEX_HALF or DUPLEX_FULL */
+        phy_interface_t intf;
 
         /*
          * Override default RX/TX queue sizes if nonzero.
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index f2b405116166..77aed9ea1d26 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -108,6 +108,25 @@
 #define SSCR1_RxTresh(x) (((x) - 1) << 10) /* level [1..4] */
 #endif
 
+/* QUARK_X1000 SSCR0 bit definition */
+#define QUARK_X1000_SSCR0_DSS   (0x1F)          /* Data Size Select (mask) */
+#define QUARK_X1000_SSCR0_DataSize(x)  ((x) - 1)        /* Data Size Select [4..32] */
+#define QUARK_X1000_SSCR0_FRF   (0x3 << 5)      /* FRame Format (mask) */
+#define QUARK_X1000_SSCR0_Motorola      (0x0 << 5)      /* Motorola's Serial Peripheral Interface (SPI) */
+
+#define RX_THRESH_QUARK_X1000_DFLT      1
+#define TX_THRESH_QUARK_X1000_DFLT      16
+
+#define QUARK_X1000_SSSR_TFL_MASK       (0x1F << 8)     /* Transmit FIFO Level mask */
+#define QUARK_X1000_SSSR_RFL_MASK       (0x1F << 13)    /* Receive FIFO Level mask */
+
+#define QUARK_X1000_SSCR1_TFT   (0x1F << 6)     /* Transmit FIFO Threshold (mask) */
+#define QUARK_X1000_SSCR1_TxTresh(x) (((x) - 1) << 6)   /* level [1..32] */
+#define QUARK_X1000_SSCR1_RFT   (0x1F << 11)    /* Receive FIFO Threshold (mask) */
+#define QUARK_X1000_SSCR1_RxTresh(x) (((x) - 1) << 11)  /* level [1..32] */
+#define QUARK_X1000_SSCR1_STRF       (1 << 17)          /* Select FIFO or EFWR */
+#define QUARK_X1000_SSCR1_EFWR  (1 << 16)               /* Enable FIFO Write/Read */
+
 /* extra bits in PXA255, PXA26x and PXA27x SSP ports */
 #define SSCR0_TISSP             (1 << 4)        /* TI Sync Serial Protocol */
 #define SSCR0_PSP               (3 << 4)        /* PSP - Programmable Serial Protocol */
@@ -175,6 +194,7 @@ enum pxa_ssp_type {
         PXA910_SSP,
         CE4100_SSP,
         LPSS_SSP,
+        QUARK_X1000_SSP,
 };
 
 struct ssp_device {
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 80d345a3524c..50978b781a19 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -56,6 +56,11 @@ enum quota_type {
         PRJQUOTA = 2,           /* element used for project quotas */
 };
 
+/* Masks for quota types when used as a bitmask */
+#define QTYPE_MASK_USR (1 << USRQUOTA)
+#define QTYPE_MASK_GRP (1 << GRPQUOTA)
+#define QTYPE_MASK_PRJ (1 << PRJQUOTA)
+
 typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */
 typedef long long qsize_t;      /* Type in which we store sizes */
 
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 1d3eee594cd6..f23538a6e411 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -64,10 +64,10 @@ void dquot_destroy(struct dquot *dquot);
 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
 void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
 
-int dquot_alloc_inode(const struct inode *inode);
+int dquot_alloc_inode(struct inode *inode);
 
 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
-void dquot_free_inode(const struct inode *inode);
+void dquot_free_inode(struct inode *inode);
 void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
 
 int dquot_disable(struct super_block *sb, int type, unsigned int flags);
@@ -213,12 +213,12 @@ static inline void dquot_drop(struct inode *inode)
 {
 }
 
-static inline int dquot_alloc_inode(const struct inode *inode)
+static inline int dquot_alloc_inode(struct inode *inode)
 {
         return 0;
 }
 
-static inline void dquot_free_inode(const struct inode *inode)
+static inline void dquot_free_inode(struct inode *inode)
 {
 }
 
diff --git a/include/linux/random.h b/include/linux/random.h
index 57fbbffd77a0..b05856e16b75 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -26,7 +26,7 @@ unsigned int get_random_int(void);
 unsigned long randomize_range(unsigned long start, unsigned long end, unsigned long len);
 
 u32 prandom_u32(void);
-void prandom_bytes(void *buf, int nbytes);
+void prandom_bytes(void *buf, size_t nbytes);
 void prandom_seed(u32 seed);
 void prandom_reseed_late(void);
 
@@ -35,7 +35,7 @@ struct rnd_state {
 };
 
 u32 prandom_u32_state(struct rnd_state *state);
-void prandom_bytes_state(struct rnd_state *state, void *buf, int nbytes);
+void prandom_bytes_state(struct rnd_state *state, void *buf, size_t nbytes);
 
 /**
  * prandom_u32_max - returns a pseudo-random number in interval [0, ep_ro)
diff --git a/include/linux/ratelimit.h b/include/linux/ratelimit.h
index 0a260d8a18bf..18102529254e 100644
--- a/include/linux/ratelimit.h
+++ b/include/linux/ratelimit.h
@@ -17,14 +17,20 @@ struct ratelimit_state {
         unsigned long   begin;
 };
 
-#define DEFINE_RATELIMIT_STATE(name, interval_init, burst_init)         \
-                                                                        \
-        struct ratelimit_state name = {                                 \
+#define RATELIMIT_STATE_INIT(name, interval_init, burst_init) {         \
                 .lock           = __RAW_SPIN_LOCK_UNLOCKED(name.lock),  \
                 .interval       = interval_init,                        \
                 .burst          = burst_init,                           \
         }
 
+#define RATELIMIT_STATE_INIT_DISABLED                                   \
+        RATELIMIT_STATE_INIT(ratelimit_state, 0, DEFAULT_RATELIMIT_BURST)
+
+#define DEFINE_RATELIMIT_STATE(name, interval_init, burst_init)         \
+                                                                        \
+        struct ratelimit_state name =                                   \
+                RATELIMIT_STATE_INIT(name, interval_init, burst_init)   \
+
 static inline void ratelimit_state_init(struct ratelimit_state *rs,
                                         int interval, int burst)
 {
diff --git a/include/linux/rbtree_augmented.h b/include/linux/rbtree_augmented.h
index fea49b5da12a..378c5ee75f78 100644
--- a/include/linux/rbtree_augmented.h
+++ b/include/linux/rbtree_augmented.h
@@ -43,6 +43,16 @@ struct rb_augment_callbacks {
 
 extern void __rb_insert_augmented(struct rb_node *node, struct rb_root *root,
         void (*augment_rotate)(struct rb_node *old, struct rb_node *new));
+/*
+ * Fixup the rbtree and update the augmented information when rebalancing.
+ *
+ * On insertion, the user must update the augmented information on the path
+ * leading to the inserted node, then call rb_link_node() as usual and
+ * rb_augment_inserted() instead of the usual rb_insert_color() call.
+ * If rb_augment_inserted() rebalances the rbtree, it will callback into
+ * a user provided function to update the augmented information on the
+ * affected subtrees.
+ */
 static inline void
 rb_insert_augmented(struct rb_node *node, struct rb_root *root,
                     const struct rb_augment_callbacks *augment)
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 372ad5e0dcb8..529bc946f450 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -241,7 +241,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  * list_entry_rcu - get the struct for this entry
  * @ptr:        the &struct list_head pointer.
  * @type:       the type of the struct this is embedded in.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * This primitive may safely run concurrently with the _rcu list-mutation
  * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
@@ -278,7 +278,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  * list_first_or_null_rcu - get the first element from a list
  * @ptr:        the list head to take the element from.
  * @type:       the type of the struct this is embedded in.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Note that if the list is empty, it returns NULL.
  *
@@ -296,7 +296,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  * list_for_each_entry_rcu      -       iterate over rcu list of given type
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as list_add_rcu()
@@ -311,7 +311,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  * list_for_each_entry_continue_rcu - continue iteration over list of given type
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
- * @member:     the name of the list_struct within the struct.
+ * @member:     the name of the list_head within the struct.
  *
  * Continue to iterate over list of given type, continuing after
  * the current position.
@@ -542,6 +542,15 @@ static inline void hlist_add_behind_rcu(struct hlist_node *n,
              pos = hlist_entry_safe(rcu_dereference_bh((pos)->member.next),\
                         typeof(*(pos)), member))
 
+/**
+ * hlist_for_each_entry_from_rcu - iterate over a hlist continuing from current point
+ * @pos:        the type * to use as a loop cursor.
+ * @member:     the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_from_rcu(pos, member)                      \
+        for (; pos;                                                     \
+             pos = hlist_entry_safe(rcu_dereference((pos)->member.next),\
+                        typeof(*(pos)), member))
 
 #endif  /* __KERNEL__ */
 #endif
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index d231aa17b1d7..ed4f5939a452 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -47,19 +47,17 @@
 #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 */
 
 enum rcutorture_type {
         RCU_FLAVOR,
         RCU_BH_FLAVOR,
         RCU_SCHED_FLAVOR,
+        RCU_TASKS_FLAVOR,
         SRCU_FLAVOR,
         INVALID_RCU_FLAVOR
 };
 
-#if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
+#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
 void rcutorture_get_gp_data(enum rcutorture_type test_type, int *flags,
                             unsigned long *gpnum, unsigned long *completed);
 void rcutorture_record_test_transition(void);
@@ -197,6 +195,28 @@ void call_rcu_sched(struct rcu_head *head,
 
 void synchronize_sched(void);
 
+/**
+ * call_rcu_tasks() - Queue an RCU for invocation task-based grace period
+ * @head: structure to be used for queueing the RCU updates.
+ * @func: actual callback function to be invoked after the grace period
+ *
+ * The callback function will be invoked some time after a full grace
+ * period elapses, in other words after all currently executing RCU
+ * read-side critical sections have completed. call_rcu_tasks() assumes
+ * that the read-side critical sections end at a voluntary context
+ * switch (not a preemption!), entry into idle, or transition to usermode
+ * execution.  As such, there are no read-side primitives analogous to
+ * rcu_read_lock() and rcu_read_unlock() because this primitive is intended
+ * to determine that all tasks have passed through a safe state, not so
+ * much for data-strcuture synchronization.
+ *
+ * See the description of call_rcu() for more detailed information on
+ * memory ordering guarantees.
+ */
+void call_rcu_tasks(struct rcu_head *head, void (*func)(struct rcu_head *head));
+void synchronize_rcu_tasks(void);
+void rcu_barrier_tasks(void);
+
 #ifdef CONFIG_PREEMPT_RCU
 
 void __rcu_read_lock(void);
@@ -238,9 +258,9 @@ static inline int rcu_preempt_depth(void)
 
 /* Internal to kernel */
 void rcu_init(void);
-void rcu_sched_qs(int cpu);
-void rcu_bh_qs(int cpu);
-void rcu_check_callbacks(int cpu, int user);
+void rcu_sched_qs(void);
+void rcu_bh_qs(void);
+void rcu_check_callbacks(int user);
 struct notifier_block;
 void rcu_idle_enter(void);
 void rcu_idle_exit(void);
@@ -269,6 +289,14 @@ static inline void rcu_user_hooks_switch(struct task_struct *prev,
                                          struct task_struct *next) { }
 #endif /* CONFIG_RCU_USER_QS */
 
+#ifdef CONFIG_RCU_NOCB_CPU
+void rcu_init_nohz(void);
+#else /* #ifdef CONFIG_RCU_NOCB_CPU */
+static inline void rcu_init_nohz(void)
+{
+}
+#endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */
+
 /**
  * RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
  * @a: Code that RCU needs to pay attention to.
@@ -294,6 +322,36 @@ static inline void rcu_user_hooks_switch(struct task_struct *prev,
                 rcu_irq_exit(); \
         } while (0)
 
+/*
+ * Note a voluntary context switch for RCU-tasks benefit.  This is a
+ * macro rather than an inline function to avoid #include hell.
+ */
+#ifdef CONFIG_TASKS_RCU
+#define TASKS_RCU(x) x
+extern struct srcu_struct tasks_rcu_exit_srcu;
+#define rcu_note_voluntary_context_switch(t) \
+        do { \
+                if (ACCESS_ONCE((t)->rcu_tasks_holdout)) \
+                        ACCESS_ONCE((t)->rcu_tasks_holdout) = false; \
+        } while (0)
+#else /* #ifdef CONFIG_TASKS_RCU */
+#define TASKS_RCU(x) do { } while (0)
+#define rcu_note_voluntary_context_switch(t)    do { } while (0)
+#endif /* #else #ifdef CONFIG_TASKS_RCU */
+
+/**
+ * cond_resched_rcu_qs - Report potential quiescent states to RCU
+ *
+ * This macro resembles cond_resched(), except that it is defined to
+ * report potential quiescent states to RCU-tasks even if the cond_resched()
+ * machinery were to be shut off, as some advocate for PREEMPT kernels.
+ */
+#define cond_resched_rcu_qs() \
+do { \
+        if (!cond_resched()) \
+                rcu_note_voluntary_context_switch(current); \
+} while (0)
+
 #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) || defined(CONFIG_SMP)
 bool __rcu_is_watching(void);
 #endif /* #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) || defined(CONFIG_SMP) */
@@ -307,7 +365,7 @@ typedef void call_rcu_func_t(struct rcu_head *head,
                              void (*func)(struct rcu_head *head));
 void wait_rcu_gp(call_rcu_func_t crf);
 
-#if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
+#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
 #include <linux/rcutree.h>
 #elif defined(CONFIG_TINY_RCU)
 #include <linux/rcutiny.h>
@@ -349,7 +407,7 @@ bool rcu_lockdep_current_cpu_online(void);
 #else /* #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
 static inline bool rcu_lockdep_current_cpu_online(void)
 {
-        return 1;
+        return true;
 }
 #endif /* #else #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
 
@@ -371,41 +429,7 @@ extern struct lockdep_map rcu_sched_lock_map;
 extern struct lockdep_map rcu_callback_map;
 int debug_lockdep_rcu_enabled(void);
 
-/**
- * rcu_read_lock_held() - might we be in RCU read-side critical section?
- *
- * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an RCU
- * read-side critical section.  In absence of CONFIG_DEBUG_LOCK_ALLOC,
- * this assumes we are in an RCU read-side critical section unless it can
- * prove otherwise.  This is useful for debug checks in functions that
- * require that they be called within an RCU read-side critical section.
- *
- * Checks debug_lockdep_rcu_enabled() to prevent false positives during boot
- * and while lockdep is disabled.
- *
- * Note that rcu_read_lock() and the matching rcu_read_unlock() must
- * occur in the same context, for example, it is illegal to invoke
- * rcu_read_unlock() in process context if the matching rcu_read_lock()
- * was invoked from within an irq handler.
- *
- * Note that rcu_read_lock() is disallowed if the CPU is either idle or
- * offline from an RCU perspective, so check for those as well.
- */
-static inline int rcu_read_lock_held(void)
-{
-        if (!debug_lockdep_rcu_enabled())
-                return 1;
-        if (!rcu_is_watching())
-                return 0;
-        if (!rcu_lockdep_current_cpu_online())
-                return 0;
-        return lock_is_held(&rcu_lock_map);
-}
-
-/*
- * rcu_read_lock_bh_held() is defined out of line to avoid #include-file
- * hell.
- */
+int rcu_read_lock_held(void);
 int rcu_read_lock_bh_held(void);
 
 /**
@@ -593,6 +617,21 @@ static inline void rcu_preempt_sleep_check(void)
 #define RCU_INITIALIZER(v) (typeof(*(v)) __force __rcu *)(v)
 
 /**
+ * lockless_dereference() - safely load a pointer for later dereference
+ * @p: The pointer to load
+ *
+ * Similar to rcu_dereference(), but for situations where the pointed-to
+ * object's lifetime is managed by something other than RCU.  That
+ * "something other" might be reference counting or simple immortality.
+ */
+#define lockless_dereference(p) \
+({ \
+        typeof(p) _________p1 = ACCESS_ONCE(p); \
+        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
+        (_________p1); \
+})
+
+/**
  * rcu_assign_pointer() - assign to RCU-protected pointer
  * @p: pointer to assign to
  * @v: value to assign (publish)
@@ -828,7 +867,7 @@ static inline void rcu_preempt_sleep_check(void)
  *
  * In non-preemptible RCU implementations (TREE_RCU and TINY_RCU),
  * it is illegal to block while in an RCU read-side critical section.
- * In preemptible RCU implementations (TREE_PREEMPT_RCU) in CONFIG_PREEMPT
+ * In preemptible RCU implementations (PREEMPT_RCU) in CONFIG_PREEMPT
  * kernel builds, RCU read-side critical sections may be preempted,
  * but explicit blocking is illegal.  Finally, in preemptible RCU
  * implementations in real-time (with -rt patchset) kernel builds, RCU
@@ -863,7 +902,9 @@ static inline void rcu_read_lock(void)
  * Unfortunately, this function acquires the scheduler's runqueue and
  * priority-inheritance spinlocks.  This means that deadlock could result
  * if the caller of rcu_read_unlock() already holds one of these locks or
- * any lock that is ever acquired while holding them.
+ * any lock that is ever acquired while holding them; or any lock which
+ * can be taken from interrupt context because rcu_boost()->rt_mutex_lock()
+ * does not disable irqs while taking ->wait_lock.
  *
  * That said, RCU readers are never priority boosted unless they were
  * preempted.  Therefore, one way to avoid deadlock is to make sure
@@ -1023,6 +1064,7 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
  */
 #define RCU_INIT_POINTER(p, v) \
         do { \
+                rcu_dereference_sparse(p, __rcu); \
                 p = RCU_INITIALIZER(v); \
         } while (0)
 
@@ -1079,7 +1121,7 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
         __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
 
 #if defined(CONFIG_TINY_RCU) || defined(CONFIG_RCU_NOCB_CPU_ALL)
-static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
+static inline int rcu_needs_cpu(unsigned long *delta_jiffies)
 {
         *delta_jiffies = ULONG_MAX;
         return 0;
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index d40a6a451330..0e5366200154 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -78,9 +78,9 @@ static inline void kfree_call_rcu(struct rcu_head *head,
         call_rcu(head, func);
 }
 
-static inline void rcu_note_context_switch(int cpu)
+static inline void rcu_note_context_switch(void)
 {
-        rcu_sched_qs(cpu);
+        rcu_sched_qs();
 }
 
 /*
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 3e2f5d432743..52953790dcca 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -30,9 +30,9 @@
 #ifndef __LINUX_RCUTREE_H
 #define __LINUX_RCUTREE_H
 
-void rcu_note_context_switch(int cpu);
+void rcu_note_context_switch(void);
 #ifndef CONFIG_RCU_NOCB_CPU_ALL
-int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies);
+int rcu_needs_cpu(unsigned long *delta_jiffies);
 #endif /* #ifndef CONFIG_RCU_NOCB_CPU_ALL */
 void rcu_cpu_stall_reset(void);
 
@@ -43,7 +43,7 @@ void rcu_cpu_stall_reset(void);
  */
 static inline void rcu_virt_note_context_switch(int cpu)
 {
-        rcu_note_context_switch(cpu);
+        rcu_note_context_switch();
 }
 
 void synchronize_rcu_bh(void);
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 48bf152761c7..67fc8fcdc4b0 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -38,6 +38,9 @@ extern int reboot_force;
 extern int register_reboot_notifier(struct notifier_block *);
 extern int unregister_reboot_notifier(struct notifier_block *);
 
+extern int register_restart_handler(struct notifier_block *);
+extern int unregister_restart_handler(struct notifier_block *);
+extern void do_kernel_restart(char *cmd);
 
 /*
  * Architecture-specific implementations of sys_reboot commands.
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index c5ed83f49c4e..4419b99d8d6e 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -27,6 +27,7 @@ struct spmi_device;
 struct regmap;
 struct regmap_range_cfg;
 struct regmap_field;
+struct snd_ac97;
 
 /* An enum of all the supported cache types */
 enum regcache_type {
@@ -340,6 +341,8 @@ struct regmap *regmap_init_spmi_ext(struct spmi_device *dev,
 struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
                                     void __iomem *regs,
                                     const struct regmap_config *config);
+struct regmap *regmap_init_ac97(struct snd_ac97 *ac97,
+                                const struct regmap_config *config);
 
 struct regmap *devm_regmap_init(struct device *dev,
                                 const struct regmap_bus *bus,
@@ -356,6 +359,10 @@ struct regmap *devm_regmap_init_spmi_ext(struct spmi_device *dev,
 struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
                                          void __iomem *regs,
                                          const struct regmap_config *config);
+struct regmap *devm_regmap_init_ac97(struct snd_ac97 *ac97,
+                                     const struct regmap_config *config);
+
+bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
 
 /**
  * regmap_init_mmio(): Initialise register map
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
index f8a8733068a7..d17e1ff7ad01 100644
--- a/include/linux/regulator/consumer.h
+++ b/include/linux/regulator/consumer.h
@@ -35,6 +35,8 @@
 #ifndef __LINUX_REGULATOR_CONSUMER_H_
 #define __LINUX_REGULATOR_CONSUMER_H_
 
+#include <linux/err.h>
+
 struct device;
 struct notifier_block;
 struct regmap;
@@ -93,7 +95,14 @@ struct regmap;
  * OVER_TEMP      Regulator over temp.
  * FORCE_DISABLE  Regulator forcibly shut down by software.
  * VOLTAGE_CHANGE Regulator voltage changed.
+ *                Data passed is old voltage cast to (void *).
  * DISABLE        Regulator was disabled.
+ * PRE_VOLTAGE_CHANGE   Regulator is about to have voltage changed.
+ *                      Data passed is "struct pre_voltage_change_data"
+ * ABORT_VOLTAGE_CHANGE Regulator voltage change failed for some reason.
+ *                      Data passed is old voltage cast to (void *).
+ * PRE_DISABLE    Regulator is about to be disabled
+ * ABORT_DISABLE  Regulator disable failed for some reason
  *
  * NOTE: These events can be OR'ed together when passed into handler.
  */
@@ -106,6 +115,23 @@ struct regmap;
 #define REGULATOR_EVENT_FORCE_DISABLE           0x20
 #define REGULATOR_EVENT_VOLTAGE_CHANGE          0x40
 #define REGULATOR_EVENT_DISABLE                 0x80
+#define REGULATOR_EVENT_PRE_VOLTAGE_CHANGE      0x100
+#define REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE    0x200
+#define REGULATOR_EVENT_PRE_DISABLE             0x400
+#define REGULATOR_EVENT_ABORT_DISABLE           0x800
+
+/**
+ * struct pre_voltage_change_data - Data sent with PRE_VOLTAGE_CHANGE event
+ *
+ * @old_uV: Current voltage before change.
+ * @min_uV: Min voltage we'll change to.
+ * @max_uV: Max voltage we'll change to.
+ */
+struct pre_voltage_change_data {
+        unsigned long old_uV;
+        unsigned long min_uV;
+        unsigned long max_uV;
+};
 
 struct regulator;
 
@@ -262,7 +288,7 @@ devm_regulator_get(struct device *dev, const char *id)
 static inline struct regulator *__must_check
 regulator_get_exclusive(struct device *dev, const char *id)
 {
-        return NULL;
+        return ERR_PTR(-ENODEV);
 }
 
 static inline struct regulator *__must_check
diff --git a/include/linux/regulator/da9211.h b/include/linux/regulator/da9211.h
index 0981ce0e72cc..5479394fefce 100644
--- a/include/linux/regulator/da9211.h
+++ b/include/linux/regulator/da9211.h
@@ -1,5 +1,5 @@
 /*
- * da9211.h - Regulator device driver for DA9211
+ * da9211.h - Regulator device driver for DA9211/DA9213
  * Copyright (C) 2014  Dialog Semiconductor Ltd.
  *
  * This library is free software; you can redistribute it and/or
@@ -20,6 +20,11 @@
 
 #define DA9211_MAX_REGULATORS   2
 
+enum da9211_chip_id {
+        DA9211,
+        DA9213,
+};
+
 struct da9211_pdata {
         /*
          * Number of buck
@@ -27,6 +32,6 @@ struct da9211_pdata {
          * 2 : 2 phase 2 buck
          */
         int num_buck;
-        struct regulator_init_data *init_data;
+        struct regulator_init_data *init_data[DA9211_MAX_REGULATORS];
 };
 #endif
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 4efa1ed8a2b0..5f1e9ca47417 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -203,6 +203,8 @@ enum regulator_type {
  *
  * @name: Identifying name for the regulator.
  * @supply_name: Identifying the regulator supply
+ * @of_match: Name used to identify regulator in DT.
+ * @regulators_node: Name of node containing regulator definitions in DT.
  * @id: Numerical identifier for the regulator.
  * @ops: Regulator operations table.
  * @irq: Interrupt number for the regulator.
@@ -240,14 +242,19 @@ enum regulator_type {
  * @bypass_val_off: Disabling value for control when using regmap set_bypass
  *
  * @enable_time: Time taken for initial enable of regulator (in uS).
+ * @off_on_delay: guard time (in uS), before re-enabling a regulator
+ *
+ * @of_map_mode: Maps a hardware mode defined in a DeviceTree to a standard mode
  */
 struct regulator_desc {
         const char *name;
         const char *supply_name;
+        const char *of_match;
+        const char *regulators_node;
         int id;
         bool continuous_voltage_range;
         unsigned n_voltages;
-        struct regulator_ops *ops;
+        const struct regulator_ops *ops;
         int irq;
         enum regulator_type type;
         struct module *owner;
@@ -278,6 +285,10 @@ struct regulator_desc {
         unsigned int bypass_val_off;
 
         unsigned int enable_time;
+
+        unsigned int off_on_delay;
+
+        unsigned int (*of_map_mode)(unsigned int mode);
 };
 
 /**
@@ -294,6 +305,9 @@ struct regulator_desc {
  *           NULL).
  * @regmap: regmap to use for core regmap helpers if dev_get_regulator() is
  *          insufficient.
+ * @ena_gpio_initialized: GPIO controlling regulator enable was properly
+ *                        initialized, meaning that >= 0 is a valid gpio
+ *                        identifier and < 0 is a non existent gpio.
  * @ena_gpio: GPIO controlling regulator enable.
  * @ena_gpio_invert: Sense for GPIO enable control.
  * @ena_gpio_flags: Flags to use when calling gpio_request_one()
@@ -305,6 +319,7 @@ struct regulator_config {
         struct device_node *of_node;
         struct regmap *regmap;
 
+        bool ena_gpio_initialized;
         int ena_gpio;
         unsigned int ena_gpio_invert:1;
         unsigned int ena_gpio_flags;
@@ -350,6 +365,9 @@ struct regulator_dev {
 
         struct regulator_enable_gpio *ena_pin;
         unsigned int ena_gpio_state:1;
+
+        /* time when this regulator was disabled last time */
+        unsigned long last_off_jiffy;
 };
 
 struct regulator_dev *
diff --git a/include/linux/regulator/max1586.h b/include/linux/regulator/max1586.h
index de9a7fae20be..cedd0febe882 100644
--- a/include/linux/regulator/max1586.h
+++ b/include/linux/regulator/max1586.h
@@ -40,7 +40,7 @@
  */
 struct max1586_subdev_data {
         int                             id;
-        char                            *name;
+        const char                      *name;
         struct regulator_init_data      *platform_data;
 };
 
diff --git a/include/linux/regulator/of_regulator.h b/include/linux/regulator/of_regulator.h
index f9217965aaa3..763953f7e3b8 100644
--- a/include/linux/regulator/of_regulator.h
+++ b/include/linux/regulator/of_regulator.h
@@ -6,24 +6,29 @@
 #ifndef __LINUX_OF_REG_H
 #define __LINUX_OF_REG_H
 
+struct regulator_desc;
+
 struct of_regulator_match {
         const char *name;
         void *driver_data;
         struct regulator_init_data *init_data;
         struct device_node *of_node;
+        const struct regulator_desc *desc;
 };
 
 #if defined(CONFIG_OF)
 extern struct regulator_init_data
         *of_get_regulator_init_data(struct device *dev,
-                                    struct device_node *node);
+                                    struct device_node *node,
+                                    const struct regulator_desc *desc);
 extern int of_regulator_match(struct device *dev, struct device_node *node,
                               struct of_regulator_match *matches,
                               unsigned int num_matches);
 #else
 static inline struct regulator_init_data
         *of_get_regulator_init_data(struct device *dev,
-                                    struct device_node *node)
+                                    struct device_node *node,
+                                    const struct regulator_desc *desc)
 {
         return NULL;
 }
diff --git a/include/linux/res_counter.h b/include/linux/res_counter.h
deleted file mode 100644
index 56b7bc32db4f..000000000000
--- a/include/linux/res_counter.h
+++ /dev/null
@@ -1,223 +0,0 @@
-#ifndef __RES_COUNTER_H__
-#define __RES_COUNTER_H__
-
-/*
- * Resource Counters
- * Contain common data types and routines for resource accounting
- *
- * Copyright 2007 OpenVZ SWsoft Inc
- *
- * Author: Pavel Emelianov <xemul@openvz.org>
- *
- * See Documentation/cgroups/resource_counter.txt for more
- * info about what this counter is.
- */
-
-#include <linux/spinlock.h>
-#include <linux/errno.h>
-
-/*
- * The core object. the cgroup that wishes to account for some
- * resource may include this counter into its structures and use
- * the helpers described beyond
- */
-
-struct res_counter {
-        /*
-         * the current resource consumption level
-         */
-        unsigned long long usage;
-        /*
-         * the maximal value of the usage from the counter creation
-         */
-        unsigned long long max_usage;
-        /*
-         * the limit that usage cannot exceed
-         */
-        unsigned long long limit;
-        /*
-         * the limit that usage can be exceed
-         */
-        unsigned long long soft_limit;
-        /*
-         * the number of unsuccessful attempts to consume the resource
-         */
-        unsigned long long failcnt;
-        /*
-         * the lock to protect all of the above.
-         * the routines below consider this to be IRQ-safe
-         */
-        spinlock_t lock;
-        /*
-         * Parent counter, used for hierarchial resource accounting
-         */
-        struct res_counter *parent;
-};
-
-#define RES_COUNTER_MAX ULLONG_MAX
-
-/**
- * Helpers to interact with userspace
- * res_counter_read_u64() - returns the value of the specified member.
- * res_counter_read/_write - put/get the specified fields from the
- * res_counter struct to/from the user
- *
- * @counter:     the counter in question
- * @member:  the field to work with (see RES_xxx below)
- * @buf:     the buffer to opeate on,...
- * @nbytes:  its size...
- * @pos:     and the offset.
- */
-
-u64 res_counter_read_u64(struct res_counter *counter, int member);
-
-ssize_t res_counter_read(struct res_counter *counter, int member,
-                const char __user *buf, size_t nbytes, loff_t *pos,
-                int (*read_strategy)(unsigned long long val, char *s));
-
-int res_counter_memparse_write_strategy(const char *buf,
-                                        unsigned long long *res);
-
-/*
- * the field descriptors. one for each member of res_counter
- */
-
-enum {
-        RES_USAGE,
-        RES_MAX_USAGE,
-        RES_LIMIT,
-        RES_FAILCNT,
-        RES_SOFT_LIMIT,
-};
-
-/*
- * helpers for accounting
- */
-
-void res_counter_init(struct res_counter *counter, struct res_counter *parent);
-
-/*
- * charge - try to consume more resource.
- *
- * @counter: the counter
- * @val: the amount of the resource. each controller defines its own
- *       units, e.g. numbers, bytes, Kbytes, etc
- *
- * returns 0 on success and <0 if the counter->usage will exceed the
- * counter->limit
- *
- * charge_nofail works the same, except that it charges the resource
- * counter unconditionally, and returns < 0 if the after the current
- * charge we are over limit.
- */
-
-int __must_check res_counter_charge(struct res_counter *counter,
-                unsigned long val, struct res_counter **limit_fail_at);
-int res_counter_charge_nofail(struct res_counter *counter,
-                unsigned long val, struct res_counter **limit_fail_at);
-
-/*
- * uncharge - tell that some portion of the resource is released
- *
- * @counter: the counter
- * @val: the amount of the resource
- *
- * these calls check for usage underflow and show a warning on the console
- *
- * returns the total charges still present in @counter.
- */
-
-u64 res_counter_uncharge(struct res_counter *counter, unsigned long val);
-
-u64 res_counter_uncharge_until(struct res_counter *counter,
-                               struct res_counter *top,
-                               unsigned long val);
-/**
- * res_counter_margin - calculate chargeable space of a counter
- * @cnt: the counter
- *
- * Returns the difference between the hard limit and the current usage
- * of resource counter @cnt.
- */
-static inline unsigned long long res_counter_margin(struct res_counter *cnt)
-{
-        unsigned long long margin;
-        unsigned long flags;
-
-        spin_lock_irqsave(&cnt->lock, flags);
-        if (cnt->limit > cnt->usage)
-                margin = cnt->limit - cnt->usage;
-        else
-                margin = 0;
-        spin_unlock_irqrestore(&cnt->lock, flags);
-        return margin;
-}
-
-/**
- * Get the difference between the usage and the soft limit
- * @cnt: The counter
- *
- * Returns 0 if usage is less than or equal to soft limit
- * The difference between usage and soft limit, otherwise.
- */
-static inline unsigned long long
-res_counter_soft_limit_excess(struct res_counter *cnt)
-{
-        unsigned long long excess;
-        unsigned long flags;
-
-        spin_lock_irqsave(&cnt->lock, flags);
-        if (cnt->usage <= cnt->soft_limit)
-                excess = 0;
-        else
-                excess = cnt->usage - cnt->soft_limit;
-        spin_unlock_irqrestore(&cnt->lock, flags);
-        return excess;
-}
-
-static inline void res_counter_reset_max(struct res_counter *cnt)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&cnt->lock, flags);
-        cnt->max_usage = cnt->usage;
-        spin_unlock_irqrestore(&cnt->lock, flags);
-}
-
-static inline void res_counter_reset_failcnt(struct res_counter *cnt)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&cnt->lock, flags);
-        cnt->failcnt = 0;
-        spin_unlock_irqrestore(&cnt->lock, flags);
-}
-
-static inline int res_counter_set_limit(struct res_counter *cnt,
-                unsigned long long limit)
-{
-        unsigned long flags;
-        int ret = -EBUSY;
-
-        spin_lock_irqsave(&cnt->lock, flags);
-        if (cnt->usage <= limit) {
-                cnt->limit = limit;
-                ret = 0;
-        }
-        spin_unlock_irqrestore(&cnt->lock, flags);
-        return ret;
-}
-
-static inline int
-res_counter_set_soft_limit(struct res_counter *cnt,
-                                unsigned long long soft_limit)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&cnt->lock, flags);
-        cnt->soft_limit = soft_limit;
-        spin_unlock_irqrestore(&cnt->lock, flags);
-        return 0;
-}
-
-#endif
diff --git a/include/linux/reset-controller.h b/include/linux/reset-controller.h
index 41a4695fde08..ce6b962ffed4 100644
--- a/include/linux/reset-controller.h
+++ b/include/linux/reset-controller.h
@@ -12,11 +12,13 @@ struct reset_controller_dev;
  *         things to reset the device
  * @assert: manually assert the reset line, if supported
  * @deassert: manually deassert the reset line, if supported
+ * @status: return the status of the reset line, if supported
  */
 struct reset_control_ops {
         int (*reset)(struct reset_controller_dev *rcdev, unsigned long id);
         int (*assert)(struct reset_controller_dev *rcdev, unsigned long id);
         int (*deassert)(struct reset_controller_dev *rcdev, unsigned long id);
+        int (*status)(struct reset_controller_dev *rcdev, unsigned long id);
 };
 
 struct module;
diff --git a/include/linux/reset.h b/include/linux/reset.h
index 349f150ae12c..da5602bd77d7 100644
--- a/include/linux/reset.h
+++ b/include/linux/reset.h
@@ -10,6 +10,7 @@ struct reset_control;
 int reset_control_reset(struct reset_control *rstc);
 int reset_control_assert(struct reset_control *rstc);
 int reset_control_deassert(struct reset_control *rstc);
+int reset_control_status(struct reset_control *rstc);
 
 struct reset_control *reset_control_get(struct device *dev, const char *id);
 void reset_control_put(struct reset_control *rstc);
@@ -57,6 +58,12 @@ static inline int reset_control_deassert(struct reset_control *rstc)
         return 0;
 }
 
+static inline int reset_control_status(struct reset_control *rstc)
+{
+        WARN_ON(1);
+        return 0;
+}
+
 static inline void reset_control_put(struct reset_control *rstc)
 {
         WARN_ON(1);
diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h
index 36826c0166c5..b93fd89b2e5e 100644
--- a/include/linux/rhashtable.h
+++ b/include/linux/rhashtable.h
@@ -44,6 +44,7 @@ struct rhashtable;
  * @head_offset: Offset of rhash_head in struct to be hashed
  * @hash_rnd: Seed to use while hashing
  * @max_shift: Maximum number of shifts while expanding
+ * @min_shift: Minimum number of shifts while shrinking
  * @hashfn: Function to hash key
  * @obj_hashfn: Function to hash object
  * @grow_decision: If defined, may return true if table should expand
@@ -57,13 +58,17 @@ struct rhashtable_params {
         size_t                  head_offset;
         u32                     hash_rnd;
         size_t                  max_shift;
+        size_t                  min_shift;
         rht_hashfn_t            hashfn;
         rht_obj_hashfn_t        obj_hashfn;
         bool                    (*grow_decision)(const struct rhashtable *ht,
                                                  size_t new_size);
         bool                    (*shrink_decision)(const struct rhashtable *ht,
                                                    size_t new_size);
-        int                     (*mutex_is_held)(void);
+#ifdef CONFIG_PROVE_LOCKING
+        int                     (*mutex_is_held)(void *parent);
+        void                    *parent;
+#endif
 };
 
 /**
@@ -94,16 +99,16 @@ int rhashtable_init(struct rhashtable *ht, struct rhashtable_params *params);
 u32 rhashtable_hashfn(const struct rhashtable *ht, const void *key, u32 len);
 u32 rhashtable_obj_hashfn(const struct rhashtable *ht, void *ptr);
 
-void rhashtable_insert(struct rhashtable *ht, struct rhash_head *node, gfp_t);
-bool rhashtable_remove(struct rhashtable *ht, struct rhash_head *node, gfp_t);
+void rhashtable_insert(struct rhashtable *ht, struct rhash_head *node);
+bool rhashtable_remove(struct rhashtable *ht, struct rhash_head *node);
 void rhashtable_remove_pprev(struct rhashtable *ht, struct rhash_head *obj,
-                             struct rhash_head __rcu **pprev, gfp_t flags);
+                             struct rhash_head __rcu **pprev);
 
 bool rht_grow_above_75(const struct rhashtable *ht, size_t new_size);
 bool rht_shrink_below_30(const struct rhashtable *ht, size_t new_size);
 
-int rhashtable_expand(struct rhashtable *ht, gfp_t flags);
-int rhashtable_shrink(struct rhashtable *ht, gfp_t flags);
+int rhashtable_expand(struct rhashtable *ht);
+int rhashtable_shrink(struct rhashtable *ht);
 
 void *rhashtable_lookup(const struct rhashtable *ht, const void *key);
 void *rhashtable_lookup_compare(const struct rhashtable *ht, u32 hash,
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index 49a4d6f59108..e2c13cd863bd 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -97,7 +97,7 @@ __ring_buffer_alloc(unsigned long size, unsigned flags, struct lock_class_key *k
         __ring_buffer_alloc((size), (flags), &__key);   \
 })
 
-int ring_buffer_wait(struct ring_buffer *buffer, int cpu);
+int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full);
 int ring_buffer_poll_wait(struct ring_buffer *buffer, int cpu,
                           struct file *filp, poll_table *poll_table);
 
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index be574506e6a9..d9d7e7e56352 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -37,6 +37,16 @@ struct anon_vma {
         atomic_t refcount;
 
         /*
+         * Count of child anon_vmas and VMAs which points to this anon_vma.
+         *
+         * This counter is used for making decision about reusing anon_vma
+         * instead of forking new one. See comments in function anon_vma_clone.
+         */
+        unsigned degree;
+
+        struct anon_vma *parent;        /* Parent of this anon_vma */
+
+        /*
          * NOTE: the LSB of the rb_root.rb_node is set by
          * mm_take_all_locks() _after_ taking the above lock. So the
          * rb_root must only be read/written after taking the above lock
@@ -150,7 +160,7 @@ int anon_vma_fork(struct vm_area_struct *, struct vm_area_struct *);
 static inline void anon_vma_merge(struct vm_area_struct *vma,
                                   struct vm_area_struct *next)
 {
-        VM_BUG_ON(vma->anon_vma != next->anon_vma);
+        VM_BUG_ON_VMA(vma->anon_vma != next->anon_vma, vma);
         unlink_anon_vmas(next);
 }
 
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index c2c28975293c..6d6be09a2fe5 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -19,11 +19,28 @@
 extern int rtc_month_days(unsigned int month, unsigned int year);
 extern int rtc_year_days(unsigned int day, unsigned int month, unsigned int year);
 extern int rtc_valid_tm(struct rtc_time *tm);
-extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time);
-extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm);
+extern time64_t rtc_tm_to_time64(struct rtc_time *tm);
+extern void rtc_time64_to_tm(time64_t time, struct rtc_time *tm);
 ktime_t rtc_tm_to_ktime(struct rtc_time tm);
 struct rtc_time rtc_ktime_to_tm(ktime_t kt);
 
+/**
+ * Deprecated. Use rtc_time64_to_tm().
+ */
+static inline void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
+{
+        rtc_time64_to_tm(time, tm);
+}
+
+/**
+ * Deprecated. Use rtc_tm_to_time64().
+ */
+static inline int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
+{
+        *time = rtc_tm_to_time64(tm);
+
+        return 0;
+}
 
 #include <linux/device.h>
 #include <linux/seq_file.h>
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 167bae7bdfa4..5db76a32fcab 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -17,6 +17,11 @@ extern int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst,
                               u32 id, long expires, u32 error);
 
 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change, gfp_t flags);
+struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
+                                       unsigned change, gfp_t flags);
+void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev,
+                       gfp_t flags);
+
 
 /* RTNL is used as a global lock for all changes to network configuration  */
 extern void rtnl_lock(void);
@@ -47,6 +52,16 @@ static inline int lockdep_rtnl_is_held(void)
         rcu_dereference_check(p, lockdep_rtnl_is_held())
 
 /**
+ * rcu_dereference_bh_rtnl - rcu_dereference_bh with debug checking
+ * @p: The pointer to read, prior to dereference
+ *
+ * Do an rcu_dereference_bh(p), but check caller either holds rcu_read_lock_bh()
+ * or RTNL. Note : Please prefer rtnl_dereference() or rcu_dereference_bh()
+ */
+#define rcu_dereference_bh_rtnl(p)                              \
+        rcu_dereference_bh_check(p, lockdep_rtnl_is_held())
+
+/**
  * rtnl_dereference - fetch RCU pointer when updates are prevented by RTNL
  * @p: The pointer to read, prior to dereferencing
  *
@@ -84,12 +99,15 @@ extern int ndo_dflt_fdb_add(struct ndmsg *ndm,
                             struct nlattr *tb[],
                             struct net_device *dev,
                             const unsigned char *addr,
-                             u16 flags);
+                            u16 vid,
+                            u16 flags);
 extern int ndo_dflt_fdb_del(struct ndmsg *ndm,
                             struct nlattr *tb[],
                             struct net_device *dev,
-                            const unsigned char *addr);
+                            const unsigned char *addr,
+                            u16 vid);
 
 extern int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
-                                   struct net_device *dev, u16 mode);
+                                   struct net_device *dev, u16 mode,
+                                   u32 flags, u32 mask);
 #endif  /* __LINUX_RTNETLINK_H */
diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h
index 035d3c57fc8a..8f498cdde280 100644
--- a/include/linux/rwsem.h
+++ b/include/linux/rwsem.h
@@ -149,7 +149,7 @@ extern void downgrade_write(struct rw_semaphore *sem);
  * static then another method for expressing nested locking is
  * the explicit definition of lock class keys and the use of
  * lockdep_set_class() at lock initialization time.
- * See Documentation/lockdep-design.txt for more details.)
+ * See Documentation/locking/lockdep-design.txt for more details.)
  */
 extern void down_read_nested(struct rw_semaphore *sem, int subclass);
 extern void down_write_nested(struct rw_semaphore *sem, int subclass);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index b867a4dab38a..8db31ef98d2f 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -57,6 +57,7 @@ struct sched_param {
 #include <linux/llist.h>
 #include <linux/uidgid.h>
 #include <linux/gfp.h>
+#include <linux/magic.h>
 
 #include <asm/processor.h>
 
@@ -167,6 +168,7 @@ extern int nr_threads;
 DECLARE_PER_CPU(unsigned long, process_counts);
 extern int nr_processes(void);
 extern unsigned long nr_running(void);
+extern bool single_task_running(void);
 extern unsigned long nr_iowait(void);
 extern unsigned long nr_iowait_cpu(int cpu);
 extern void get_iowait_load(unsigned long *nr_waiters, unsigned long *load);
@@ -241,6 +243,43 @@ extern char ___assert_task_state[1 - 2*!!(
                                 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
                                  (task->flags & PF_FROZEN) == 0)
 
+#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
+
+#define __set_task_state(tsk, state_value)                      \
+        do {                                                    \
+                (tsk)->task_state_change = _THIS_IP_;           \
+                (tsk)->state = (state_value);                   \
+        } while (0)
+#define set_task_state(tsk, state_value)                        \
+        do {                                                    \
+                (tsk)->task_state_change = _THIS_IP_;           \
+                set_mb((tsk)->state, (state_value));            \
+        } while (0)
+
+/*
+ * set_current_state() includes a barrier so that the write of current->state
+ * is correctly serialised wrt the caller's subsequent test of whether to
+ * actually sleep:
+ *
+ *      set_current_state(TASK_UNINTERRUPTIBLE);
+ *      if (do_i_need_to_sleep())
+ *              schedule();
+ *
+ * If the caller does not need such serialisation then use __set_current_state()
+ */
+#define __set_current_state(state_value)                        \
+        do {                                                    \
+                current->task_state_change = _THIS_IP_;         \
+                current->state = (state_value);                 \
+        } while (0)
+#define set_current_state(state_value)                          \
+        do {                                                    \
+                current->task_state_change = _THIS_IP_;         \
+                set_mb(current->state, (state_value));          \
+        } while (0)
+
+#else
+
 #define __set_task_state(tsk, state_value)              \
         do { (tsk)->state = (state_value); } while (0)
 #define set_task_state(tsk, state_value)                \
@@ -257,11 +296,13 @@ extern char ___assert_task_state[1 - 2*!!(
  *
  * If the caller does not need such serialisation then use __set_current_state()
  */
-#define __set_current_state(state_value)                        \
+#define __set_current_state(state_value)                \
         do { current->state = (state_value); } while (0)
-#define set_current_state(state_value)          \
+#define set_current_state(state_value)                  \
         set_mb(current->state, (state_value))
 
+#endif
+
 /* Task command name length */
 #define TASK_COMM_LEN 16
 
@@ -645,6 +686,7 @@ struct signal_struct {
          * Live threads maintain their own counters and add to these
          * in __exit_signal, except for the group leader.
          */
+        seqlock_t stats_lock;
         cputime_t utime, stime, cutime, cstime;
         cputime_t gtime;
         cputime_t cgtime;
@@ -1023,6 +1065,7 @@ struct sched_domain_topology_level {
 extern struct sched_domain_topology_level *sched_domain_topology;
 
 extern void set_sched_topology(struct sched_domain_topology_level *tl);
+extern void wake_up_if_idle(int cpu);
 
 #ifdef CONFIG_SCHED_DEBUG
 # define SD_INIT_NAME(type)             .name = #type
@@ -1212,6 +1255,13 @@ struct sched_dl_entity {
         struct hrtimer dl_timer;
 };
 
+union rcu_special {
+        struct {
+                bool blocked;
+                bool need_qs;
+        } b;
+        short s;
+};
 struct rcu_node;
 
 enum perf_event_task_context {
@@ -1264,12 +1314,18 @@ struct task_struct {
 
 #ifdef CONFIG_PREEMPT_RCU
         int rcu_read_lock_nesting;
-        char rcu_read_unlock_special;
+        union rcu_special rcu_read_unlock_special;
         struct list_head rcu_node_entry;
 #endif /* #ifdef CONFIG_PREEMPT_RCU */
-#ifdef CONFIG_TREE_PREEMPT_RCU
+#ifdef CONFIG_PREEMPT_RCU
         struct rcu_node *rcu_blocked_node;
-#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+#endif /* #ifdef CONFIG_PREEMPT_RCU */
+#ifdef CONFIG_TASKS_RCU
+        unsigned long rcu_tasks_nvcsw;
+        bool rcu_tasks_holdout;
+        struct list_head rcu_tasks_holdout_list;
+        int rcu_tasks_idle_cpu;
+#endif /* #ifdef CONFIG_TASKS_RCU */
 
 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
         struct sched_info sched_info;
@@ -1308,6 +1364,10 @@ struct task_struct {
         unsigned sched_reset_on_fork:1;
         unsigned sched_contributes_to_load:1;
 
+#ifdef CONFIG_MEMCG_KMEM
+        unsigned memcg_kmem_skip_account:1;
+#endif
+
         unsigned long atomic_flags; /* Flags needing atomic access. */
 
         pid_t pid;
@@ -1541,28 +1601,23 @@ struct task_struct {
         struct numa_group *numa_group;
 
         /*
-         * Exponential decaying average of faults on a per-node basis.
-         * Scheduling placement decisions are made based on the these counts.
-         * The values remain static for the duration of a PTE scan
+         * numa_faults is an array split into four regions:
+         * faults_memory, faults_cpu, faults_memory_buffer, faults_cpu_buffer
+         * in this precise order.
+         *
+         * faults_memory: Exponential decaying average of faults on a per-node
+         * basis. Scheduling placement decisions are made based on these
+         * counts. The values remain static for the duration of a PTE scan.
+         * faults_cpu: Track the nodes the process was running on when a NUMA
+         * hinting fault was incurred.
+         * faults_memory_buffer and faults_cpu_buffer: Record faults per node
+         * during the current scan window. When the scan completes, the counts
+         * in faults_memory and faults_cpu decay and these values are copied.
          */
-        unsigned long *numa_faults_memory;
+        unsigned long *numa_faults;
         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_memory decay and these values are copied.
-         */
-        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
          * scan window were remote/local. The task scan period is adapted
          * based on the locality of the faults with different weights
@@ -1628,8 +1683,7 @@ struct task_struct {
         /* bitmask and counter of trace recursion */
         unsigned long trace_recursion;
 #endif /* CONFIG_TRACING */
-#ifdef CONFIG_MEMCG /* memcg uses this to do batch job */
-        unsigned int memcg_kmem_skip_account;
+#ifdef CONFIG_MEMCG
         struct memcg_oom_info {
                 struct mem_cgroup *memcg;
                 gfp_t gfp_mask;
@@ -1644,6 +1698,9 @@ struct task_struct {
         unsigned int    sequential_io;
         unsigned int    sequential_io_avg;
 #endif
+#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
+        unsigned long   task_state_change;
+#endif
 };
 
 /* Future-safe accessor for struct task_struct's cpus_allowed. */
@@ -1934,11 +1991,13 @@ extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut,
 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
 #define used_math() tsk_used_math(current)
 
-/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */
+/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags
+ * __GFP_FS is also cleared as it implies __GFP_IO.
+ */
 static inline gfp_t memalloc_noio_flags(gfp_t flags)
 {
         if (unlikely(current->flags & PF_MEMALLOC_NOIO))
-                flags &= ~__GFP_IO;
+                flags &= ~(__GFP_IO | __GFP_FS);
         return flags;
 }
 
@@ -2011,29 +2070,21 @@ extern void task_clear_jobctl_trapping(struct task_struct *task);
 extern void task_clear_jobctl_pending(struct task_struct *task,
                                       unsigned int mask);
 
-#ifdef CONFIG_PREEMPT_RCU
-
-#define RCU_READ_UNLOCK_BLOCKED (1 << 0) /* blocked while in RCU read-side. */
-#define RCU_READ_UNLOCK_NEED_QS (1 << 1) /* RCU core needs CPU response. */
-
 static inline void rcu_copy_process(struct task_struct *p)
 {
+#ifdef CONFIG_PREEMPT_RCU
         p->rcu_read_lock_nesting = 0;
-        p->rcu_read_unlock_special = 0;
-#ifdef CONFIG_TREE_PREEMPT_RCU
+        p->rcu_read_unlock_special.s = 0;
         p->rcu_blocked_node = NULL;
-#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
         INIT_LIST_HEAD(&p->rcu_node_entry);
+#endif /* #ifdef CONFIG_PREEMPT_RCU */
+#ifdef CONFIG_TASKS_RCU
+        p->rcu_tasks_holdout = false;
+        INIT_LIST_HEAD(&p->rcu_tasks_holdout_list);
+        p->rcu_tasks_idle_cpu = -1;
+#endif /* #ifdef CONFIG_TASKS_RCU */
 }
 
-#else
-
-static inline void rcu_copy_process(struct task_struct *p)
-{
-}
-
-#endif
-
 static inline void tsk_restore_flags(struct task_struct *task,
                                 unsigned long orig_flags, unsigned long flags)
 {
@@ -2041,6 +2092,10 @@ static inline void tsk_restore_flags(struct task_struct *task,
         task->flags |= orig_flags & flags;
 }
 
+extern int cpuset_cpumask_can_shrink(const struct cpumask *cur,
+                                     const struct cpumask *trial);
+extern int task_can_attach(struct task_struct *p,
+                           const struct cpumask *cs_cpus_allowed);
 #ifdef CONFIG_SMP
 extern void do_set_cpus_allowed(struct task_struct *p,
                                const struct cpumask *new_mask);
@@ -2430,6 +2485,10 @@ extern void do_group_exit(int);
 extern int do_execve(struct filename *,
                      const char __user * const __user *,
                      const char __user * const __user *);
+extern int do_execveat(int, struct filename *,
+                       const char __user * const __user *,
+                       const char __user * const __user *,
+                       int);
 extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);
 struct task_struct *fork_idle(int);
 extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
@@ -2639,6 +2698,8 @@ static inline unsigned long *end_of_stack(struct task_struct *p)
 }
 
 #endif
+#define task_stack_end_corrupted(task) \
+                (*(end_of_stack(task)) != STACK_END_MAGIC)
 
 static inline int object_is_on_stack(void *obj)
 {
@@ -2661,6 +2722,7 @@ static inline unsigned long stack_not_used(struct task_struct *p)
         return (unsigned long)n - (unsigned long)end_of_stack(p);
 }
 #endif
+extern void set_task_stack_end_magic(struct task_struct *tsk);
 
 /* set thread flags in other task's structures
  * - see asm/thread_info.h for TIF_xxxx flags available
@@ -2746,7 +2808,7 @@ static inline int signal_pending_state(long state, struct task_struct *p)
 extern int _cond_resched(void);
 
 #define cond_resched() ({                       \
-        __might_sleep(__FILE__, __LINE__, 0);   \
+        ___might_sleep(__FILE__, __LINE__, 0);  \
         _cond_resched();                        \
 })
 
@@ -2759,14 +2821,14 @@ extern int __cond_resched_lock(spinlock_t *lock);
 #endif
 
 #define cond_resched_lock(lock) ({                              \
-        __might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET); \
+        ___might_sleep(__FILE__, __LINE__, PREEMPT_LOCK_OFFSET);\
         __cond_resched_lock(lock);                              \
 })
 
 extern int __cond_resched_softirq(void);
 
 #define cond_resched_softirq() ({                                       \
-        __might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET);      \
+        ___might_sleep(__FILE__, __LINE__, SOFTIRQ_DISABLE_OFFSET);     \
         __cond_resched_softirq();                                       \
 })
 
diff --git a/include/linux/screen_info.h b/include/linux/screen_info.h
index 005bf3e38db5..f0f8bad54be9 100644
--- a/include/linux/screen_info.h
+++ b/include/linux/screen_info.h
@@ -5,12 +5,4 @@
 
 extern struct screen_info screen_info;
 
-#define ORIG_X                  (screen_info.orig_x)
-#define ORIG_Y                  (screen_info.orig_y)
-#define ORIG_VIDEO_MODE         (screen_info.orig_video_mode)
-#define ORIG_VIDEO_COLS         (screen_info.orig_video_cols)
-#define ORIG_VIDEO_EGA_BX       (screen_info.orig_video_ega_bx)
-#define ORIG_VIDEO_LINES        (screen_info.orig_video_lines)
-#define ORIG_VIDEO_ISVGA        (screen_info.orig_video_isVGA)
-#define ORIG_VIDEO_POINTS       (screen_info.orig_video_points)
 #endif /* _SCREEN_INFO_H */
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index 5d586a45a319..a19ddacdac30 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -27,19 +27,23 @@ struct seccomp {
         struct seccomp_filter *filter;
 };
 
-extern int __secure_computing(int);
-static inline int secure_computing(int this_syscall)
+#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER
+extern int __secure_computing(void);
+static inline int secure_computing(void)
 {
         if (unlikely(test_thread_flag(TIF_SECCOMP)))
-                return  __secure_computing(this_syscall);
+                return  __secure_computing();
         return 0;
 }
 
-/* A wrapper for architectures supporting only SECCOMP_MODE_STRICT. */
-static inline void secure_computing_strict(int this_syscall)
-{
-        BUG_ON(secure_computing(this_syscall) != 0);
-}
+#define SECCOMP_PHASE1_OK       0
+#define SECCOMP_PHASE1_SKIP     1
+
+extern u32 seccomp_phase1(struct seccomp_data *sd);
+int seccomp_phase2(u32 phase1_result);
+#else
+extern void secure_computing_strict(int this_syscall);
+#endif
 
 extern long prctl_get_seccomp(void);
 extern long prctl_set_seccomp(unsigned long, char __user *);
@@ -56,8 +60,11 @@ static inline int seccomp_mode(struct seccomp *s)
 struct seccomp { };
 struct seccomp_filter { };
 
-static inline int secure_computing(int this_syscall) { return 0; }
+#ifdef CONFIG_HAVE_ARCH_SECCOMP_FILTER
+static inline int secure_computing(void) { return 0; }
+#else
 static inline void secure_computing_strict(int this_syscall) { return; }
+#endif
 
 static inline long prctl_get_seccomp(void)
 {
diff --git a/include/linux/security.h b/include/linux/security.h
index 623f90e5f38d..ba96471c11ba 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1559,7 +1559,7 @@ struct security_operations {
         int (*file_lock) (struct file *file, unsigned int cmd);
         int (*file_fcntl) (struct file *file, unsigned int cmd,
                            unsigned long arg);
-        int (*file_set_fowner) (struct file *file);
+        void (*file_set_fowner) (struct file *file);
         int (*file_send_sigiotask) (struct task_struct *tsk,
                                     struct fown_struct *fown, int sig);
         int (*file_receive) (struct file *file);
@@ -1834,7 +1834,7 @@ int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
                            unsigned long prot);
 int security_file_lock(struct file *file, unsigned int cmd);
 int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg);
-int security_file_set_fowner(struct file *file);
+void security_file_set_fowner(struct file *file);
 int security_file_send_sigiotask(struct task_struct *tsk,
                                  struct fown_struct *fown, int sig);
 int security_file_receive(struct file *file);
@@ -2108,7 +2108,7 @@ static inline int security_dentry_init_security(struct dentry *dentry,
 static inline int security_inode_init_security(struct inode *inode,
                                                 struct inode *dir,
                                                 const struct qstr *qstr,
-                                                const initxattrs initxattrs,
+                                                const initxattrs xattrs,
                                                 void *fs_data)
 {
         return 0;
@@ -2312,9 +2312,9 @@ static inline int security_file_fcntl(struct file *file, unsigned int cmd,
         return 0;
 }
 
-static inline int security_file_set_fowner(struct file *file)
+static inline void security_file_set_fowner(struct file *file)
 {
-        return 0;
+        return;
 }
 
 static inline int security_file_send_sigiotask(struct task_struct *tsk,
diff --git a/include/linux/seq_buf.h b/include/linux/seq_buf.h
new file mode 100644
index 000000000000..9aafe0e24c68
--- /dev/null
+++ b/include/linux/seq_buf.h
@@ -0,0 +1,136 @@
+#ifndef _LINUX_SEQ_BUF_H
+#define _LINUX_SEQ_BUF_H
+
+#include <linux/fs.h>
+
+/*
+ * Trace sequences are used to allow a function to call several other functions
+ * to create a string of data to use.
+ */
+
+/**
+ * seq_buf - seq buffer structure
+ * @buffer:     pointer to the buffer
+ * @size:       size of the buffer
+ * @len:        the amount of data inside the buffer
+ * @readpos:    The next position to read in the buffer.
+ */
+struct seq_buf {
+        char                    *buffer;
+        size_t                  size;
+        size_t                  len;
+        loff_t                  readpos;
+};
+
+static inline void seq_buf_clear(struct seq_buf *s)
+{
+        s->len = 0;
+        s->readpos = 0;
+}
+
+static inline void
+seq_buf_init(struct seq_buf *s, unsigned char *buf, unsigned int size)
+{
+        s->buffer = buf;
+        s->size = size;
+        seq_buf_clear(s);
+}
+
+/*
+ * seq_buf have a buffer that might overflow. When this happens
+ * the len and size are set to be equal.
+ */
+static inline bool
+seq_buf_has_overflowed(struct seq_buf *s)
+{
+        return s->len > s->size;
+}
+
+static inline void
+seq_buf_set_overflow(struct seq_buf *s)
+{
+        s->len = s->size + 1;
+}
+
+/*
+ * How much buffer is left on the seq_buf?
+ */
+static inline unsigned int
+seq_buf_buffer_left(struct seq_buf *s)
+{
+        if (seq_buf_has_overflowed(s))
+                return 0;
+
+        return s->size - s->len;
+}
+
+/* How much buffer was written? */
+static inline unsigned int seq_buf_used(struct seq_buf *s)
+{
+        return min(s->len, s->size);
+}
+
+/**
+ * seq_buf_get_buf - get buffer to write arbitrary data to
+ * @s: the seq_buf handle
+ * @bufp: the beginning of the buffer is stored here
+ *
+ * Return the number of bytes available in the buffer, or zero if
+ * there's no space.
+ */
+static inline size_t seq_buf_get_buf(struct seq_buf *s, char **bufp)
+{
+        WARN_ON(s->len > s->size + 1);
+
+        if (s->len < s->size) {
+                *bufp = s->buffer + s->len;
+                return s->size - s->len;
+        }
+
+        *bufp = NULL;
+        return 0;
+}
+
+/**
+ * seq_buf_commit - commit data to the buffer
+ * @s: the seq_buf handle
+ * @num: the number of bytes to commit
+ *
+ * Commit @num bytes of data written to a buffer previously acquired
+ * by seq_buf_get.  To signal an error condition, or that the data
+ * didn't fit in the available space, pass a negative @num value.
+ */
+static inline void seq_buf_commit(struct seq_buf *s, int num)
+{
+        if (num < 0) {
+                seq_buf_set_overflow(s);
+        } else {
+                /* num must be negative on overflow */
+                BUG_ON(s->len + num > s->size);
+                s->len += num;
+        }
+}
+
+extern __printf(2, 3)
+int seq_buf_printf(struct seq_buf *s, const char *fmt, ...);
+extern __printf(2, 0)
+int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args);
+extern int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s);
+extern int seq_buf_to_user(struct seq_buf *s, char __user *ubuf,
+                           int cnt);
+extern int seq_buf_puts(struct seq_buf *s, const char *str);
+extern int seq_buf_putc(struct seq_buf *s, unsigned char c);
+extern int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len);
+extern int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
+                              unsigned int len);
+extern int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc);
+
+extern int seq_buf_bitmask(struct seq_buf *s, const unsigned long *maskp,
+                           int nmaskbits);
+
+#ifdef CONFIG_BINARY_PRINTF
+extern int
+seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary);
+#endif
+
+#endif /* _LINUX_SEQ_BUF_H */
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 52e0097f61f0..cf6a9daaaf6d 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -43,6 +43,21 @@ struct seq_operations {
 #define SEQ_SKIP 1
 
 /**
+ * seq_has_overflowed - check if the buffer has overflowed
+ * @m: the seq_file handle
+ *
+ * seq_files have a buffer which may overflow. When this happens a larger
+ * buffer is reallocated and all the data will be printed again.
+ * The overflow state is true when m->count == m->size.
+ *
+ * Returns true if the buffer received more than it can hold.
+ */
+static inline bool seq_has_overflowed(struct seq_file *m)
+{
+        return m->count == m->size;
+}
+
+/**
  * seq_get_buf - get buffer to write arbitrary data to
  * @m: the seq_file handle
  * @bufp: the beginning of the buffer is stored here
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index cc359636cfa3..f5df8f687b4d 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -456,4 +456,23 @@ read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags)
         spin_unlock_irqrestore(&sl->lock, flags);
 }
 
+static inline unsigned long
+read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)
+{
+        unsigned long flags = 0;
+
+        if (!(*seq & 1))        /* Even */
+                *seq = read_seqbegin(lock);
+        else                    /* Odd */
+                read_seqlock_excl_irqsave(lock, flags);
+
+        return flags;
+}
+
+static inline void
+done_seqretry_irqrestore(seqlock_t *lock, int seq, unsigned long flags)
+{
+        if (seq & 1)
+                read_sequnlock_excl_irqrestore(lock, flags);
+}
 #endif /* __LINUX_SEQLOCK_H */
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index f93649e22c43..e02acf0a0ec9 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -84,6 +84,7 @@ struct uart_8250_port {
         unsigned char           mcr_mask;       /* mask of user bits */
         unsigned char           mcr_force;      /* mask of forced bits */
         unsigned char           cur_iotype;     /* Running I/O type */
+        unsigned int            rpm_tx_active;
 
         /*
          * Some bits in registers are cleared on a read, so they must
@@ -121,6 +122,8 @@ extern void serial8250_early_out(struct uart_port *port, int offset, int value);
 extern int setup_early_serial8250_console(char *cmdline);
 extern void serial8250_do_set_termios(struct uart_port *port,
                 struct ktermios *termios, struct ktermios *old);
+extern int serial8250_do_startup(struct uart_port *port);
+extern void serial8250_do_shutdown(struct uart_port *port);
 extern void serial8250_do_pm(struct uart_port *port, unsigned int state,
                              unsigned int oldstate);
 extern int fsl8250_handle_irq(struct uart_port *port);
diff --git a/include/linux/serial_bcm63xx.h b/include/linux/serial_bcm63xx.h
index a80aa1a5bee2..570e964dc899 100644
--- a/include/linux/serial_bcm63xx.h
+++ b/include/linux/serial_bcm63xx.h
@@ -116,6 +116,4 @@
                                         UART_FIFO_PARERR_MASK |         \
                                         UART_FIFO_BRKDET_MASK)
 
-#define UART_REG_SIZE                   24
-
 #endif /* _LINUX_SERIAL_BCM63XX_H */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index cf3a1e789bf5..057038cf2788 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -63,7 +63,7 @@ struct uart_ops {
         void            (*flush_buffer)(struct uart_port *);
         void            (*set_termios)(struct uart_port *, struct ktermios *new,
                                        struct ktermios *old);
-        void            (*set_ldisc)(struct uart_port *, int new);
+        void            (*set_ldisc)(struct uart_port *, struct ktermios *);
         void            (*pm)(struct uart_port *, unsigned int state,
                               unsigned int oldstate);
 
@@ -112,6 +112,7 @@ struct uart_icount {
 };
 
 typedef unsigned int __bitwise__ upf_t;
+typedef unsigned int __bitwise__ upstat_t;
 
 struct uart_port {
         spinlock_t              lock;                   /* port lock */
@@ -122,10 +123,16 @@ struct uart_port {
         void                    (*set_termios)(struct uart_port *,
                                                struct ktermios *new,
                                                struct ktermios *old);
+        int                     (*startup)(struct uart_port *port);
+        void                    (*shutdown)(struct uart_port *port);
+        void                    (*throttle)(struct uart_port *port);
+        void                    (*unthrottle)(struct uart_port *port);
         int                     (*handle_irq)(struct uart_port *);
         void                    (*pm)(struct uart_port *, unsigned int state,
                                       unsigned int old);
         void                    (*handle_break)(struct uart_port *);
+        int                     (*rs485_config)(struct uart_port *,
+                                                struct serial_rs485 *rs485);
         unsigned int            irq;                    /* irq number */
         unsigned long           irqflags;               /* irq flags  */
         unsigned int            uartclk;                /* base uart clock */
@@ -135,12 +142,13 @@ struct uart_port {
         unsigned char           iotype;                 /* io access style */
         unsigned char           unused1;
 
-#define UPIO_PORT               (0)
-#define UPIO_HUB6               (1)
-#define UPIO_MEM                (2)
-#define UPIO_MEM32              (3)
-#define UPIO_AU                 (4)                     /* Au1x00 and RT288x type IO */
-#define UPIO_TSI                (5)                     /* Tsi108/109 type IO */
+#define UPIO_PORT               (0)                     /* 8b I/O port access */
+#define UPIO_HUB6               (1)                     /* Hub6 ISA card */
+#define UPIO_MEM                (2)                     /* 8b MMIO access */
+#define UPIO_MEM32              (3)                     /* 32b little endian */
+#define UPIO_MEM32BE            (4)                     /* 32b big endian */
+#define UPIO_AU                 (5)                     /* Au1x00 and RT288x type IO */
+#define UPIO_TSI                (6)                     /* Tsi108/109 type IO */
 
         unsigned int            read_status_mask;       /* driver specific */
         unsigned int            ignore_status_mask;     /* driver specific */
@@ -152,23 +160,36 @@ struct uart_port {
         unsigned long           sysrq;                  /* sysrq timeout */
 #endif
 
+        /* flags must be updated while holding port mutex */
         upf_t                   flags;
 
-#define UPF_FOURPORT            ((__force upf_t) (1 << 1))
-#define UPF_SAK                 ((__force upf_t) (1 << 2))
-#define UPF_SPD_MASK            ((__force upf_t) (0x1030))
-#define UPF_SPD_HI              ((__force upf_t) (0x0010))
-#define UPF_SPD_VHI             ((__force upf_t) (0x0020))
-#define UPF_SPD_CUST            ((__force upf_t) (0x0030))
-#define UPF_SPD_SHI             ((__force upf_t) (0x1000))
-#define UPF_SPD_WARP            ((__force upf_t) (0x1010))
-#define UPF_SKIP_TEST           ((__force upf_t) (1 << 6))
-#define UPF_AUTO_IRQ            ((__force upf_t) (1 << 7))
-#define UPF_HARDPPS_CD          ((__force upf_t) (1 << 11))
-#define UPF_LOW_LATENCY         ((__force upf_t) (1 << 13))
-#define UPF_BUGGY_UART          ((__force upf_t) (1 << 14))
+        /*
+         * These flags must be equivalent to the flags defined in
+         * include/uapi/linux/tty_flags.h which are the userspace definitions
+         * assigned from the serial_struct flags in uart_set_info()
+         * [for bit definitions in the UPF_CHANGE_MASK]
+         *
+         * Bits [0..UPF_LAST_USER] are userspace defined/visible/changeable
+         * except bit 15 (UPF_NO_TXEN_TEST) which is masked off.
+         * The remaining bits are serial-core specific and not modifiable by
+         * userspace.
+         */
+#define UPF_FOURPORT            ((__force upf_t) ASYNC_FOURPORT       /* 1  */ )
+#define UPF_SAK                 ((__force upf_t) ASYNC_SAK            /* 2  */ )
+#define UPF_SPD_HI              ((__force upf_t) ASYNC_SPD_HI         /* 4  */ )
+#define UPF_SPD_VHI             ((__force upf_t) ASYNC_SPD_VHI        /* 5  */ )
+#define UPF_SPD_CUST            ((__force upf_t) ASYNC_SPD_CUST   /* 0x0030 */ )
+#define UPF_SPD_WARP            ((__force upf_t) ASYNC_SPD_WARP   /* 0x1010 */ )
+#define UPF_SPD_MASK            ((__force upf_t) ASYNC_SPD_MASK   /* 0x1030 */ )
+#define UPF_SKIP_TEST           ((__force upf_t) ASYNC_SKIP_TEST      /* 6  */ )
+#define UPF_AUTO_IRQ            ((__force upf_t) ASYNC_AUTO_IRQ       /* 7  */ )
+#define UPF_HARDPPS_CD          ((__force upf_t) ASYNC_HARDPPS_CD     /* 11 */ )
+#define UPF_SPD_SHI             ((__force upf_t) ASYNC_SPD_SHI        /* 12 */ )
+#define UPF_LOW_LATENCY         ((__force upf_t) ASYNC_LOW_LATENCY    /* 13 */ )
+#define UPF_BUGGY_UART          ((__force upf_t) ASYNC_BUGGY_UART     /* 14 */ )
 #define UPF_NO_TXEN_TEST        ((__force upf_t) (1 << 15))
-#define UPF_MAGIC_MULTIPLIER    ((__force upf_t) (1 << 16))
+#define UPF_MAGIC_MULTIPLIER    ((__force upf_t) ASYNC_MAGIC_MULTIPLIER /* 16 */ )
+
 /* Port has hardware-assisted h/w flow control (iow, auto-RTS *not* auto-CTS) */
 #define UPF_HARD_FLOW           ((__force upf_t) (1 << 21))
 /* Port has hardware-assisted s/w flow control */
@@ -184,9 +205,21 @@ struct uart_port {
 #define UPF_DEAD                ((__force upf_t) (1 << 30))
 #define UPF_IOREMAP             ((__force upf_t) (1 << 31))
 
-#define UPF_CHANGE_MASK         ((__force upf_t) (0x17fff))
+#define __UPF_CHANGE_MASK       0x17fff
+#define UPF_CHANGE_MASK         ((__force upf_t) __UPF_CHANGE_MASK)
 #define UPF_USR_MASK            ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
 
+#if __UPF_CHANGE_MASK > ASYNC_FLAGS
+#error Change mask not equivalent to userspace-visible bit defines
+#endif
+
+        /* status must be updated while holding port lock */
+        upstat_t                status;
+
+#define UPSTAT_CTS_ENABLE       ((__force upstat_t) (1 << 0))
+#define UPSTAT_DCD_ENABLE       ((__force upstat_t) (1 << 1))
+
+        int                     hw_stopped;             /* sw-assisted CTS flow state */
         unsigned int            mctrl;                  /* current modem ctrl settings */
         unsigned int            timeout;                /* character-based timeout */
         unsigned int            type;                   /* port type */
@@ -201,6 +234,7 @@ struct uart_port {
         unsigned char           unused[2];
         struct attribute_group  *attr_group;            /* port specific attributes */
         const struct attribute_group **tty_groups;      /* all attributes (serial core use only) */
+        struct serial_rs485     rs485;
         void                    *private_data;          /* generic platform data pointer */
 };
 
@@ -347,11 +381,16 @@ int uart_resume_port(struct uart_driver *reg, struct uart_port *port);
 static inline int uart_tx_stopped(struct uart_port *port)
 {
         struct tty_struct *tty = port->state->port.tty;
-        if(tty->stopped || tty->hw_stopped)
+        if (tty->stopped || port->hw_stopped)
                 return 1;
         return 0;
 }
 
+static inline bool uart_cts_enabled(struct uart_port *uport)
+{
+        return !!(uport->status & UPSTAT_CTS_ENABLE);
+}
+
 /*
  * The following are helper functions for the low level drivers.
  */
diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
index 68c097077ef0..f4aee75f00b1 100644
--- a/include/linux/shrinker.h
+++ b/include/linux/shrinker.h
@@ -18,8 +18,6 @@ struct shrink_control {
          */
         unsigned long nr_to_scan;
 
-        /* shrink from these nodes */
-        nodemask_t nodes_to_scan;
         /* current node being shrunk (for NUMA aware shrinkers) */
         int nid;
 };
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 750196fcc0a5..ab1e0392b5ac 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -2,6 +2,7 @@
 #define _LINUX_SIGNAL_H
 
 #include <linux/list.h>
+#include <linux/bug.h>
 #include <uapi/linux/signal.h>
 
 struct task_struct;
@@ -67,7 +68,6 @@ static inline int sigismember(sigset_t *set, int _sig)
 
 static inline int sigisemptyset(sigset_t *set)
 {
-        extern void _NSIG_WORDS_is_unsupported_size(void);
         switch (_NSIG_WORDS) {
         case 4:
                 return (set->sig[3] | set->sig[2] |
@@ -77,7 +77,7 @@ static inline int sigisemptyset(sigset_t *set)
         case 1:
                 return set->sig[0] == 0;
         default:
-                _NSIG_WORDS_is_unsupported_size();
+                BUILD_BUG();
                 return 0;
         }
 }
@@ -90,24 +90,23 @@ static inline int sigisemptyset(sigset_t *set)
 #define _SIG_SET_BINOP(name, op)                                        \
 static inline void name(sigset_t *r, const sigset_t *a, const sigset_t *b) \
 {                                                                       \
-        extern void _NSIG_WORDS_is_unsupported_size(void);              \
         unsigned long a0, a1, a2, a3, b0, b1, b2, b3;                   \
                                                                         \
         switch (_NSIG_WORDS) {                                          \
-            case 4:                                                     \
+        case 4:                                                         \
                 a3 = a->sig[3]; a2 = a->sig[2];                         \
                 b3 = b->sig[3]; b2 = b->sig[2];                         \
                 r->sig[3] = op(a3, b3);                                 \
                 r->sig[2] = op(a2, b2);                                 \
-            case 2:                                                     \
+        case 2:                                                         \
                 a1 = a->sig[1]; b1 = b->sig[1];                         \
                 r->sig[1] = op(a1, b1);                                 \
-            case 1:                                                     \
+        case 1:                                                         \
                 a0 = a->sig[0]; b0 = b->sig[0];                         \
                 r->sig[0] = op(a0, b0);                                 \
                 break;                                                  \
-            default:                                                    \
-                _NSIG_WORDS_is_unsupported_size();                      \
+        default:                                                        \
+                BUILD_BUG();                                            \
         }                                                               \
 }
 
@@ -128,16 +127,14 @@ _SIG_SET_BINOP(sigandnsets, _sig_andn)
 #define _SIG_SET_OP(name, op)                                           \
 static inline void name(sigset_t *set)                                  \
 {                                                                       \
-        extern void _NSIG_WORDS_is_unsupported_size(void);              \
-                                                                        \
         switch (_NSIG_WORDS) {                                          \
-            case 4: set->sig[3] = op(set->sig[3]);                      \
-                    set->sig[2] = op(set->sig[2]);                      \
-            case 2: set->sig[1] = op(set->sig[1]);                      \
-            case 1: set->sig[0] = op(set->sig[0]);                      \
+        case 4: set->sig[3] = op(set->sig[3]);                          \
+                set->sig[2] = op(set->sig[2]);                          \
+        case 2: set->sig[1] = op(set->sig[1]);                          \
+        case 1: set->sig[0] = op(set->sig[0]);                          \
                     break;                                              \
-            default:                                                    \
-                _NSIG_WORDS_is_unsupported_size();                      \
+        default:                                                        \
+                BUILD_BUG();                                            \
         }                                                               \
 }
 
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index abde271c18ae..85ab7d72b54c 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -20,6 +20,8 @@
 #include <linux/time.h>
 #include <linux/bug.h>
 #include <linux/cache.h>
+#include <linux/rbtree.h>
+#include <linux/socket.h>
 
 #include <linux/atomic.h>
 #include <asm/types.h>
@@ -28,7 +30,6 @@
 #include <linux/textsearch.h>
 #include <net/checksum.h>
 #include <linux/rcupdate.h>
-#include <linux/dmaengine.h>
 #include <linux/hrtimer.h>
 #include <linux/dma-mapping.h>
 #include <linux/netdev_features.h>
@@ -47,11 +48,29 @@
  *
  *   The hardware you're dealing with doesn't calculate the full checksum
  *   (as in CHECKSUM_COMPLETE), but it does parse headers and verify checksums
- *   for specific protocols e.g. TCP/UDP/SCTP, then, for such packets it will
- *   set CHECKSUM_UNNECESSARY if their checksums are okay. skb->csum is still
- *   undefined in this case though. It is a bad option, but, unfortunately,
- *   nowadays most vendors do this. Apparently with the secret goal to sell
- *   you new devices, when you will add new protocol to your host, f.e. IPv6 8)
+ *   for specific protocols. For such packets it will set CHECKSUM_UNNECESSARY
+ *   if their checksums are okay. skb->csum is still undefined in this case
+ *   though. It is a bad option, but, unfortunately, nowadays most vendors do
+ *   this. Apparently with the secret goal to sell you new devices, when you
+ *   will add new protocol to your host, f.e. IPv6 8)
+ *
+ *   CHECKSUM_UNNECESSARY is applicable to following protocols:
+ *     TCP: IPv6 and IPv4.
+ *     UDP: IPv4 and IPv6. A device may apply CHECKSUM_UNNECESSARY to a
+ *       zero UDP checksum for either IPv4 or IPv6, the networking stack
+ *       may perform further validation in this case.
+ *     GRE: only if the checksum is present in the header.
+ *     SCTP: indicates the CRC in SCTP header has been validated.
+ *
+ *   skb->csum_level indicates the number of consecutive checksums found in
+ *   the packet minus one that have been verified as CHECKSUM_UNNECESSARY.
+ *   For instance if a device receives an IPv6->UDP->GRE->IPv4->TCP packet
+ *   and a device is able to verify the checksums for UDP (possibly zero),
+ *   GRE (checksum flag is set), and TCP-- skb->csum_level would be set to
+ *   two. If the device were only able to verify the UDP checksum and not
+ *   GRE, either because it doesn't support GRE checksum of because GRE
+ *   checksum is bad, skb->csum_level would be set to zero (TCP checksum is
+ *   not considered in this case).
  *
  * CHECKSUM_COMPLETE:
  *
@@ -112,6 +131,9 @@
 #define CHECKSUM_COMPLETE       2
 #define CHECKSUM_PARTIAL        3
 
+/* Maximum value in skb->csum_level */
+#define SKB_MAX_CSUM_LEVEL      3
+
 #define SKB_DATA_ALIGN(X)       ALIGN(X, SMP_CACHE_BYTES)
 #define SKB_WITH_OVERHEAD(X)    \
         ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
@@ -128,6 +150,8 @@
 struct net_device;
 struct scatterlist;
 struct pipe_inode_info;
+struct iov_iter;
+struct napi_struct;
 
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 struct nf_conntrack {
@@ -135,7 +159,7 @@ struct nf_conntrack {
 };
 #endif
 
-#ifdef CONFIG_BRIDGE_NETFILTER
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
 struct nf_bridge_info {
         atomic_t                use;
         unsigned int            mask;
@@ -318,9 +342,9 @@ struct skb_shared_info {
 
 
 enum {
-        SKB_FCLONE_UNAVAILABLE,
-        SKB_FCLONE_ORIG,
-        SKB_FCLONE_CLONE,
+        SKB_FCLONE_UNAVAILABLE, /* skb has no fclone (from head_cache) */
+        SKB_FCLONE_ORIG,        /* orig skb (from fclone_cache) */
+        SKB_FCLONE_CLONE,       /* companion fclone skb (from fclone_cache) */
 };
 
 enum {
@@ -349,8 +373,7 @@ enum {
 
         SKB_GSO_UDP_TUNNEL_CSUM = 1 << 11,
 
-        SKB_GSO_MPLS = 1 << 12,
-
+        SKB_GSO_TUNNEL_REMCSUM = 1 << 12,
 };
 
 #if BITS_PER_LONG > 32
@@ -419,6 +442,7 @@ static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1,
  *      @next: Next buffer in list
  *      @prev: Previous buffer in list
  *      @tstamp: Time we arrived/left
+ *      @rbnode: RB tree node, alternative to next/prev for netem/tcp
  *      @sk: Socket we are owned by
  *      @dev: Device we arrived on/are leaving by
  *      @cb: Control buffer. Free for use by every layer. Put private vars here
@@ -452,6 +476,7 @@ static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1,
  *      @tc_verd: traffic control verdict
  *      @hash: the packet hash
  *      @queue_mapping: Queue mapping for multiqueue devices
+ *      @xmit_more: More SKBs are pending for this queue
  *      @ndisc_nodetype: router type (from link layer)
  *      @ooo_okay: allow the mapping of a socket to a queue to be changed
  *      @l4_hash: indicate hash is a canonical 4-tuple hash over transport
@@ -460,8 +485,6 @@ static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1,
  *      @wifi_acked_valid: wifi_acked was set
  *      @wifi_acked: whether frame was acked on wifi or not
  *      @no_fcs:  Request NIC to treat last 4 bytes as Ethernet FCS
- *      @dma_cookie: a cookie to one of several possible DMA operations
- *              done by skb DMA functions
   *     @napi_id: id of the NAPI struct this skb came from
  *      @secmark: security marking
  *      @mark: Generic packet mark
@@ -484,15 +507,19 @@ static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1,
  */
 
 struct sk_buff {
-        /* These two members must be first. */
-        struct sk_buff          *next;
-        struct sk_buff          *prev;
-
         union {
-                ktime_t         tstamp;
-                struct skb_mstamp skb_mstamp;
+                struct {
+                        /* These two members must be first. */
+                        struct sk_buff          *next;
+                        struct sk_buff          *prev;
+
+                        union {
+                                ktime_t         tstamp;
+                                struct skb_mstamp skb_mstamp;
+                        };
+                };
+                struct rb_node  rbnode; /* used in netem & tcp stack */
         };
-
         struct sock             *sk;
         struct net_device       *dev;
 
@@ -505,87 +532,102 @@ struct sk_buff {
         char                    cb[48] __aligned(8);
 
         unsigned long           _skb_refdst;
+        void                    (*destructor)(struct sk_buff *skb);
 #ifdef CONFIG_XFRM
         struct  sec_path        *sp;
 #endif
+#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
+        struct nf_conntrack     *nfct;
+#endif
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
+        struct nf_bridge_info   *nf_bridge;
+#endif
         unsigned int            len,
                                 data_len;
         __u16                   mac_len,
                                 hdr_len;
-        union {
-                __wsum          csum;
-                struct {
-                        __u16   csum_start;
-                        __u16   csum_offset;
-                };
-        };
-        __u32                   priority;
+
+        /* Following fields are _not_ copied in __copy_skb_header()
+         * Note that queue_mapping is here mostly to fill a hole.
+         */
         kmemcheck_bitfield_begin(flags1);
-        __u8                    ignore_df:1,
-                                cloned:1,
-                                ip_summed:2,
+        __u16                   queue_mapping;
+        __u8                    cloned:1,
                                 nohdr:1,
-                                nfctinfo:3;
-        __u8                    pkt_type:3,
                                 fclone:2,
-                                ipvs_property:1,
                                 peeked:1,
-                                nf_trace:1;
+                                head_frag:1,
+                                xmit_more:1;
+        /* one bit hole */
         kmemcheck_bitfield_end(flags1);
-        __be16                  protocol;
 
-        void                    (*destructor)(struct sk_buff *skb);
-#if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
-        struct nf_conntrack     *nfct;
-#endif
-#ifdef CONFIG_BRIDGE_NETFILTER
-        struct nf_bridge_info   *nf_bridge;
-#endif
-
-        int                     skb_iif;
-
-        __u32                   hash;
-
-        __be16                  vlan_proto;
-        __u16                   vlan_tci;
+        /* fields enclosed in headers_start/headers_end are copied
+         * using a single memcpy() in __copy_skb_header()
+         */
+        /* private: */
+        __u32                   headers_start[0];
+        /* public: */
 
-#ifdef CONFIG_NET_SCHED
-        __u16                   tc_index;       /* traffic control index */
-#ifdef CONFIG_NET_CLS_ACT
-        __u16                   tc_verd;        /* traffic control verdict */
-#endif
+/* if you move pkt_type around you also must adapt those constants */
+#ifdef __BIG_ENDIAN_BITFIELD
+#define PKT_TYPE_MAX    (7 << 5)
+#else
+#define PKT_TYPE_MAX    7
 #endif
+#define PKT_TYPE_OFFSET()       offsetof(struct sk_buff, __pkt_type_offset)
 
-        __u16                   queue_mapping;
-        kmemcheck_bitfield_begin(flags2);
-#ifdef CONFIG_IPV6_NDISC_NODETYPE
-        __u8                    ndisc_nodetype:2;
-#endif
+        __u8                    __pkt_type_offset[0];
+        __u8                    pkt_type:3;
         __u8                    pfmemalloc:1;
+        __u8                    ignore_df:1;
+        __u8                    nfctinfo:3;
+
+        __u8                    nf_trace:1;
+        __u8                    ip_summed:2;
         __u8                    ooo_okay:1;
         __u8                    l4_hash:1;
         __u8                    sw_hash:1;
         __u8                    wifi_acked_valid:1;
         __u8                    wifi_acked:1;
+
         __u8                    no_fcs:1;
-        __u8                    head_frag:1;
-        /* Encapsulation protocol and NIC drivers should use
-         * this flag to indicate to each other if the skb contains
-         * encapsulated packet or not and maybe use the inner packet
-         * headers if needed
-         */
+        /* Indicates the inner headers are valid in the skbuff. */
         __u8                    encapsulation:1;
         __u8                    encap_hdr_csum:1;
         __u8                    csum_valid:1;
         __u8                    csum_complete_sw:1;
-        /* 2/4 bit hole (depending on ndisc_nodetype presence) */
-        kmemcheck_bitfield_end(flags2);
+        __u8                    csum_level:2;
+        __u8                    csum_bad:1;
+
+#ifdef CONFIG_IPV6_NDISC_NODETYPE
+        __u8                    ndisc_nodetype:2;
+#endif
+        __u8                    ipvs_property:1;
+        __u8                    inner_protocol_type:1;
+        __u8                    remcsum_offload:1;
+        /* 3 or 5 bit hole */
+
+#ifdef CONFIG_NET_SCHED
+        __u16                   tc_index;       /* traffic control index */
+#ifdef CONFIG_NET_CLS_ACT
+        __u16                   tc_verd;        /* traffic control verdict */
+#endif
+#endif
 
-#if defined CONFIG_NET_DMA || defined CONFIG_NET_RX_BUSY_POLL
         union {
-                unsigned int    napi_id;
-                dma_cookie_t    dma_cookie;
+                __wsum          csum;
+                struct {
+                        __u16   csum_start;
+                        __u16   csum_offset;
+                };
         };
+        __u32                   priority;
+        int                     skb_iif;
+        __u32                   hash;
+        __be16                  vlan_proto;
+        __u16                   vlan_tci;
+#ifdef CONFIG_NET_RX_BUSY_POLL
+        unsigned int    napi_id;
 #endif
 #ifdef CONFIG_NETWORK_SECMARK
         __u32                   secmark;
@@ -596,13 +638,24 @@ struct sk_buff {
                 __u32           reserved_tailroom;
         };
 
-        __be16                  inner_protocol;
+        union {
+                __be16          inner_protocol;
+                __u8            inner_ipproto;
+        };
+
         __u16                   inner_transport_header;
         __u16                   inner_network_header;
         __u16                   inner_mac_header;
+
+        __be16                  protocol;
         __u16                   transport_header;
         __u16                   network_header;
         __u16                   mac_header;
+
+        /* private: */
+        __u32                   headers_end[0];
+        /* public: */
+
         /* These elements must be at the end, see alloc_skb() for details.  */
         sk_buff_data_t          tail;
         sk_buff_data_t          end;
@@ -621,6 +674,7 @@ struct sk_buff {
 
 #define SKB_ALLOC_FCLONE        0x01
 #define SKB_ALLOC_RX            0x02
+#define SKB_ALLOC_NAPI          0x04
 
 /* Returns true if the skb was allocated from PFMEMALLOC reserves */
 static inline bool skb_pfmemalloc(const struct sk_buff *skb)
@@ -665,9 +719,6 @@ static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
         skb->_skb_refdst = (unsigned long)dst;
 }
 
-void __skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst,
-                         bool force);
-
 /**
  * skb_dst_set_noref - sets skb dst, hopefully, without taking reference
  * @skb: buffer
@@ -680,24 +731,8 @@ void __skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst,
  */
 static inline void skb_dst_set_noref(struct sk_buff *skb, struct dst_entry *dst)
 {
-        __skb_dst_set_noref(skb, dst, false);
-}
-
-/**
- * skb_dst_set_noref_force - sets skb dst, without taking reference
- * @skb: buffer
- * @dst: dst entry
- *
- * Sets skb dst, assuming a reference was not taken on dst.
- * No reference is taken and no dst_release will be called. While for
- * cached dsts deferred reclaim is a basic feature, for entries that are
- * not cached it is caller's job to guarantee that last dst_release for
- * provided dst happens when nobody uses it, eg. after a RCU grace period.
- */
-static inline void skb_dst_set_noref_force(struct sk_buff *skb,
-                                           struct dst_entry *dst)
-{
-        __skb_dst_set_noref(skb, dst, true);
+        WARN_ON(!rcu_read_lock_held() && !rcu_read_lock_bh_held());
+        skb->_skb_refdst = (unsigned long)dst | SKB_DST_NOREF;
 }
 
 /**
@@ -734,6 +769,41 @@ static inline struct sk_buff *alloc_skb(unsigned int size,
         return __alloc_skb(size, priority, 0, NUMA_NO_NODE);
 }
 
+struct sk_buff *alloc_skb_with_frags(unsigned long header_len,
+                                     unsigned long data_len,
+                                     int max_page_order,
+                                     int *errcode,
+                                     gfp_t gfp_mask);
+
+/* Layout of fast clones : [skb1][skb2][fclone_ref] */
+struct sk_buff_fclones {
+        struct sk_buff  skb1;
+
+        struct sk_buff  skb2;
+
+        atomic_t        fclone_ref;
+};
+
+/**
+ *      skb_fclone_busy - check if fclone is busy
+ *      @skb: buffer
+ *
+ * Returns true is skb is a fast clone, and its clone is not freed.
+ * Some drivers call skb_orphan() in their ndo_start_xmit(),
+ * so we also check that this didnt happen.
+ */
+static inline bool skb_fclone_busy(const struct sock *sk,
+                                   const struct sk_buff *skb)
+{
+        const struct sk_buff_fclones *fclones;
+
+        fclones = container_of(skb, struct sk_buff_fclones, skb1);
+
+        return skb->fclone == SKB_FCLONE_ORIG &&
+               atomic_read(&fclones->fclone_ref) > 1 &&
+               fclones->skb2.sk == sk;
+}
+
 static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
                                                gfp_t priority)
 {
@@ -1042,6 +1112,7 @@ static inline int skb_header_cloned(const struct sk_buff *skb)
  *      Drop a reference to the header part of the buffer.  This is done
  *      by acquiring a payload reference.  You must not read from the header
  *      part of skb->data after this.
+ *      Note : Check if you can use __skb_header_release() instead.
  */
 static inline void skb_header_release(struct sk_buff *skb)
 {
@@ -1051,6 +1122,20 @@ static inline void skb_header_release(struct sk_buff *skb)
 }
 
 /**
+ *      __skb_header_release - release reference to header
+ *      @skb: buffer to operate on
+ *
+ *      Variant of skb_header_release() assuming skb is private to caller.
+ *      We can avoid one atomic operation.
+ */
+static inline void __skb_header_release(struct sk_buff *skb)
+{
+        skb->nohdr = 1;
+        atomic_set(&skb_shinfo(skb)->dataref, 1 + (1 << SKB_DATAREF_SHIFT));
+}
+
+
+/**
  *      skb_shared - is the buffer shared
  *      @skb: buffer to check
  *
@@ -1116,7 +1201,12 @@ static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
         might_sleep_if(pri & __GFP_WAIT);
         if (skb_cloned(skb)) {
                 struct sk_buff *nskb = skb_copy(skb, pri);
-                kfree_skb(skb); /* Free our shared copy */
+
+                /* Free our shared copy */
+                if (likely(nskb))
+                        consume_skb(skb);
+                else
+                        kfree_skb(skb);
                 skb = nskb;
         }
         return skb;
@@ -1675,6 +1765,23 @@ static inline void skb_reserve(struct sk_buff *skb, int len)
         skb->tail += len;
 }
 
+#define ENCAP_TYPE_ETHER        0
+#define ENCAP_TYPE_IPPROTO      1
+
+static inline void skb_set_inner_protocol(struct sk_buff *skb,
+                                          __be16 protocol)
+{
+        skb->inner_protocol = protocol;
+        skb->inner_protocol_type = ENCAP_TYPE_ETHER;
+}
+
+static inline void skb_set_inner_ipproto(struct sk_buff *skb,
+                                         __u8 ipproto)
+{
+        skb->inner_ipproto = ipproto;
+        skb->inner_protocol_type = ENCAP_TYPE_IPPROTO;
+}
+
 static inline void skb_reset_inner_headers(struct sk_buff *skb)
 {
         skb->inner_mac_header = skb->mac_header;
@@ -1860,18 +1967,6 @@ static inline int pskb_network_may_pull(struct sk_buff *skb, unsigned int len)
         return pskb_may_pull(skb, skb_network_offset(skb) + len);
 }
 
-static inline void skb_pop_rcv_encapsulation(struct sk_buff *skb)
-{
-        /* Only continue with checksum unnecessary if device indicated
-         * it is valid across encapsulation (skb->encapsulation was set).
-         */
-        if (skb->ip_summed == CHECKSUM_UNNECESSARY && !skb->encapsulation)
-                skb->ip_summed = CHECKSUM_NONE;
-
-        skb->encapsulation = 0;
-        skb->csum_valid = 0;
-}
-
 /*
  * CPUs often take a performance hit when accessing unaligned memory
  * locations. The actual performance hit varies, it can be small if the
@@ -2071,47 +2166,61 @@ static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
         return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
 }
 
+void *napi_alloc_frag(unsigned int fragsz);
+struct sk_buff *__napi_alloc_skb(struct napi_struct *napi,
+                                 unsigned int length, gfp_t gfp_mask);
+static inline struct sk_buff *napi_alloc_skb(struct napi_struct *napi,
+                                             unsigned int length)
+{
+        return __napi_alloc_skb(napi, length, GFP_ATOMIC);
+}
+
 /**
- *      __skb_alloc_pages - allocate pages for ps-rx on a skb and preserve pfmemalloc data
- *      @gfp_mask: alloc_pages_node mask. Set __GFP_NOMEMALLOC if not for network packet RX
- *      @skb: skb to set pfmemalloc on if __GFP_MEMALLOC is used
- *      @order: size of the allocation
+ * __dev_alloc_pages - allocate page for network Rx
+ * @gfp_mask: allocation priority. Set __GFP_NOMEMALLOC if not for network Rx
+ * @order: size of the allocation
  *
- *      Allocate a new page.
+ * Allocate a new page.
  *
- *      %NULL is returned if there is no free memory.
+ * %NULL is returned if there is no free memory.
 */
-static inline struct page *__skb_alloc_pages(gfp_t gfp_mask,
-                                              struct sk_buff *skb,
-                                              unsigned int order)
-{
-        struct page *page;
-
-        gfp_mask |= __GFP_COLD;
-
-        if (!(gfp_mask & __GFP_NOMEMALLOC))
-                gfp_mask |= __GFP_MEMALLOC;
+static inline struct page *__dev_alloc_pages(gfp_t gfp_mask,
+                                             unsigned int order)
+{
+        /* This piece of code contains several assumptions.
+         * 1.  This is for device Rx, therefor a cold page is preferred.
+         * 2.  The expectation is the user wants a compound page.
+         * 3.  If requesting a order 0 page it will not be compound
+         *     due to the check to see if order has a value in prep_new_page
+         * 4.  __GFP_MEMALLOC is ignored if __GFP_NOMEMALLOC is set due to
+         *     code in gfp_to_alloc_flags that should be enforcing this.
+         */
+        gfp_mask |= __GFP_COLD | __GFP_COMP | __GFP_MEMALLOC;
 
-        page = alloc_pages_node(NUMA_NO_NODE, gfp_mask, order);
-        if (skb && page && page->pfmemalloc)
-                skb->pfmemalloc = true;
+        return alloc_pages_node(NUMA_NO_NODE, gfp_mask, order);
+}
 
-        return page;
+static inline struct page *dev_alloc_pages(unsigned int order)
+{
+        return __dev_alloc_pages(GFP_ATOMIC, order);
 }
 
 /**
- *      __skb_alloc_page - allocate a page for ps-rx for a given skb and preserve pfmemalloc data
- *      @gfp_mask: alloc_pages_node mask. Set __GFP_NOMEMALLOC if not for network packet RX
- *      @skb: skb to set pfmemalloc on if __GFP_MEMALLOC is used
+ * __dev_alloc_page - allocate a page for network Rx
+ * @gfp_mask: allocation priority. Set __GFP_NOMEMALLOC if not for network Rx
  *
- *      Allocate a new page.
+ * Allocate a new page.
  *
- *      %NULL is returned if there is no free memory.
+ * %NULL is returned if there is no free memory.
  */
-static inline struct page *__skb_alloc_page(gfp_t gfp_mask,
-                                             struct sk_buff *skb)
+static inline struct page *__dev_alloc_page(gfp_t gfp_mask)
+{
+        return __dev_alloc_pages(gfp_mask, 0);
+}
+
+static inline struct page *dev_alloc_page(void)
 {
-        return __skb_alloc_pages(gfp_mask, skb, 0);
+        return __dev_alloc_page(GFP_ATOMIC);
 }
 
 /**
@@ -2343,7 +2452,6 @@ static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
  *      is untouched. Otherwise it is extended. Returns zero on
  *      success. The skb is freed on error.
  */
- 
 static inline int skb_padto(struct sk_buff *skb, unsigned int len)
 {
         unsigned int size = skb->len;
@@ -2352,6 +2460,29 @@ static inline int skb_padto(struct sk_buff *skb, unsigned int len)
         return skb_pad(skb, len - size);
 }
 
+/**
+ *      skb_put_padto - increase size and pad an skbuff up to a minimal size
+ *      @skb: buffer to pad
+ *      @len: minimal length
+ *
+ *      Pads up a buffer to ensure the trailing bytes exist and are
+ *      blanked. If the buffer already contains sufficient data it
+ *      is untouched. Otherwise it is extended. Returns zero on
+ *      success. The skb is freed on error.
+ */
+static inline int skb_put_padto(struct sk_buff *skb, unsigned int len)
+{
+        unsigned int size = skb->len;
+
+        if (unlikely(size < len)) {
+                len -= size;
+                if (skb_pad(skb, len))
+                        return -ENOMEM;
+                __skb_put(skb, len);
+        }
+        return 0;
+}
+
 static inline int skb_add_data(struct sk_buff *skb,
                                char __user *from, int copy)
 {
@@ -2524,18 +2655,18 @@ struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock,
                                   int *err);
 unsigned int datagram_poll(struct file *file, struct socket *sock,
                            struct poll_table_struct *wait);
-int skb_copy_datagram_iovec(const struct sk_buff *from, int offset,
-                            struct iovec *to, int size);
-int skb_copy_and_csum_datagram_iovec(struct sk_buff *skb, int hlen,
-                                     struct iovec *iov);
-int skb_copy_datagram_from_iovec(struct sk_buff *skb, int offset,
-                                 const struct iovec *from, int from_offset,
-                                 int len);
-int zerocopy_sg_from_iovec(struct sk_buff *skb, const struct iovec *frm,
-                           int offset, size_t count);
-int skb_copy_datagram_const_iovec(const struct sk_buff *from, int offset,
-                                  const struct iovec *to, int to_offset,
-                                  int size);
+int skb_copy_datagram_iter(const struct sk_buff *from, int offset,
+                           struct iov_iter *to, int size);
+static inline int skb_copy_datagram_msg(const struct sk_buff *from, int offset,
+                                        struct msghdr *msg, int size)
+{
+        return skb_copy_datagram_iter(from, offset, &msg->msg_iter, size);
+}
+int skb_copy_and_csum_datagram_msg(struct sk_buff *skb, int hlen,
+                                   struct msghdr *msg);
+int skb_copy_datagram_from_iter(struct sk_buff *skb, int offset,
+                                 struct iov_iter *from, int len);
+int zerocopy_sg_from_iter(struct sk_buff *skb, struct iov_iter *frm);
 void skb_free_datagram(struct sock *sk, struct sk_buff *skb);
 void skb_free_datagram_locked(struct sock *sk, struct sk_buff *skb);
 int skb_kill_datagram(struct sock *sk, struct sk_buff *skb, unsigned int flags);
@@ -2556,6 +2687,20 @@ void skb_scrub_packet(struct sk_buff *skb, bool xnet);
 unsigned int skb_gso_transport_seglen(const struct sk_buff *skb);
 struct sk_buff *skb_segment(struct sk_buff *skb, netdev_features_t features);
 struct sk_buff *skb_vlan_untag(struct sk_buff *skb);
+int skb_ensure_writable(struct sk_buff *skb, int write_len);
+int skb_vlan_pop(struct sk_buff *skb);
+int skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci);
+
+static inline int memcpy_from_msg(void *data, struct msghdr *msg, int len)
+{
+        /* XXX: stripping const */
+        return memcpy_fromiovec(data, (struct iovec *)msg->msg_iter.iov, len);
+}
+
+static inline int memcpy_to_msg(struct msghdr *msg, void *data, int len)
+{
+        return copy_to_iter(data, len, &msg->msg_iter) == len ? 0 : -EFAULT;
+}
 
 struct skb_checksum_ops {
         __wsum (*update)(const void *mem, int len, __wsum wsum);
@@ -2567,20 +2712,26 @@ __wsum __skb_checksum(const struct sk_buff *skb, int offset, int len,
 __wsum skb_checksum(const struct sk_buff *skb, int offset, int len,
                     __wsum csum);
 
-static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
-                                       int len, void *buffer)
+static inline void *__skb_header_pointer(const struct sk_buff *skb, int offset,
+                                         int len, void *data, int hlen, void *buffer)
 {
-        int hlen = skb_headlen(skb);
-
         if (hlen - offset >= len)
-                return skb->data + offset;
+                return data + offset;
 
-        if (skb_copy_bits(skb, offset, buffer, len) < 0)
+        if (!skb ||
+            skb_copy_bits(skb, offset, buffer, len) < 0)
                 return NULL;
 
         return buffer;
 }
 
+static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
+                                       int len, void *buffer)
+{
+        return __skb_header_pointer(skb, offset, len, skb->data,
+                                    skb_headlen(skb), buffer);
+}
+
 /**
  *      skb_needs_linearize - check if we need to linearize a given skb
  *                            depending on the given device features.
@@ -2671,6 +2822,8 @@ static inline ktime_t net_invalid_timestamp(void)
         return ktime_set(0, 0);
 }
 
+struct sk_buff *skb_clone_sk(struct sk_buff *skb);
+
 #ifdef CONFIG_NETWORK_PHY_TIMESTAMPING
 
 void skb_clone_tx_timestamp(struct sk_buff *skb);
@@ -2786,6 +2939,42 @@ static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
                0 : __skb_checksum_complete(skb);
 }
 
+static inline void __skb_decr_checksum_unnecessary(struct sk_buff *skb)
+{
+        if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
+                if (skb->csum_level == 0)
+                        skb->ip_summed = CHECKSUM_NONE;
+                else
+                        skb->csum_level--;
+        }
+}
+
+static inline void __skb_incr_checksum_unnecessary(struct sk_buff *skb)
+{
+        if (skb->ip_summed == CHECKSUM_UNNECESSARY) {
+                if (skb->csum_level < SKB_MAX_CSUM_LEVEL)
+                        skb->csum_level++;
+        } else if (skb->ip_summed == CHECKSUM_NONE) {
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+                skb->csum_level = 0;
+        }
+}
+
+static inline void __skb_mark_checksum_bad(struct sk_buff *skb)
+{
+        /* Mark current checksum as bad (typically called from GRO
+         * path). In the case that ip_summed is CHECKSUM_NONE
+         * this must be the first checksum encountered in the packet.
+         * When ip_summed is CHECKSUM_UNNECESSARY, this is the first
+         * checksum after the last one validated. For UDP, a zero
+         * checksum can not be marked as bad.
+         */
+
+        if (skb->ip_summed == CHECKSUM_NONE ||
+            skb->ip_summed == CHECKSUM_UNNECESSARY)
+                skb->csum_bad = 1;
+}
+
 /* Check if we need to perform checksum complete validation.
  *
  * Returns true if checksum complete is needed, false otherwise
@@ -2797,6 +2986,7 @@ static inline bool __skb_checksum_validate_needed(struct sk_buff *skb,
 {
         if (skb_csum_unnecessary(skb) || (zero_okay && !check)) {
                 skb->csum_valid = 1;
+                __skb_decr_checksum_unnecessary(skb);
                 return false;
         }
 
@@ -2826,6 +3016,9 @@ static inline __sum16 __skb_checksum_validate_complete(struct sk_buff *skb,
                         skb->csum_valid = 1;
                         return 0;
                 }
+        } else if (skb->csum_bad) {
+                /* ip_summed == CHECKSUM_NONE in this case */
+                return 1;
         }
 
         skb->csum = psum;
@@ -2883,6 +3076,26 @@ static inline __wsum null_compute_pseudo(struct sk_buff *skb, int proto)
 #define skb_checksum_simple_validate(skb)                               \
         __skb_checksum_validate(skb, 0, true, false, 0, null_compute_pseudo)
 
+static inline bool __skb_checksum_convert_check(struct sk_buff *skb)
+{
+        return (skb->ip_summed == CHECKSUM_NONE &&
+                skb->csum_valid && !skb->csum_bad);
+}
+
+static inline void __skb_checksum_convert(struct sk_buff *skb,
+                                          __sum16 check, __wsum pseudo)
+{
+        skb->csum = ~pseudo;
+        skb->ip_summed = CHECKSUM_COMPLETE;
+}
+
+#define skb_checksum_try_convert(skb, proto, check, compute_pseudo)     \
+do {                                                                    \
+        if (__skb_checksum_convert_check(skb))                          \
+                __skb_checksum_convert(skb, check,                      \
+                                       compute_pseudo(skb, proto));     \
+} while (0)
+
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 void nf_conntrack_destroy(struct nf_conntrack *nfct);
 static inline void nf_conntrack_put(struct nf_conntrack *nfct)
@@ -2896,7 +3109,7 @@ static inline void nf_conntrack_get(struct nf_conntrack *nfct)
                 atomic_inc(&nfct->use);
 }
 #endif
-#ifdef CONFIG_BRIDGE_NETFILTER
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
 static inline void nf_bridge_put(struct nf_bridge_info *nf_bridge)
 {
         if (nf_bridge && atomic_dec_and_test(&nf_bridge->use))
@@ -2914,7 +3127,7 @@ static inline void nf_reset(struct sk_buff *skb)
         nf_conntrack_put(skb->nfct);
         skb->nfct = NULL;
 #endif
-#ifdef CONFIG_BRIDGE_NETFILTER
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
         nf_bridge_put(skb->nf_bridge);
         skb->nf_bridge = NULL;
 #endif
@@ -2928,19 +3141,22 @@ static inline void nf_reset_trace(struct sk_buff *skb)
 }
 
 /* Note: This doesn't put any conntrack and bridge info in dst. */
-static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src)
+static inline void __nf_copy(struct sk_buff *dst, const struct sk_buff *src,
+                             bool copy)
 {
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
         dst->nfct = src->nfct;
         nf_conntrack_get(src->nfct);
-        dst->nfctinfo = src->nfctinfo;
+        if (copy)
+                dst->nfctinfo = src->nfctinfo;
 #endif
-#ifdef CONFIG_BRIDGE_NETFILTER
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
         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;
+        if (copy)
+                dst->nf_trace = src->nf_trace;
 #endif
 }
 
@@ -2949,10 +3165,10 @@ static inline void nf_copy(struct sk_buff *dst, const struct sk_buff *src)
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
         nf_conntrack_put(dst->nfct);
 #endif
-#ifdef CONFIG_BRIDGE_NETFILTER
+#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
         nf_bridge_put(dst->nf_bridge);
 #endif
-        __nf_copy(dst, src);
+        __nf_copy(dst, src, true);
 }
 
 #ifdef CONFIG_NETWORK_SECMARK
@@ -3137,7 +3353,9 @@ bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
 
 int skb_checksum_setup(struct sk_buff *skb, bool recalculate);
 
-u32 __skb_get_poff(const struct sk_buff *skb);
+u32 skb_get_poff(const struct sk_buff *skb);
+u32 __skb_get_poff(const struct sk_buff *skb, void *data,
+                   const struct flow_keys *keys, int hlen);
 
 /**
  * skb_head_is_locked - Determine if the skb->head is locked down
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 1d9abb7d22a0..9a139b637069 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -158,31 +158,6 @@ size_t ksize(const void *);
 #define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
 #endif
 
-#ifdef CONFIG_SLOB
-/*
- * Common fields provided in kmem_cache by all slab allocators
- * This struct is either used directly by the allocator (SLOB)
- * or the allocator must include definitions for all fields
- * provided in kmem_cache_common in their definition of kmem_cache.
- *
- * Once we can do anonymous structs (C11 standard) we could put a
- * anonymous struct definition in these allocators so that the
- * separate allocations in the kmem_cache structure of SLAB and
- * SLUB is no longer needed.
- */
-struct kmem_cache {
-        unsigned int object_size;/* The original size of the object */
-        unsigned int size;      /* The aligned/padded/added on size  */
-        unsigned int align;     /* Alignment as calculated */
-        unsigned long flags;    /* Active flags on the slab */
-        const char *name;       /* Slab name for sysfs */
-        int refcount;           /* Use counter */
-        void (*ctor)(void *);   /* Called on object slot creation */
-        struct list_head list;  /* List of all slab caches on the system */
-};
-
-#endif /* CONFIG_SLOB */
-
 /*
  * Kmalloc array related definitions
  */
@@ -363,14 +338,6 @@ kmem_cache_alloc_node_trace(struct kmem_cache *s,
 }
 #endif /* CONFIG_TRACING */
 
-#ifdef CONFIG_SLAB
-#include <linux/slab_def.h>
-#endif
-
-#ifdef CONFIG_SLUB
-#include <linux/slub_def.h>
-#endif
-
 extern void *kmalloc_order(size_t size, gfp_t flags, unsigned int order);
 
 #ifdef CONFIG_TRACING
@@ -526,7 +493,6 @@ static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
  * @memcg: pointer to the memcg this cache belongs to
  * @list: list_head for the list of all caches in this memcg
  * @root_cache: pointer to the global, root cache, this cache was derived from
- * @nr_pages: number of pages that belongs to this cache.
  */
 struct memcg_cache_params {
         bool is_root_cache;
@@ -539,17 +505,12 @@ struct memcg_cache_params {
                         struct mem_cgroup *memcg;
                         struct list_head list;
                         struct kmem_cache *root_cache;
-                        atomic_t nr_pages;
                 };
         };
 };
 
 int memcg_update_all_caches(int num_memcgs);
 
-struct seq_file;
-int cache_show(struct kmem_cache *s, struct seq_file *m);
-void print_slabinfo_header(struct seq_file *m);
-
 /**
  * kmalloc_array - allocate memory for an array.
  * @n: number of elements.
@@ -582,37 +543,15 @@ static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
  * allocator where we care about the real place the memory allocation
  * request comes from.
  */
-#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB) || \
-        (defined(CONFIG_SLAB) && defined(CONFIG_TRACING)) || \
-        (defined(CONFIG_SLOB) && defined(CONFIG_TRACING))
 extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
 #define kmalloc_track_caller(size, flags) \
         __kmalloc_track_caller(size, flags, _RET_IP_)
-#else
-#define kmalloc_track_caller(size, flags) \
-        __kmalloc(size, flags)
-#endif /* DEBUG_SLAB */
 
 #ifdef CONFIG_NUMA
-/*
- * kmalloc_node_track_caller is a special version of kmalloc_node that
- * records the calling function of the routine calling it for slab leak
- * tracking instead of just the calling function (confusing, eh?).
- * It's useful when the call to kmalloc_node comes from a widely-used
- * standard allocator where we care about the real place the memory
- * allocation request comes from.
- */
-#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB) || \
-        (defined(CONFIG_SLAB) && defined(CONFIG_TRACING)) || \
-        (defined(CONFIG_SLOB) && defined(CONFIG_TRACING))
 extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, unsigned long);
 #define kmalloc_node_track_caller(size, flags, node) \
         __kmalloc_node_track_caller(size, flags, node, \
                         _RET_IP_)
-#else
-#define kmalloc_node_track_caller(size, flags, node) \
-        __kmalloc_node(size, flags, node)
-#endif
 
 #else /* CONFIG_NUMA */
 
@@ -650,14 +589,7 @@ static inline void *kzalloc_node(size_t size, gfp_t flags, int node)
         return kmalloc_node(size, flags | __GFP_ZERO, node);
 }
 
-/*
- * Determine the size of a slab object
- */
-static inline unsigned int kmem_cache_size(struct kmem_cache *s)
-{
-        return s->object_size;
-}
-
+unsigned int kmem_cache_size(struct kmem_cache *s);
 void __init kmem_cache_init_late(void);
 
 #endif  /* _LINUX_SLAB_H */
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 8235dfbb3b05..b869d1662ba3 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -8,6 +8,8 @@
  */
 
 struct kmem_cache {
+        struct array_cache __percpu *cpu_cache;
+
 /* 1) Cache tunables. Protected by slab_mutex */
         unsigned int batchcount;
         unsigned int limit;
@@ -71,23 +73,7 @@ struct kmem_cache {
         struct memcg_cache_params *memcg_params;
 #endif
 
-/* 6) per-cpu/per-node data, touched during every alloc/free */
-        /*
-         * We put array[] at the end of kmem_cache, because we want to size
-         * this array to nr_cpu_ids slots instead of NR_CPUS
-         * (see kmem_cache_init())
-         * We still use [NR_CPUS] and not [1] or [0] because cache_cache
-         * is statically defined, so we reserve the max number of cpus.
-         *
-         * We also need to guarantee that the list is able to accomodate a
-         * pointer for each node since "nodelists" uses the remainder of
-         * available pointers.
-         */
-        struct kmem_cache_node **node;
-        struct array_cache *array[NR_CPUS + MAX_NUMNODES];
-        /*
-         * Do not add fields after array[]
-         */
+        struct kmem_cache_node *node[MAX_NUMNODES];
 };
 
 #endif  /* _LINUX_SLAB_DEF_H */
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 34347f26be9b..93dff5fff524 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -100,6 +100,7 @@ int smp_call_function_any(const struct cpumask *mask,
                           smp_call_func_t func, void *info, int wait);
 
 void kick_all_cpus_sync(void);
+void wake_up_all_idle_cpus(void);
 
 /*
  * Generic and arch helpers
@@ -148,6 +149,7 @@ smp_call_function_any(const struct cpumask *mask, smp_call_func_t func,
 }
 
 static inline void kick_all_cpus_sync(void) {  }
+static inline void wake_up_all_idle_cpus(void) {  }
 
 #endif /* !SMP */
 
diff --git a/include/linux/soc/ti/knav_dma.h b/include/linux/soc/ti/knav_dma.h
new file mode 100644
index 000000000000..dad035c16d94
--- /dev/null
+++ b/include/linux/soc/ti/knav_dma.h
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2014 Texas Instruments Incorporated
+ * Authors:     Sandeep Nair <sandeep_n@ti.com
+ *              Cyril Chemparathy <cyril@ti.com
+                Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __SOC_TI_KEYSTONE_NAVIGATOR_DMA_H__
+#define __SOC_TI_KEYSTONE_NAVIGATOR_DMA_H__
+
+/*
+ * PKTDMA descriptor manipulation macros for host packet descriptor
+ */
+#define MASK(x)                                 (BIT(x) - 1)
+#define KNAV_DMA_DESC_PKT_LEN_MASK              MASK(22)
+#define KNAV_DMA_DESC_PKT_LEN_SHIFT             0
+#define KNAV_DMA_DESC_PS_INFO_IN_SOP            BIT(22)
+#define KNAV_DMA_DESC_PS_INFO_IN_DESC           0
+#define KNAV_DMA_DESC_TAG_MASK                  MASK(8)
+#define KNAV_DMA_DESC_SAG_HI_SHIFT              24
+#define KNAV_DMA_DESC_STAG_LO_SHIFT             16
+#define KNAV_DMA_DESC_DTAG_HI_SHIFT             8
+#define KNAV_DMA_DESC_DTAG_LO_SHIFT             0
+#define KNAV_DMA_DESC_HAS_EPIB                  BIT(31)
+#define KNAV_DMA_DESC_NO_EPIB                   0
+#define KNAV_DMA_DESC_PSLEN_SHIFT               24
+#define KNAV_DMA_DESC_PSLEN_MASK                MASK(6)
+#define KNAV_DMA_DESC_ERR_FLAG_SHIFT            20
+#define KNAV_DMA_DESC_ERR_FLAG_MASK             MASK(4)
+#define KNAV_DMA_DESC_PSFLAG_SHIFT              16
+#define KNAV_DMA_DESC_PSFLAG_MASK               MASK(4)
+#define KNAV_DMA_DESC_RETQ_SHIFT                0
+#define KNAV_DMA_DESC_RETQ_MASK                 MASK(14)
+#define KNAV_DMA_DESC_BUF_LEN_MASK              MASK(22)
+
+#define KNAV_DMA_NUM_EPIB_WORDS                 4
+#define KNAV_DMA_NUM_PS_WORDS                   16
+#define KNAV_DMA_FDQ_PER_CHAN                   4
+
+/* Tx channel scheduling priority */
+enum knav_dma_tx_priority {
+        DMA_PRIO_HIGH   = 0,
+        DMA_PRIO_MED_H,
+        DMA_PRIO_MED_L,
+        DMA_PRIO_LOW
+};
+
+/* Rx channel error handling mode during buffer starvation */
+enum knav_dma_rx_err_mode {
+        DMA_DROP = 0,
+        DMA_RETRY
+};
+
+/* Rx flow size threshold configuration */
+enum knav_dma_rx_thresholds {
+        DMA_THRESH_NONE         = 0,
+        DMA_THRESH_0            = 1,
+        DMA_THRESH_0_1          = 3,
+        DMA_THRESH_0_1_2        = 7
+};
+
+/* Descriptor type */
+enum knav_dma_desc_type {
+        DMA_DESC_HOST = 0,
+        DMA_DESC_MONOLITHIC = 2
+};
+
+/**
+ * struct knav_dma_tx_cfg:      Tx channel configuration
+ * @filt_einfo:                 Filter extended packet info
+ * @filt_pswords:               Filter PS words present
+ * @knav_dma_tx_priority:       Tx channel scheduling priority
+ */
+struct knav_dma_tx_cfg {
+        bool                            filt_einfo;
+        bool                            filt_pswords;
+        enum knav_dma_tx_priority       priority;
+};
+
+/**
+ * struct knav_dma_rx_cfg:      Rx flow configuration
+ * @einfo_present:              Extended packet info present
+ * @psinfo_present:             PS words present
+ * @knav_dma_rx_err_mode:       Error during buffer starvation
+ * @knav_dma_desc_type: Host or Monolithic desc
+ * @psinfo_at_sop:              PS word located at start of packet
+ * @sop_offset:                 Start of packet offset
+ * @dst_q:                      Destination queue for a given flow
+ * @thresh:                     Rx flow size threshold
+ * @fdq[]:                      Free desc Queue array
+ * @sz_thresh0:                 RX packet size threshold 0
+ * @sz_thresh1:                 RX packet size threshold 1
+ * @sz_thresh2:                 RX packet size threshold 2
+ */
+struct knav_dma_rx_cfg {
+        bool                            einfo_present;
+        bool                            psinfo_present;
+        enum knav_dma_rx_err_mode       err_mode;
+        enum knav_dma_desc_type         desc_type;
+        bool                            psinfo_at_sop;
+        unsigned int                    sop_offset;
+        unsigned int                    dst_q;
+        enum knav_dma_rx_thresholds     thresh;
+        unsigned int                    fdq[KNAV_DMA_FDQ_PER_CHAN];
+        unsigned int                    sz_thresh0;
+        unsigned int                    sz_thresh1;
+        unsigned int                    sz_thresh2;
+};
+
+/**
+ * struct knav_dma_cfg: Pktdma channel configuration
+ * @sl_cfg:                     Slave configuration
+ * @tx:                         Tx channel configuration
+ * @rx:                         Rx flow configuration
+ */
+struct knav_dma_cfg {
+        enum dma_transfer_direction direction;
+        union {
+                struct knav_dma_tx_cfg  tx;
+                struct knav_dma_rx_cfg  rx;
+        } u;
+};
+
+/**
+ * struct knav_dma_desc:        Host packet descriptor layout
+ * @desc_info:                  Descriptor information like id, type, length
+ * @tag_info:                   Flow tag info written in during RX
+ * @packet_info:                Queue Manager, policy, flags etc
+ * @buff_len:                   Buffer length in bytes
+ * @buff:                       Buffer pointer
+ * @next_desc:                  For chaining the descriptors
+ * @orig_len:                   length since 'buff_len' can be overwritten
+ * @orig_buff:                  buff pointer since 'buff' can be overwritten
+ * @epib:                       Extended packet info block
+ * @psdata:                     Protocol specific
+ */
+struct knav_dma_desc {
+        u32     desc_info;
+        u32     tag_info;
+        u32     packet_info;
+        u32     buff_len;
+        u32     buff;
+        u32     next_desc;
+        u32     orig_len;
+        u32     orig_buff;
+        u32     epib[KNAV_DMA_NUM_EPIB_WORDS];
+        u32     psdata[KNAV_DMA_NUM_PS_WORDS];
+        u32     pad[4];
+} ____cacheline_aligned;
+
+#if IS_ENABLED(CONFIG_KEYSTONE_NAVIGATOR_DMA)
+void *knav_dma_open_channel(struct device *dev, const char *name,
+                                struct knav_dma_cfg *config);
+void knav_dma_close_channel(void *channel);
+#else
+static inline void *knav_dma_open_channel(struct device *dev, const char *name,
+                                struct knav_dma_cfg *config)
+{
+        return (void *) NULL;
+}
+static inline void knav_dma_close_channel(void *channel)
+{}
+
+#endif
+
+#endif /* __SOC_TI_KEYSTONE_NAVIGATOR_DMA_H__ */
diff --git a/include/linux/soc/ti/knav_qmss.h b/include/linux/soc/ti/knav_qmss.h
new file mode 100644
index 000000000000..9f0ebb3bad27
--- /dev/null
+++ b/include/linux/soc/ti/knav_qmss.h
@@ -0,0 +1,90 @@
+/*
+ * Keystone Navigator Queue Management Sub-System header
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
+ * Author:      Sandeep Nair <sandeep_n@ti.com>
+ *              Cyril Chemparathy <cyril@ti.com>
+ *              Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __SOC_TI_KNAV_QMSS_H__
+#define __SOC_TI_KNAV_QMSS_H__
+
+#include <linux/err.h>
+#include <linux/time.h>
+#include <linux/atomic.h>
+#include <linux/device.h>
+#include <linux/fcntl.h>
+#include <linux/dma-mapping.h>
+
+/* queue types */
+#define KNAV_QUEUE_QPEND        ((unsigned)-2) /* interruptible qpend queue */
+#define KNAV_QUEUE_ACC          ((unsigned)-3) /* Accumulated queue */
+#define KNAV_QUEUE_GP           ((unsigned)-4) /* General purpose queue */
+
+/* queue flags */
+#define KNAV_QUEUE_SHARED       0x0001          /* Queue can be shared */
+
+/**
+ * enum knav_queue_ctrl_cmd -   queue operations.
+ * @KNAV_QUEUE_GET_ID:          Get the ID number for an open queue
+ * @KNAV_QUEUE_FLUSH:           forcibly empty a queue if possible
+ * @KNAV_QUEUE_SET_NOTIFIER:    Set a notifier callback to a queue handle.
+ * @KNAV_QUEUE_ENABLE_NOTIFY:   Enable notifier callback for a queue handle.
+ * @KNAV_QUEUE_DISABLE_NOTIFY:  Disable notifier callback for a queue handle.
+ * @KNAV_QUEUE_GET_COUNT:       Get number of queues.
+ */
+enum knav_queue_ctrl_cmd {
+        KNAV_QUEUE_GET_ID,
+        KNAV_QUEUE_FLUSH,
+        KNAV_QUEUE_SET_NOTIFIER,
+        KNAV_QUEUE_ENABLE_NOTIFY,
+        KNAV_QUEUE_DISABLE_NOTIFY,
+        KNAV_QUEUE_GET_COUNT
+};
+
+/* Queue notifier callback prototype */
+typedef void (*knav_queue_notify_fn)(void *arg);
+
+/**
+ * struct knav_queue_notify_config:     Notifier configuration
+ * @fn:                                 Notifier function
+ * @fn_arg:                             Notifier function arguments
+ */
+struct knav_queue_notify_config {
+        knav_queue_notify_fn fn;
+        void *fn_arg;
+};
+
+void *knav_queue_open(const char *name, unsigned id,
+                                        unsigned flags);
+void knav_queue_close(void *qhandle);
+int knav_queue_device_control(void *qhandle,
+                                enum knav_queue_ctrl_cmd cmd,
+                                unsigned long arg);
+dma_addr_t knav_queue_pop(void *qhandle, unsigned *size);
+int knav_queue_push(void *qhandle, dma_addr_t dma,
+                                unsigned size, unsigned flags);
+
+void *knav_pool_create(const char *name,
+                                int num_desc, int region_id);
+void knav_pool_destroy(void *ph);
+int knav_pool_count(void *ph);
+void *knav_pool_desc_get(void *ph);
+void knav_pool_desc_put(void *ph, void *desc);
+int knav_pool_desc_map(void *ph, void *desc, unsigned size,
+                                        dma_addr_t *dma, unsigned *dma_sz);
+void *knav_pool_desc_unmap(void *ph, dma_addr_t dma, unsigned dma_sz);
+dma_addr_t knav_pool_desc_virt_to_dma(void *ph, void *virt);
+void *knav_pool_desc_dma_to_virt(void *ph, dma_addr_t dma);
+
+#endif /* __SOC_TI_KNAV_QMSS_H__ */
diff --git a/include/linux/socket.h b/include/linux/socket.h
index ec538fc287a6..6e49a14365dc 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -47,16 +47,25 @@ struct linger {
 struct msghdr {
         void            *msg_name;      /* ptr to socket address structure */
         int             msg_namelen;    /* size of socket address structure */
-        struct iovec    *msg_iov;       /* scatter/gather array */
-        __kernel_size_t msg_iovlen;     /* # elements in msg_iov */
+        struct iov_iter msg_iter;       /* data */
         void            *msg_control;   /* ancillary data */
         __kernel_size_t msg_controllen; /* ancillary data buffer length */
         unsigned int    msg_flags;      /* flags on received message */
 };
+ 
+struct user_msghdr {
+        void            __user *msg_name;       /* ptr to socket address structure */
+        int             msg_namelen;            /* size of socket address structure */
+        struct iovec    __user *msg_iov;        /* scatter/gather array */
+        __kernel_size_t msg_iovlen;             /* # elements in msg_iov */
+        void            __user *msg_control;    /* ancillary data */
+        __kernel_size_t msg_controllen;         /* ancillary data buffer length */
+        unsigned int    msg_flags;              /* flags on received message */
+};
 
 /* For recvmmsg/sendmmsg */
 struct mmsghdr {
-        struct msghdr   msg_hdr;
+        struct user_msghdr  msg_hdr;
         unsigned int        msg_len;
 };
 
@@ -94,6 +103,10 @@ struct cmsghdr {
                              (cmsg)->cmsg_len <= (unsigned long) \
                              ((mhdr)->msg_controllen - \
                               ((char *)(cmsg) - (char *)(mhdr)->msg_control)))
+#define for_each_cmsghdr(cmsg, msg) \
+        for (cmsg = CMSG_FIRSTHDR(msg); \
+             cmsg; \
+             cmsg = CMSG_NXTHDR(msg, cmsg))
 
 /*
  *      Get the next cmsg header
@@ -256,7 +269,7 @@ struct ucred {
 #define MSG_EOF         MSG_FIN
 
 #define MSG_FASTOPEN    0x20000000      /* Send data in TCP SYN */
-#define MSG_CMSG_CLOEXEC 0x40000000     /* Set close_on_exit for file
+#define MSG_CMSG_CLOEXEC 0x40000000     /* Set close_on_exec for file
                                            descriptor received through
                                            SCM_RIGHTS */
 #if defined(CONFIG_COMPAT)
@@ -312,15 +325,14 @@ extern int csum_partial_copy_fromiovecend(unsigned char *kdata,
 extern unsigned long iov_pages(const struct iovec *iov, int offset,
                                unsigned long nr_segs);
 
-extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr_storage *address, int mode);
 extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr);
 extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
 
 struct timespec;
 
 /* The __sys_...msg variants allow MSG_CMSG_COMPAT */
-extern long __sys_recvmsg(int fd, struct msghdr __user *msg, unsigned flags);
-extern long __sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags);
+extern long __sys_recvmsg(int fd, struct user_msghdr __user *msg, unsigned flags);
+extern long __sys_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags);
 extern int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
                           unsigned int flags, struct timespec *timeout);
 extern int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg,
diff --git a/include/linux/spi/mcp23s08.h b/include/linux/spi/mcp23s08.h
index 2d676d5aaa89..aa07d7b32568 100644
--- a/include/linux/spi/mcp23s08.h
+++ b/include/linux/spi/mcp23s08.h
@@ -22,4 +22,22 @@ struct mcp23s08_platform_data {
          * base to base+15 (or base+31 for s17 variant).
          */
         unsigned        base;
+        /* Marks the device as a interrupt controller.
+         * NOTE: The interrupt functionality is only supported for i2c
+         * versions of the chips. The spi chips can also do the interrupts,
+         * but this is not supported by the linux driver yet.
+         */
+        bool            irq_controller;
+
+        /* Sets the mirror flag in the IOCON register. Devices
+         * with two interrupt outputs (these are the devices ending with 17 and
+         * those that have 16 IOs) have two IO banks: IO 0-7 form bank 1 and
+         * IO 8-15 are bank 2. These chips have two different interrupt outputs:
+         * One for bank 1 and another for bank 2. If irq-mirror is set, both
+         * interrupts are generated regardless of the bank that an input change
+         * occurred on. If it is not set, the interrupt are only generated for
+         * the bank they belong to.
+         * On devices with only one interrupt output this property is useless.
+         */
+        bool            mirror;
 };
diff --git a/include/linux/spi/pxa2xx_spi.h b/include/linux/spi/pxa2xx_spi.h
index 82d5111cd0c2..d5a316550177 100644
--- a/include/linux/spi/pxa2xx_spi.h
+++ b/include/linux/spi/pxa2xx_spi.h
@@ -23,6 +23,8 @@
 #define PXA2XX_CS_ASSERT (0x01)
 #define PXA2XX_CS_DEASSERT (0x02)
 
+struct dma_chan;
+
 /* device.platform_data for SSP controller devices */
 struct pxa2xx_spi_master {
         u32 clock_enable;
@@ -30,10 +32,9 @@ struct pxa2xx_spi_master {
         u8 enable_dma;
 
         /* DMA engine specific config */
-        int rx_chan_id;
-        int tx_chan_id;
-        int rx_slave_id;
-        int tx_slave_id;
+        bool (*dma_filter)(struct dma_chan *chan, void *param);
+        void *tx_param;
+        void *rx_param;
 
         /* For non-PXA arches */
         struct ssp_device ssp;
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 46d188a9947c..a6ef2a8e6de4 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -1049,4 +1049,10 @@ spi_unregister_device(struct spi_device *spi)
 extern const struct spi_device_id *
 spi_get_device_id(const struct spi_device *sdev);
 
+static inline bool
+spi_transfer_is_last(struct spi_master *master, struct spi_transfer *xfer)
+{
+        return list_is_last(&xfer->transfer_list, &master->cur_msg->transfers);
+}
+
 #endif /* __LINUX_SPI_H */
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 3f2867ff0ced..262ba4ef9a8e 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -197,7 +197,13 @@ static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
                  _raw_spin_lock_nest_lock(lock, &(nest_lock)->dep_map); \
          } while (0)
 #else
-# define raw_spin_lock_nested(lock, subclass)           _raw_spin_lock(lock)
+/*
+ * Always evaluate the 'subclass' argument to avoid that the compiler
+ * warns about set-but-not-used variables when building with
+ * CONFIG_DEBUG_LOCK_ALLOC=n and with W=1.
+ */
+# define raw_spin_lock_nested(lock, subclass)           \
+        _raw_spin_lock(((void)(subclass), (lock)))
 # define raw_spin_lock_nest_lock(lock, nest_lock)       _raw_spin_lock(lock)
 #endif
 
diff --git a/include/linux/spmi.h b/include/linux/spmi.h
index 91f5eab9e428..f84212cd3b7d 100644
--- a/include/linux/spmi.h
+++ b/include/linux/spmi.h
@@ -134,9 +134,6 @@ void spmi_controller_remove(struct spmi_controller *ctrl);
  *              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
diff --git a/include/linux/stacktrace.h b/include/linux/stacktrace.h
index 115b570e3bff..669045ab73f3 100644
--- a/include/linux/stacktrace.h
+++ b/include/linux/stacktrace.h
@@ -1,6 +1,8 @@
 #ifndef __LINUX_STACKTRACE_H
 #define __LINUX_STACKTRACE_H
 
+#include <linux/types.h>
+
 struct task_struct;
 struct pt_regs;
 
@@ -20,6 +22,8 @@ extern void save_stack_trace_tsk(struct task_struct *tsk,
                                 struct stack_trace *trace);
 
 extern void print_stack_trace(struct stack_trace *trace, int spaces);
+extern int snprint_stack_trace(char *buf, size_t size,
+                        struct stack_trace *trace, int spaces);
 
 #ifdef CONFIG_USER_STACKTRACE_SUPPORT
 extern void save_stack_trace_user(struct stack_trace *trace);
@@ -32,6 +36,7 @@ extern void save_stack_trace_user(struct stack_trace *trace);
 # define save_stack_trace_tsk(tsk, trace)               do { } while (0)
 # define save_stack_trace_user(trace)                   do { } while (0)
 # define print_stack_trace(trace, spaces)               do { } while (0)
+# define snprint_stack_trace(buf, size, trace, spaces)  do { } while (0)
 #endif
 
 #endif
diff --git a/include/linux/string.h b/include/linux/string.h
index d36977e029af..2e22a2e58f3a 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -41,7 +41,7 @@ extern int strcmp(const char *,const char *);
 extern int strncmp(const char *,const char *,__kernel_size_t);
 #endif
 #ifndef __HAVE_ARCH_STRNICMP
-extern int strnicmp(const char *, const char *, __kernel_size_t);
+#define strnicmp strncasecmp
 #endif
 #ifndef __HAVE_ARCH_STRCASECMP
 extern int strcasecmp(const char *s1, const char *s2);
@@ -132,7 +132,7 @@ int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __printf(3, 4);
 #endif
 
 extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
-                        const void *from, size_t available);
+                                       const void *from, size_t available);
 
 /**
  * strstarts - does @str start with @prefix?
@@ -144,7 +144,8 @@ static inline bool strstarts(const char *str, const char *prefix)
         return strncmp(str, prefix, strlen(prefix)) == 0;
 }
 
-extern size_t memweight(const void *ptr, size_t bytes);
+size_t memweight(const void *ptr, size_t bytes);
+void memzero_explicit(void *s, size_t count);
 
 /**
  * kbasename - return the last part of a pathname.
diff --git a/include/linux/string_helpers.h b/include/linux/string_helpers.h
index 3eeee9672a4a..6eb567ac56bc 100644
--- a/include/linux/string_helpers.h
+++ b/include/linux/string_helpers.h
@@ -20,40 +20,6 @@ int string_get_size(u64 size, enum string_size_units units,
 #define UNESCAPE_ANY            \
         (UNESCAPE_SPACE | UNESCAPE_OCTAL | UNESCAPE_HEX | UNESCAPE_SPECIAL)
 
-/**
- * string_unescape - unquote characters in the given string
- * @src:        source buffer (escaped)
- * @dst:        destination buffer (unescaped)
- * @size:       size of the destination buffer (0 to unlimit)
- * @flags:      combination of the flags (bitwise OR):
- *      %UNESCAPE_SPACE:
- *              '\f' - form feed
- *              '\n' - new line
- *              '\r' - carriage return
- *              '\t' - horizontal tab
- *              '\v' - vertical tab
- *      %UNESCAPE_OCTAL:
- *              '\NNN' - byte with octal value NNN (1 to 3 digits)
- *      %UNESCAPE_HEX:
- *              '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
- *      %UNESCAPE_SPECIAL:
- *              '\"' - double quote
- *              '\\' - backslash
- *              '\a' - alert (BEL)
- *              '\e' - escape
- *      %UNESCAPE_ANY:
- *              all previous together
- *
- * Returns amount of characters processed to the destination buffer excluding
- * trailing '\0'.
- *
- * Because the size of the output will be the same as or less than the size of
- * the input, the transformation may be performed in place.
- *
- * Caller must provide valid source and destination pointers. Be aware that
- * destination buffer will always be NULL-terminated. Source string must be
- * NULL-terminated as well.
- */
 int string_unescape(char *src, char *dst, size_t size, unsigned int flags);
 
 static inline int string_unescape_inplace(char *buf, unsigned int flags)
@@ -71,4 +37,35 @@ static inline int string_unescape_any_inplace(char *buf)
         return string_unescape_any(buf, buf, 0);
 }
 
+#define ESCAPE_SPACE            0x01
+#define ESCAPE_SPECIAL          0x02
+#define ESCAPE_NULL             0x04
+#define ESCAPE_OCTAL            0x08
+#define ESCAPE_ANY              \
+        (ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_SPECIAL | ESCAPE_NULL)
+#define ESCAPE_NP               0x10
+#define ESCAPE_ANY_NP           (ESCAPE_ANY | ESCAPE_NP)
+#define ESCAPE_HEX              0x20
+
+int string_escape_mem(const char *src, size_t isz, char **dst, size_t osz,
+                unsigned int flags, const char *esc);
+
+static inline int string_escape_mem_any_np(const char *src, size_t isz,
+                char **dst, size_t osz, const char *esc)
+{
+        return string_escape_mem(src, isz, dst, osz, ESCAPE_ANY_NP, esc);
+}
+
+static inline int string_escape_str(const char *src, char **dst, size_t sz,
+                unsigned int flags, const char *esc)
+{
+        return string_escape_mem(src, strlen(src), dst, sz, flags, esc);
+}
+
+static inline int string_escape_str_any_np(const char *src, char **dst,
+                size_t sz, const char *esc)
+{
+        return string_escape_str(src, dst, sz, ESCAPE_ANY_NP, esc);
+}
+
 #endif
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 8e030075fe79..a7cbb570cc5c 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -53,7 +53,7 @@ struct rpc_cred {
         struct rcu_head         cr_rcu;
         struct rpc_auth *       cr_auth;
         const struct rpc_credops *cr_ops;
-#ifdef RPC_DEBUG
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
         unsigned long           cr_magic;       /* 0x0f4aa4f0 */
 #endif
         unsigned long           cr_expire;      /* when to gc */
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 70736b98c721..d86acc63b25f 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -63,6 +63,9 @@ struct rpc_clnt {
         struct rpc_rtt          cl_rtt_default;
         struct rpc_timeout      cl_timeout_default;
         const struct rpc_program *cl_program;
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+        struct dentry           *cl_debugfs;    /* debugfs directory */
+#endif
 };
 
 /*
@@ -176,5 +179,6 @@ size_t		rpc_peeraddr(struct rpc_clnt *, struct sockaddr *, size_t);
 const char      *rpc_peeraddr2str(struct rpc_clnt *, enum rpc_display_format_t);
 int             rpc_localaddr(struct rpc_clnt *, struct sockaddr *, size_t);
 
+const char *rpc_proc_name(const struct rpc_task *task);
 #endif /* __KERNEL__ */
 #endif /* _LINUX_SUNRPC_CLNT_H */
diff --git a/include/linux/sunrpc/debug.h b/include/linux/sunrpc/debug.h
index 9385bd74c860..c57d8ea0716c 100644
--- a/include/linux/sunrpc/debug.h
+++ b/include/linux/sunrpc/debug.h
@@ -10,22 +10,10 @@
 
 #include <uapi/linux/sunrpc/debug.h>
 
-
-/*
- * Enable RPC debugging/profiling.
- */
-#ifdef CONFIG_SUNRPC_DEBUG
-#define  RPC_DEBUG
-#endif
-#ifdef CONFIG_TRACEPOINTS
-#define RPC_TRACEPOINTS
-#endif
-/* #define  RPC_PROFILE */
-
 /*
  * Debugging macros etc
  */
-#ifdef RPC_DEBUG
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 extern unsigned int             rpc_debug;
 extern unsigned int             nfs_debug;
 extern unsigned int             nfsd_debug;
@@ -36,7 +24,7 @@ extern unsigned int		nlm_debug;
 #define dprintk_rcu(args...)    dfprintk_rcu(FACILITY, ## args)
 
 #undef ifdebug
-#ifdef RPC_DEBUG                        
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 # define ifdebug(fac)           if (unlikely(rpc_debug & RPCDBG_##fac))
 
 # define dfprintk(fac, args...) \
@@ -65,9 +53,55 @@ extern unsigned int		nlm_debug;
 /*
  * Sysctl interface for RPC debugging
  */
-#ifdef RPC_DEBUG
+
+struct rpc_clnt;
+struct rpc_xprt;
+
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 void            rpc_register_sysctl(void);
 void            rpc_unregister_sysctl(void);
+int             sunrpc_debugfs_init(void);
+void            sunrpc_debugfs_exit(void);
+int             rpc_clnt_debugfs_register(struct rpc_clnt *);
+void            rpc_clnt_debugfs_unregister(struct rpc_clnt *);
+int             rpc_xprt_debugfs_register(struct rpc_xprt *);
+void            rpc_xprt_debugfs_unregister(struct rpc_xprt *);
+#else
+static inline int
+sunrpc_debugfs_init(void)
+{
+        return 0;
+}
+
+static inline void
+sunrpc_debugfs_exit(void)
+{
+        return;
+}
+
+static inline int
+rpc_clnt_debugfs_register(struct rpc_clnt *clnt)
+{
+        return 0;
+}
+
+static inline void
+rpc_clnt_debugfs_unregister(struct rpc_clnt *clnt)
+{
+        return;
+}
+
+static inline int
+rpc_xprt_debugfs_register(struct rpc_xprt *xprt)
+{
+        return 0;
+}
+
+static inline void
+rpc_xprt_debugfs_unregister(struct rpc_xprt *xprt)
+{
+        return;
+}
 #endif
 
 #endif /* _LINUX_SUNRPC_DEBUG_H_ */
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
index 1565bbe86d51..eecb5a71e6c0 100644
--- a/include/linux/sunrpc/metrics.h
+++ b/include/linux/sunrpc/metrics.h
@@ -27,10 +27,13 @@
 
 #include <linux/seq_file.h>
 #include <linux/ktime.h>
+#include <linux/spinlock.h>
 
 #define RPC_IOSTATS_VERS        "1.0"
 
 struct rpc_iostats {
+        spinlock_t              om_lock;
+
         /*
          * These counters give an idea about how many request
          * transmissions are required, on average, to complete that
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 1a8959944c5f..5f1e6bd4c316 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -79,7 +79,7 @@ struct rpc_task {
         unsigned short          tk_flags;       /* misc flags */
         unsigned short          tk_timeouts;    /* maj timeouts */
 
-#if defined(RPC_DEBUG) || defined(RPC_TRACEPOINTS)
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS)
         unsigned short          tk_pid;         /* debugging aid */
 #endif
         unsigned char           tk_priority : 2,/* Task priority */
@@ -187,7 +187,7 @@ struct rpc_wait_queue {
         unsigned char           nr;                     /* # tasks remaining for cookie */
         unsigned short          qlen;                   /* total # tasks waiting in queue */
         struct rpc_timer        timer_list;
-#if defined(RPC_DEBUG) || defined(RPC_TRACEPOINTS)
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS)
         const char *            name;
 #endif
 };
@@ -237,7 +237,7 @@ void		rpc_free(void *);
 int             rpciod_up(void);
 void            rpciod_down(void);
 int             __rpc_wait_for_completion_task(struct rpc_task *task, wait_bit_action_f *);
-#ifdef RPC_DEBUG
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 struct net;
 void            rpc_show_tasks(struct net *);
 #endif
@@ -251,7 +251,7 @@ static inline int rpc_wait_for_completion_task(struct rpc_task *task)
         return __rpc_wait_for_completion_task(task, NULL);
 }
 
-#if defined(RPC_DEBUG) || defined (RPC_TRACEPOINTS)
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS)
 static inline const char * rpc_qname(const struct rpc_wait_queue *q)
 {
         return ((q && q->name) ? q->name : "unknown");
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index cf61ecd148e0..6f22cfeef5e3 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -26,10 +26,10 @@ typedef int		(*svc_thread_fn)(void *);
 
 /* statistics for svc_pool structures */
 struct svc_pool_stats {
-        unsigned long   packets;
+        atomic_long_t   packets;
         unsigned long   sockets_queued;
-        unsigned long   threads_woken;
-        unsigned long   threads_timedout;
+        atomic_long_t   threads_woken;
+        atomic_long_t   threads_timedout;
 };
 
 /*
@@ -45,12 +45,13 @@ struct svc_pool_stats {
 struct svc_pool {
         unsigned int            sp_id;          /* pool id; also node id on NUMA */
         spinlock_t              sp_lock;        /* protects all fields */
-        struct list_head        sp_threads;     /* idle server threads */
         struct list_head        sp_sockets;     /* pending sockets */
         unsigned int            sp_nrthreads;   /* # of threads in pool */
         struct list_head        sp_all_threads; /* all server threads */
         struct svc_pool_stats   sp_stats;       /* statistics on pool operation */
-        int                     sp_task_pending;/* has pending task */
+#define SP_TASK_PENDING         (0)             /* still work to do even if no
+                                                 * xprt is queued. */
+        unsigned long           sp_flags;
 } ____cacheline_aligned_in_smp;
 
 /*
@@ -219,8 +220,8 @@ static inline void svc_putu32(struct kvec *iov, __be32 val)
  * processed.
  */
 struct svc_rqst {
-        struct list_head        rq_list;        /* idle list */
         struct list_head        rq_all;         /* all threads list */
+        struct rcu_head         rq_rcu_head;    /* for RCU deferred kfree */
         struct svc_xprt *       rq_xprt;        /* transport ptr */
 
         struct sockaddr_storage rq_addr;        /* peer address */
@@ -236,7 +237,6 @@ struct svc_rqst {
         struct svc_cred         rq_cred;        /* auth info */
         void *                  rq_xprt_ctxt;   /* transport specific context ptr */
         struct svc_deferred_req*rq_deferred;    /* deferred request we are replaying */
-        bool                    rq_usedeferral; /* use deferral */
 
         size_t                  rq_xprt_hlen;   /* xprt header len */
         struct xdr_buf          rq_arg;
@@ -253,9 +253,17 @@ struct svc_rqst {
         u32                     rq_vers;        /* program version */
         u32                     rq_proc;        /* procedure number */
         u32                     rq_prot;        /* IP protocol */
-        unsigned short
-                                rq_secure  : 1; /* secure port */
-        unsigned short          rq_local   : 1; /* local request */
+        int                     rq_cachetype;   /* catering to nfsd */
+#define RQ_SECURE       (0)                     /* secure port */
+#define RQ_LOCAL        (1)                     /* local request */
+#define RQ_USEDEFERRAL  (2)                     /* use deferral */
+#define RQ_DROPME       (3)                     /* drop current reply */
+#define RQ_SPLICE_OK    (4)                     /* turned off in gss privacy
+                                                 * to prevent encrypting page
+                                                 * cache pages */
+#define RQ_VICTIM       (5)                     /* about to be shut down */
+#define RQ_BUSY         (6)                     /* request is busy */
+        unsigned long           rq_flags;       /* flags field */
 
         void *                  rq_argp;        /* decoded arguments */
         void *                  rq_resp;        /* xdr'd results */
@@ -271,17 +279,12 @@ struct svc_rqst {
         struct cache_req        rq_chandle;     /* handle passed to caches for 
                                                  * request delaying 
                                                  */
-        bool                    rq_dropme;
         /* Catering to nfsd */
         struct auth_domain *    rq_client;      /* RPC peer info */
         struct auth_domain *    rq_gssclient;   /* "gss/"-style peer info */
-        int                     rq_cachetype;
         struct svc_cacherep *   rq_cacherep;    /* cache info */
-        bool                    rq_splice_ok;   /* turned off in gss privacy
-                                                 * to prevent encrypting page
-                                                 * cache pages */
-        wait_queue_head_t       rq_wait;        /* synchronization */
         struct task_struct      *rq_task;       /* service thread */
+        spinlock_t              rq_lock;        /* per-request lock */
 };
 
 #define SVC_NET(svc_rqst)       (svc_rqst->rq_xprt->xpt_net)
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h
index ce6e4182a5b2..79f6f8f3dc0a 100644
--- a/include/linux/sunrpc/svc_xprt.h
+++ b/include/linux/sunrpc/svc_xprt.h
@@ -63,10 +63,9 @@ struct svc_xprt {
 #define XPT_CHNGBUF     7               /* need to change snd/rcv buf sizes */
 #define XPT_DEFERRED    8               /* deferred request pending */
 #define XPT_OLD         9               /* used for xprt aging mark+sweep */
-#define XPT_DETACHED    10              /* detached from tempsocks list */
-#define XPT_LISTENER    11              /* listening endpoint */
-#define XPT_CACHE_AUTH  12              /* cache auth info */
-#define XPT_LOCAL       13              /* connection from loopback interface */
+#define XPT_LISTENER    10              /* listening endpoint */
+#define XPT_CACHE_AUTH  11              /* cache auth info */
+#define XPT_LOCAL       12              /* connection from loopback interface */
 
         struct svc_serv         *xpt_server;    /* service for transport */
         atomic_t                xpt_reserved;   /* space on outq that is rsvd */
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index fcbfe8783243..9d27ac45b909 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -239,6 +239,9 @@ struct rpc_xprt {
         struct net              *xprt_net;
         const char              *servername;
         const char              *address_strings[RPC_DISPLAY_MAX];
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+        struct dentry           *debugfs;               /* debugfs directory */
+#endif
 };
 
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
@@ -357,6 +360,7 @@ int			xs_swapper(struct rpc_xprt *xprt, int enable);
 #define XPRT_CONNECTION_ABORT   (7)
 #define XPRT_CONNECTION_CLOSE   (8)
 #define XPRT_CONGESTED          (9)
+#define XPRT_CONNECTION_REUSE   (10)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {
diff --git a/include/linux/sunrpc/xprtsock.h b/include/linux/sunrpc/xprtsock.h
index 1ad36cc25b2e..7591788e9fbf 100644
--- a/include/linux/sunrpc/xprtsock.h
+++ b/include/linux/sunrpc/xprtsock.h
@@ -17,6 +17,65 @@ void		cleanup_socket_xprt(void);
 #define RPC_DEF_MIN_RESVPORT    (665U)
 #define RPC_DEF_MAX_RESVPORT    (1023U)
 
+struct sock_xprt {
+        struct rpc_xprt         xprt;
+
+        /*
+         * Network layer
+         */
+        struct socket *         sock;
+        struct sock *           inet;
+
+        /*
+         * State of TCP reply receive
+         */
+        __be32                  tcp_fraghdr,
+                                tcp_xid,
+                                tcp_calldir;
+
+        u32                     tcp_offset,
+                                tcp_reclen;
+
+        unsigned long           tcp_copied,
+                                tcp_flags;
+
+        /*
+         * Connection of transports
+         */
+        struct delayed_work     connect_worker;
+        struct sockaddr_storage srcaddr;
+        unsigned short          srcport;
+
+        /*
+         * UDP socket buffer size parameters
+         */
+        size_t                  rcvsize,
+                                sndsize;
+
+        /*
+         * Saved socket callback addresses
+         */
+        void                    (*old_data_ready)(struct sock *);
+        void                    (*old_state_change)(struct sock *);
+        void                    (*old_write_space)(struct sock *);
+        void                    (*old_error_report)(struct sock *);
+};
+
+/*
+ * TCP receive state flags
+ */
+#define TCP_RCV_LAST_FRAG       (1UL << 0)
+#define TCP_RCV_COPY_FRAGHDR    (1UL << 1)
+#define TCP_RCV_COPY_XID        (1UL << 2)
+#define TCP_RCV_COPY_DATA       (1UL << 3)
+#define TCP_RCV_READ_CALLDIR    (1UL << 4)
+#define TCP_RCV_COPY_CALLDIR    (1UL << 5)
+
+/*
+ * TCP RPC flags
+ */
+#define TCP_RPC_REPLY           (1UL << 6)
+
 #endif /* __KERNEL__ */
 
 #endif /* _LINUX_SUNRPC_XPRTSOCK_H */
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 519064e0c943..3388c1b6f7d8 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -189,6 +189,8 @@ struct platform_suspend_ops {
 
 struct platform_freeze_ops {
         int (*begin)(void);
+        int (*prepare)(void);
+        void (*restore)(void);
         void (*end)(void);
 };
 
@@ -371,6 +373,8 @@ extern int unregister_pm_notifier(struct notifier_block *nb);
 extern bool events_check_enabled;
 
 extern bool pm_wakeup_pending(void);
+extern void pm_system_wakeup(void);
+extern void pm_wakeup_clear(void);
 extern bool pm_get_wakeup_count(unsigned int *count, bool block);
 extern bool pm_save_wakeup_count(unsigned int count);
 extern void pm_wakep_autosleep_enabled(bool set);
@@ -418,6 +422,8 @@ static inline int unregister_pm_notifier(struct notifier_block *nb)
 #define pm_notifier(fn, pri)    do { (void)(fn); } while (0)
 
 static inline bool pm_wakeup_pending(void) { return false; }
+static inline void pm_system_wakeup(void) {}
+static inline void pm_wakeup_clear(void) {}
 
 static inline void lock_system_sleep(void) {}
 static inline void unlock_system_sleep(void) {}
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 1b72060f093a..34e8b60ab973 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -102,14 +102,6 @@ union swap_header {
         } info;
 };
 
- /* A swap entry has to fit into a "unsigned long", as
-  * the entry is hidden in the "index" field of the
-  * swapper address space.
-  */
-typedef struct {
-        unsigned long val;
-} swp_entry_t;
-
 /*
  * current->reclaim_state points to one of these when a task is running
  * memory reclaim
@@ -327,8 +319,10 @@ extern void lru_cache_add_active_or_unevictable(struct page *page,
 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
                                         gfp_t gfp_mask, nodemask_t *mask);
 extern int __isolate_lru_page(struct page *page, isolate_mode_t mode);
-extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem,
-                                                  gfp_t gfp_mask, bool noswap);
+extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
+                                                  unsigned long nr_pages,
+                                                  gfp_t gfp_mask,
+                                                  bool may_swap);
 extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
                                                 gfp_t gfp_mask, bool noswap,
                                                 struct zone *zone,
@@ -354,22 +348,6 @@ static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
 extern int page_evictable(struct page *page);
 extern void check_move_unevictable_pages(struct page **, int nr_pages);
 
-extern unsigned long scan_unevictable_pages;
-extern int scan_unevictable_handler(struct ctl_table *, int,
-                                        void __user *, size_t *, loff_t *);
-#ifdef CONFIG_NUMA
-extern int scan_unevictable_register_node(struct node *node);
-extern void scan_unevictable_unregister_node(struct node *node);
-#else
-static inline int scan_unevictable_register_node(struct node *node)
-{
-        return 0;
-}
-static inline void scan_unevictable_unregister_node(struct node *node)
-{
-}
-#endif
-
 extern int kswapd_run(int nid);
 extern void kswapd_stop(int nid);
 #ifdef CONFIG_MEMCG
diff --git a/include/linux/swap_cgroup.h b/include/linux/swap_cgroup.h
new file mode 100644
index 000000000000..145306bdc92f
--- /dev/null
+++ b/include/linux/swap_cgroup.h
@@ -0,0 +1,42 @@
+#ifndef __LINUX_SWAP_CGROUP_H
+#define __LINUX_SWAP_CGROUP_H
+
+#include <linux/swap.h>
+
+#ifdef CONFIG_MEMCG_SWAP
+
+extern unsigned short swap_cgroup_cmpxchg(swp_entry_t ent,
+                                        unsigned short old, unsigned short new);
+extern unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id);
+extern unsigned short lookup_swap_cgroup_id(swp_entry_t ent);
+extern int swap_cgroup_swapon(int type, unsigned long max_pages);
+extern void swap_cgroup_swapoff(int type);
+
+#else
+
+static inline
+unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id)
+{
+        return 0;
+}
+
+static inline
+unsigned short lookup_swap_cgroup_id(swp_entry_t ent)
+{
+        return 0;
+}
+
+static inline int
+swap_cgroup_swapon(int type, unsigned long max_pages)
+{
+        return 0;
+}
+
+static inline void swap_cgroup_swapoff(int type)
+{
+        return;
+}
+
+#endif /* CONFIG_MEMCG_SWAP */
+
+#endif /* __LINUX_SWAP_CGROUP_H */
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 0f86d85a9ce4..85893d744901 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -25,7 +25,7 @@ struct linux_dirent64;
 struct list_head;
 struct mmap_arg_struct;
 struct msgbuf;
-struct msghdr;
+struct user_msghdr;
 struct mmsghdr;
 struct msqid_ds;
 struct new_utsname;
@@ -65,6 +65,7 @@ struct old_linux_dirent;
 struct perf_event_attr;
 struct file_handle;
 struct sigaltstack;
+union bpf_attr;
 
 #include <linux/types.h>
 #include <linux/aio_abi.h>
@@ -600,13 +601,13 @@ asmlinkage long sys_getpeername(int, struct sockaddr __user *, int __user *);
 asmlinkage long sys_send(int, void __user *, size_t, unsigned);
 asmlinkage long sys_sendto(int, void __user *, size_t, unsigned,
                                 struct sockaddr __user *, int);
-asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags);
+asmlinkage long sys_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags);
 asmlinkage long sys_sendmmsg(int fd, struct mmsghdr __user *msg,
                              unsigned int vlen, unsigned flags);
 asmlinkage long sys_recv(int, void __user *, size_t, unsigned);
 asmlinkage long sys_recvfrom(int, void __user *, size_t, unsigned,
                                 struct sockaddr __user *, int __user *);
-asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, unsigned flags);
+asmlinkage long sys_recvmsg(int fd, struct user_msghdr __user *msg, unsigned flags);
 asmlinkage long sys_recvmmsg(int fd, struct mmsghdr __user *msg,
                              unsigned int vlen, unsigned flags,
                              struct timespec __user *timeout);
@@ -875,5 +876,10 @@ asmlinkage long sys_seccomp(unsigned int op, unsigned int flags,
                             const char __user *uargs);
 asmlinkage long sys_getrandom(char __user *buf, size_t count,
                               unsigned int flags);
+asmlinkage long sys_bpf(int cmd, union bpf_attr *attr, unsigned int size);
+
+asmlinkage long sys_execveat(int dfd, const char __user *filename,
+                        const char __user *const __user *argv,
+                        const char __user *const __user *envp, int flags);
 
 #endif
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index f97d0dbb59fa..ddad16148bd6 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -70,6 +70,8 @@ struct attribute_group {
  * for examples..
  */
 
+#define SYSFS_PREALLOC 010000
+
 #define __ATTR(_name, _mode, _show, _store) {                           \
         .attr = {.name = __stringify(_name),                            \
                  .mode = VERIFY_OCTAL_PERMISSIONS(_mode) },             \
@@ -77,6 +79,13 @@ struct attribute_group {
         .store  = _store,                                               \
 }
 
+#define __ATTR_PREALLOC(_name, _mode, _show, _store) {                  \
+        .attr = {.name = __stringify(_name),                            \
+                 .mode = SYSFS_PREALLOC | VERIFY_OCTAL_PERMISSIONS(_mode) },\
+        .show   = _show,                                                \
+        .store  = _store,                                               \
+}
+
 #define __ATTR_RO(_name) {                                              \
         .attr   = { .name = __stringify(_name), .mode = S_IRUGO },      \
         .show   = _name##_show,                                         \
diff --git a/include/linux/syslog.h b/include/linux/syslog.h
index 98a3153c0f96..4b7b875a7ce1 100644
--- a/include/linux/syslog.h
+++ b/include/linux/syslog.h
@@ -49,4 +49,13 @@
 
 int do_syslog(int type, char __user *buf, int count, bool from_file);
 
+#ifdef CONFIG_PRINTK
+int check_syslog_permissions(int type, bool from_file);
+#else
+static inline int check_syslog_permissions(int type, bool from_file)
+{
+        return 0;
+}
+#endif
+
 #endif /* _LINUX_SYSLOG_H */
diff --git a/include/linux/t10-pi.h b/include/linux/t10-pi.h
new file mode 100644
index 000000000000..6a8b9942632d
--- /dev/null
+++ b/include/linux/t10-pi.h
@@ -0,0 +1,22 @@
+#ifndef _LINUX_T10_PI_H
+#define _LINUX_T10_PI_H
+
+#include <linux/types.h>
+#include <linux/blkdev.h>
+
+/*
+ * T10 Protection Information tuple.
+ */
+struct t10_pi_tuple {
+        __be16 guard_tag;       /* Checksum */
+        __be16 app_tag;         /* Opaque storage */
+        __be32 ref_tag;         /* Target LBA or indirect LBA */
+};
+
+
+extern struct blk_integrity t10_pi_type1_crc;
+extern struct blk_integrity t10_pi_type1_ip;
+extern struct blk_integrity t10_pi_type3_crc;
+extern struct blk_integrity t10_pi_type3_ip;
+
+#endif
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index fa5258f322e7..67309ece0772 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -19,7 +19,6 @@
 
 
 #include <linux/skbuff.h>
-#include <linux/dmaengine.h>
 #include <net/sock.h>
 #include <net/inet_connection_sock.h>
 #include <net/inet_timewait_sock.h>
@@ -131,7 +130,7 @@ struct tcp_sock {
         /* inet_connection_sock has to be the first member of tcp_sock */
         struct inet_connection_sock     inet_conn;
         u16     tcp_header_len; /* Bytes of tcp header to send          */
-        u16     xmit_size_goal_segs; /* Goal for segmenting output packets */
+        u16     gso_segs;       /* Max number of segs per GSO packet    */
 
 /*
  *      Header prediction flags
@@ -163,16 +162,9 @@ struct tcp_sock {
         struct {
                 struct sk_buff_head     prequeue;
                 struct task_struct      *task;
-                struct iovec            *iov;
+                struct msghdr           *msg;
                 int                     memory;
                 int                     len;
-#ifdef CONFIG_NET_DMA
-                /* members for async copy */
-                struct dma_chan         *dma_chan;
-                int                     wakeup;
-                struct dma_pinned_list  *pinned_list;
-                dma_cookie_t            dma_cookie;
-#endif
         } ucopy;
 
         u32     snd_wl1;        /* Sequence for window update           */
@@ -212,10 +204,10 @@ struct tcp_sock {
 
         u16     urg_data;       /* Saved octet of OOB data and control flags */
         u8      ecn_flags;      /* ECN status bits.                     */
-        u8      reordering;     /* Packet reordering metric.            */
+        u8      keepalive_probes; /* num of allowed keep alive probes   */
+        u32     reordering;     /* Packet reordering metric.            */
         u32     snd_up;         /* Urgent pointer               */
 
-        u8      keepalive_probes; /* num of allowed keep alive probes   */
 /*
  *      Options received (usually on last packet, some only on SYN packets).
  */
@@ -276,7 +268,7 @@ struct tcp_sock {
         u32     retrans_stamp;  /* Timestamp of the last retransmit,
                                  * also used in SYN-SENT to remember stamp of
                                  * the first SYN. */
-        u32     undo_marker;    /* tracking retrans started here. */
+        u32     undo_marker;    /* snd_una upon a new recovery episode. */
         int     undo_retrans;   /* number of undoable retransmissions. */
         u32     total_retrans;  /* Total retransmits for entire connection */
 
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index 0305cde21a74..fc52e307efab 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -29,26 +29,25 @@
 #include <linux/idr.h>
 #include <linux/device.h>
 #include <linux/workqueue.h>
+#include <uapi/linux/thermal.h>
 
 #define THERMAL_TRIPS_NONE      -1
 #define THERMAL_MAX_TRIPS       12
-#define THERMAL_NAME_LENGTH     20
 
 /* invalid cooling state */
 #define THERMAL_CSTATE_INVALID -1UL
 
 /* No upper/lower limit requirement */
-#define THERMAL_NO_LIMIT        THERMAL_CSTATE_INVALID
+#define THERMAL_NO_LIMIT        ((u32)~0)
 
 /* Unit conversion macros */
 #define KELVIN_TO_CELSIUS(t)    (long)(((long)t-2732 >= 0) ?    \
                                 ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
 #define CELSIUS_TO_KELVIN(t)    ((t)*10+2732)
-
-/* Adding event notification support elements */
-#define THERMAL_GENL_FAMILY_NAME                "thermal_event"
-#define THERMAL_GENL_VERSION                    0x01
-#define THERMAL_GENL_MCAST_GROUP_NAME           "thermal_mc_grp"
+#define DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(t, off) (((t) - (off)) * 100)
+#define DECI_KELVIN_TO_MILLICELSIUS(t) DECI_KELVIN_TO_MILLICELSIUS_WITH_OFFSET(t, 2732)
+#define MILLICELSIUS_TO_DECI_KELVIN_WITH_OFFSET(t, off) (((t) / 100) + (off))
+#define MILLICELSIUS_TO_DECI_KELVIN(t) MILLICELSIUS_TO_DECI_KELVIN_WITH_OFFSET(t, 2732)
 
 /* Default Thermal Governor */
 #if defined(CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE)
@@ -82,30 +81,6 @@ enum thermal_trend {
         THERMAL_TREND_DROP_FULL, /* apply lowest cooling action */
 };
 
-/* Events supported by Thermal Netlink */
-enum events {
-        THERMAL_AUX0,
-        THERMAL_AUX1,
-        THERMAL_CRITICAL,
-        THERMAL_DEV_FAULT,
-};
-
-/* attributes of thermal_genl_family */
-enum {
-        THERMAL_GENL_ATTR_UNSPEC,
-        THERMAL_GENL_ATTR_EVENT,
-        __THERMAL_GENL_ATTR_MAX,
-};
-#define THERMAL_GENL_ATTR_MAX (__THERMAL_GENL_ATTR_MAX - 1)
-
-/* commands supported by the thermal_genl_family */
-enum {
-        THERMAL_GENL_CMD_UNSPEC,
-        THERMAL_GENL_CMD_EVENT,
-        __THERMAL_GENL_CMD_MAX,
-};
-#define THERMAL_GENL_CMD_MAX (__THERMAL_GENL_CMD_MAX - 1)
-
 struct thermal_zone_device_ops {
         int (*bind) (struct thermal_zone_device *,
                      struct thermal_cooling_device *);
@@ -285,19 +260,49 @@ struct thermal_genl_event {
         enum events event;
 };
 
+/**
+ * struct thermal_zone_of_device_ops - scallbacks for handling DT based zones
+ *
+ * Mandatory:
+ * @get_temp: a pointer to a function that reads the sensor temperature.
+ *
+ * Optional:
+ * @get_trend: a pointer to a function that reads the sensor temperature trend.
+ * @set_emul_temp: a pointer to a function that sets sensor emulated
+ *                 temperature.
+ */
+struct thermal_zone_of_device_ops {
+        int (*get_temp)(void *, long *);
+        int (*get_trend)(void *, long *);
+        int (*set_emul_temp)(void *, unsigned long);
+};
+
+/**
+ * struct thermal_trip - representation of a point in temperature domain
+ * @np: pointer to struct device_node that this trip point was created from
+ * @temperature: temperature value in miliCelsius
+ * @hysteresis: relative hysteresis in miliCelsius
+ * @type: trip point type
+ */
+
+struct thermal_trip {
+        struct device_node *np;
+        unsigned long int temperature;
+        unsigned long int hysteresis;
+        enum thermal_trip_type type;
+};
+
 /* Function declarations */
 #ifdef CONFIG_THERMAL_OF
 struct thermal_zone_device *
-thermal_zone_of_sensor_register(struct device *dev, int id,
-                                void *data, int (*get_temp)(void *, long *),
-                                int (*get_trend)(void *, long *));
+thermal_zone_of_sensor_register(struct device *dev, int id, void *data,
+                                const struct thermal_zone_of_device_ops *ops);
 void thermal_zone_of_sensor_unregister(struct device *dev,
                                        struct thermal_zone_device *tz);
 #else
 static inline struct thermal_zone_device *
-thermal_zone_of_sensor_register(struct device *dev, int id,
-                                void *data, int (*get_temp)(void *, long *),
-                                int (*get_trend)(void *, long *))
+thermal_zone_of_sensor_register(struct device *dev, int id, void *data,
+                                const struct thermal_zone_of_device_ops *ops)
 {
         return NULL;
 }
diff --git a/include/linux/ti_wilink_st.h b/include/linux/ti_wilink_st.h
index 932b76392248..884d6263e962 100644
--- a/include/linux/ti_wilink_st.h
+++ b/include/linux/ti_wilink_st.h
@@ -268,7 +268,7 @@ struct kim_data_s {
         struct st_data_s *core_data;
         struct chip_version version;
         unsigned char ldisc_install;
-        unsigned char dev_name[UART_DEV_NAME_LEN];
+        unsigned char dev_name[UART_DEV_NAME_LEN + 1];
         unsigned char flow_cntrl;
         unsigned long baud_rate;
 };
diff --git a/include/linux/tick.h b/include/linux/tick.h
index 9a82c7dc3fdd..eda850ca757a 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -108,7 +108,7 @@ extern struct tick_sched *tick_get_tick_sched(int cpu);
 extern void tick_irq_enter(void);
 extern int tick_oneshot_mode_active(void);
 #  ifndef arch_needs_cpu
-#   define arch_needs_cpu(cpu) (0)
+#   define arch_needs_cpu() (0)
 #  endif
 # else
 static inline void tick_clock_notify(void) { }
@@ -181,14 +181,12 @@ static inline bool tick_nohz_full_cpu(int cpu)
         return cpumask_test_cpu(cpu, tick_nohz_full_mask);
 }
 
-extern void tick_nohz_init(void);
 extern void __tick_nohz_full_check(void);
 extern void tick_nohz_full_kick(void);
 extern void tick_nohz_full_kick_cpu(int cpu);
 extern void tick_nohz_full_kick_all(void);
 extern void __tick_nohz_task_switch(struct task_struct *tsk);
 #else
-static inline void tick_nohz_init(void) { }
 static inline bool tick_nohz_full_enabled(void) { return false; }
 static inline bool tick_nohz_full_cpu(int cpu) { return false; }
 static inline void __tick_nohz_full_check(void) { }
diff --git a/include/linux/time.h b/include/linux/time.h
index 8c42cf8d2444..203c2ad40d71 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -39,9 +39,20 @@ static inline int timeval_compare(const struct timeval *lhs, const struct timeva
         return lhs->tv_usec - rhs->tv_usec;
 }
 
-extern unsigned long mktime(const unsigned int year, const unsigned int mon,
-                            const unsigned int day, const unsigned int hour,
-                            const unsigned int min, const unsigned int sec);
+extern time64_t mktime64(const unsigned int year, const unsigned int mon,
+                        const unsigned int day, const unsigned int hour,
+                        const unsigned int min, const unsigned int sec);
+
+/**
+ * Deprecated. Use mktime64().
+ */
+static inline unsigned long mktime(const unsigned int year,
+                        const unsigned int mon, const unsigned int day,
+                        const unsigned int hour, const unsigned int min,
+                        const unsigned int sec)
+{
+        return mktime64(year, mon, day, hour, min, sec);
+}
 
 extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
 
diff --git a/include/linux/timekeeper_internal.h b/include/linux/timekeeper_internal.h
index 95640dcd1899..05af9a334893 100644
--- a/include/linux/timekeeper_internal.h
+++ b/include/linux/timekeeper_internal.h
@@ -42,6 +42,7 @@ struct tk_read_base {
  * struct timekeeper - Structure holding internal timekeeping values.
  * @tkr:                The readout base structure
  * @xtime_sec:          Current CLOCK_REALTIME time in seconds
+ * @ktime_sec:          Current CLOCK_MONOTONIC time in seconds
  * @wall_to_monotonic:  CLOCK_REALTIME to CLOCK_MONOTONIC offset
  * @offs_real:          Offset clock monotonic -> clock realtime
  * @offs_boot:          Offset clock monotonic -> clock boottime
@@ -77,6 +78,7 @@ struct tk_read_base {
 struct timekeeper {
         struct tk_read_base     tkr;
         u64                     xtime_sec;
+        unsigned long           ktime_sec;
         struct timespec64       wall_to_monotonic;
         ktime_t                 offs_real;
         ktime_t                 offs_boot;
diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index 1caa6b04fdc5..9b63d13ba82b 100644
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -10,7 +10,7 @@ extern int timekeeping_suspended;
  * Get and set timeofday
  */
 extern void do_gettimeofday(struct timeval *tv);
-extern int do_settimeofday(const struct timespec *tv);
+extern int do_settimeofday64(const struct timespec64 *ts);
 extern int do_sys_settimeofday(const struct timespec *tv,
                                const struct timezone *tz);
 
@@ -25,14 +25,24 @@ struct timespec __current_kernel_time(void);
 /*
  * timespec based interfaces
  */
-struct timespec get_monotonic_coarse(void);
-extern void getrawmonotonic(struct timespec *ts);
+struct timespec64 get_monotonic_coarse64(void);
+extern void getrawmonotonic64(struct timespec64 *ts);
 extern void ktime_get_ts64(struct timespec64 *ts);
+extern time64_t ktime_get_seconds(void);
+extern time64_t ktime_get_real_seconds(void);
 
 extern int __getnstimeofday64(struct timespec64 *tv);
 extern void getnstimeofday64(struct timespec64 *tv);
 
 #if BITS_PER_LONG == 64
+/**
+ * Deprecated. Use do_settimeofday64().
+ */
+static inline int do_settimeofday(const struct timespec *ts)
+{
+        return do_settimeofday64(ts);
+}
+
 static inline int __getnstimeofday(struct timespec *ts)
 {
         return __getnstimeofday64(ts);
@@ -53,7 +63,27 @@ static inline void ktime_get_real_ts(struct timespec *ts)
         getnstimeofday64(ts);
 }
 
+static inline void getrawmonotonic(struct timespec *ts)
+{
+        getrawmonotonic64(ts);
+}
+
+static inline struct timespec get_monotonic_coarse(void)
+{
+        return get_monotonic_coarse64();
+}
 #else
+/**
+ * Deprecated. Use do_settimeofday64().
+ */
+static inline int do_settimeofday(const struct timespec *ts)
+{
+        struct timespec64 ts64;
+
+        ts64 = timespec_to_timespec64(*ts);
+        return do_settimeofday64(&ts64);
+}
+
 static inline int __getnstimeofday(struct timespec *ts)
 {
         struct timespec64 ts64;
@@ -86,6 +116,19 @@ static inline void ktime_get_real_ts(struct timespec *ts)
         getnstimeofday64(&ts64);
         *ts = timespec64_to_timespec(ts64);
 }
+
+static inline void getrawmonotonic(struct timespec *ts)
+{
+        struct timespec64 ts64;
+
+        getrawmonotonic64(&ts64);
+        *ts = timespec64_to_timespec(ts64);
+}
+
+static inline struct timespec get_monotonic_coarse(void)
+{
+        return timespec64_to_timespec(get_monotonic_coarse64());
+}
 #endif
 
 extern void getboottime(struct timespec *ts);
@@ -182,7 +225,7 @@ static inline void timekeeping_clocktai(struct timespec *ts)
 /*
  * RTC specific
  */
-extern void timekeeping_inject_sleeptime(struct timespec *delta);
+extern void timekeeping_inject_sleeptime64(struct timespec64 *delta);
 
 /*
  * PPS accessor
diff --git a/include/linux/topology.h b/include/linux/topology.h
index dda6ee521e74..909b6e43b694 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -119,11 +119,20 @@ static inline int numa_node_id(void)
  * Use the accessor functions set_numa_mem(), numa_mem_id() and cpu_to_mem().
  */
 DECLARE_PER_CPU(int, _numa_mem_);
+extern int _node_numa_mem_[MAX_NUMNODES];
 
 #ifndef set_numa_mem
 static inline void set_numa_mem(int node)
 {
         this_cpu_write(_numa_mem_, node);
+        _node_numa_mem_[numa_node_id()] = node;
+}
+#endif
+
+#ifndef node_to_mem_node
+static inline int node_to_mem_node(int node)
+{
+        return _node_numa_mem_[node];
 }
 #endif
 
@@ -146,6 +155,7 @@ static inline int cpu_to_mem(int cpu)
 static inline void set_cpu_numa_mem(int cpu, int node)
 {
         per_cpu(_numa_mem_, cpu) = node;
+        _node_numa_mem_[cpu_to_node(cpu)] = node;
 }
 #endif
 
@@ -159,6 +169,13 @@ static inline int numa_mem_id(void)
 }
 #endif
 
+#ifndef node_to_mem_node
+static inline int node_to_mem_node(int node)
+{
+        return node;
+}
+#endif
+
 #ifndef cpu_to_mem
 static inline int cpu_to_mem(int cpu)
 {
diff --git a/include/linux/torture.h b/include/linux/torture.h
index 5ca58fcbaf1b..7759fc3c622d 100644
--- a/include/linux/torture.h
+++ b/include/linux/torture.h
@@ -51,7 +51,7 @@
 
 /* Definitions for online/offline exerciser. */
 int torture_onoff_init(long ooholdoff, long oointerval);
-char *torture_onoff_stats(char *page);
+void torture_onoff_stats(void);
 bool torture_onoff_failures(void);
 
 /* Low-rider random number generator. */
@@ -77,7 +77,8 @@ int torture_stutter_init(int s);
 /* Initialization and cleanup. */
 bool torture_init_begin(char *ttype, bool v, int *runnable);
 void torture_init_end(void);
-bool torture_cleanup(void);
+bool torture_cleanup_begin(void);
+void torture_cleanup_end(void);
 bool torture_must_stop(void);
 bool torture_must_stop_irq(void);
 void torture_kthread_stopping(char *title);
diff --git a/include/linux/trace_seq.h b/include/linux/trace_seq.h
index ea6c9dea79e3..cfaf5a1d4bad 100644
--- a/include/linux/trace_seq.h
+++ b/include/linux/trace_seq.h
@@ -1,7 +1,7 @@
 #ifndef _LINUX_TRACE_SEQ_H
 #define _LINUX_TRACE_SEQ_H
 
-#include <linux/fs.h>
+#include <linux/seq_buf.h>
 
 #include <asm/page.h>
 
@@ -12,20 +12,36 @@
 
 struct trace_seq {
         unsigned char           buffer[PAGE_SIZE];
-        unsigned int            len;
-        unsigned int            readpos;
+        struct seq_buf          seq;
         int                     full;
 };
 
 static inline void
 trace_seq_init(struct trace_seq *s)
 {
-        s->len = 0;
-        s->readpos = 0;
+        seq_buf_init(&s->seq, s->buffer, PAGE_SIZE);
         s->full = 0;
 }
 
 /**
+ * trace_seq_used - amount of actual data written to buffer
+ * @s: trace sequence descriptor
+ *
+ * Returns the amount of data written to the buffer.
+ *
+ * IMPORTANT!
+ *
+ * Use this instead of @s->seq.len if you need to pass the amount
+ * of data from the buffer to another buffer (userspace, or what not).
+ * The @s->seq.len on overflow is bigger than the buffer size and
+ * using it can cause access to undefined memory.
+ */
+static inline int trace_seq_used(struct trace_seq *s)
+{
+        return seq_buf_used(&s->seq);
+}
+
+/**
  * trace_seq_buffer_ptr - return pointer to next location in buffer
  * @s: trace sequence descriptor
  *
@@ -37,7 +53,19 @@ trace_seq_init(struct trace_seq *s)
 static inline unsigned char *
 trace_seq_buffer_ptr(struct trace_seq *s)
 {
-        return s->buffer + s->len;
+        return s->buffer + seq_buf_used(&s->seq);
+}
+
+/**
+ * trace_seq_has_overflowed - return true if the trace_seq took too much
+ * @s: trace sequence descriptor
+ *
+ * Returns true if too much data was added to the trace_seq and it is
+ * now full and will not take anymore.
+ */
+static inline bool trace_seq_has_overflowed(struct trace_seq *s)
+{
+        return s->full || seq_buf_has_overflowed(&s->seq);
 }
 
 /*
@@ -45,40 +73,37 @@ trace_seq_buffer_ptr(struct trace_seq *s)
  */
 #ifdef CONFIG_TRACING
 extern __printf(2, 3)
-int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
+void trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
 extern __printf(2, 0)
-int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args);
-extern int
+void trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args);
+extern void
 trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary);
 extern int trace_print_seq(struct seq_file *m, struct trace_seq *s);
 extern int trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
                              int cnt);
-extern int trace_seq_puts(struct trace_seq *s, const char *str);
-extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
-extern int trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len);
-extern int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
+extern void trace_seq_puts(struct trace_seq *s, const char *str);
+extern void trace_seq_putc(struct trace_seq *s, unsigned char c);
+extern void trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len);
+extern void trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
                                 unsigned int len);
 extern int trace_seq_path(struct trace_seq *s, const struct path *path);
 
-extern int trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
+extern void trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
                              int nmaskbits);
 
 #else /* CONFIG_TRACING */
-static inline int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+static inline void trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
 {
-        return 0;
 }
-static inline int
+static inline void
 trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
 {
-        return 0;
 }
 
-static inline int
+static inline void
 trace_seq_bitmask(struct trace_seq *s, const unsigned long *maskp,
                   int nmaskbits)
 {
-        return 0;
 }
 
 static inline int trace_print_seq(struct seq_file *m, struct trace_seq *s)
@@ -90,23 +115,19 @@ static inline int trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
 {
         return 0;
 }
-static inline int trace_seq_puts(struct trace_seq *s, const char *str)
+static inline void trace_seq_puts(struct trace_seq *s, const char *str)
 {
-        return 0;
 }
-static inline int trace_seq_putc(struct trace_seq *s, unsigned char c)
+static inline void trace_seq_putc(struct trace_seq *s, unsigned char c)
 {
-        return 0;
 }
-static inline int
+static inline void
 trace_seq_putmem(struct trace_seq *s, const void *mem, unsigned int len)
 {
-        return 0;
 }
-static inline int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
+static inline void trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
                                        unsigned int len)
 {
-        return 0;
 }
 static inline int trace_seq_path(struct trace_seq *s, const struct path *path)
 {
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index b1293f15f592..e08e21e5f601 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -157,6 +157,12 @@ extern void syscall_unregfunc(void);
  * Make sure the alignment of the structure in the __tracepoints section will
  * not add unwanted padding between the beginning of the section and the
  * structure. Force alignment to the same alignment as the section start.
+ *
+ * When lockdep is enabled, we make sure to always do the RCU portions of
+ * the tracepoint code, regardless of whether tracing is on or we match the
+ * condition.  This lets us find RCU issues triggered with tracepoints even
+ * when this tracepoint is off.  This code has no purpose other than poking
+ * RCU a bit.
  */
 #define __DECLARE_TRACE(name, proto, args, cond, data_proto, data_args) \
         extern struct tracepoint __tracepoint_##name;                   \
@@ -167,6 +173,11 @@ extern void syscall_unregfunc(void);
                                 TP_PROTO(data_proto),                   \
                                 TP_ARGS(data_args),                     \
                                 TP_CONDITION(cond),,);                  \
+                if (IS_ENABLED(CONFIG_LOCKDEP)) {                       \
+                        rcu_read_lock_sched_notrace();                  \
+                        rcu_dereference_sched(__tracepoint_##name.funcs);\
+                        rcu_read_unlock_sched_notrace();                \
+                }                                                       \
         }                                                               \
         __DECLARE_TRACE_RCU(name, PARAMS(proto), PARAMS(args),          \
                 PARAMS(cond), PARAMS(data_proto), PARAMS(data_args))    \
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 84132942902a..7d66ae508e5c 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -252,6 +252,7 @@ struct tty_struct {
         struct rw_semaphore termios_rwsem;
         struct mutex winsize_mutex;
         spinlock_t ctrl_lock;
+        spinlock_t flow_lock;
         /* Termios values are protected by the termios rwsem */
         struct ktermios termios, termios_locked;
         struct termiox *termiox;        /* May be NULL for unsupported */
@@ -261,8 +262,13 @@ struct tty_struct {
         unsigned long flags;
         int count;
         struct winsize winsize;         /* winsize_mutex */
-        unsigned char stopped:1, hw_stopped:1, flow_stopped:1, packet:1;
-        unsigned char ctrl_status;      /* ctrl_lock */
+        unsigned long stopped:1,        /* flow_lock */
+                      flow_stopped:1,
+                      unused:BITS_PER_LONG - 2;
+        int hw_stopped;
+        unsigned long ctrl_status:8,    /* ctrl_lock */
+                      packet:1,
+                      unused_ctrl:BITS_PER_LONG - 9;
         unsigned int receive_room;      /* Bytes free for queue */
         int flow_change;
 
@@ -278,7 +284,7 @@ struct tty_struct {
 
 #define N_TTY_BUF_SIZE 4096
 
-        unsigned char closing:1;
+        int closing;
         unsigned char *write_buf;
         int write_cnt;
         /* If the tty has a pending do_SAK, queue it here - akpm */
@@ -310,12 +316,10 @@ struct tty_file_private {
 #define TTY_EXCLUSIVE           3       /* Exclusive open mode */
 #define TTY_DEBUG               4       /* Debugging */
 #define TTY_DO_WRITE_WAKEUP     5       /* Call write_wakeup after queuing new */
-#define TTY_CLOSING             7       /* ->close() in progress */
 #define TTY_LDISC_OPEN          11      /* Line discipline is open */
 #define TTY_PTY_LOCK            16      /* pty private */
 #define TTY_NO_WRITE_SPLIT      17      /* Preserve write boundaries to driver */
 #define TTY_HUPPED              18      /* Post driver->hangup() */
-#define TTY_HUPPING             21      /* ->hangup() in progress */
 #define TTY_LDISC_HALTED        22      /* Line discipline is halted */
 
 #define TTY_WRITE_FLUSH(tty) tty_write_flush((tty))
@@ -397,7 +401,9 @@ extern int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
 extern char *tty_name(struct tty_struct *tty, char *buf);
 extern void tty_wait_until_sent(struct tty_struct *tty, long timeout);
 extern int tty_check_change(struct tty_struct *tty);
+extern void __stop_tty(struct tty_struct *tty);
 extern void stop_tty(struct tty_struct *tty);
+extern void __start_tty(struct tty_struct *tty);
 extern void start_tty(struct tty_struct *tty);
 extern int tty_register_driver(struct tty_driver *driver);
 extern int tty_unregister_driver(struct tty_driver *driver);
@@ -411,6 +417,7 @@ extern void tty_unregister_device(struct tty_driver *driver, unsigned index);
 extern int tty_read_raw_data(struct tty_struct *tty, unsigned char *bufp,
                              int buflen);
 extern void tty_write_message(struct tty_struct *tty, char *msg);
+extern int tty_send_xchar(struct tty_struct *tty, char ch);
 extern int tty_put_char(struct tty_struct *tty, unsigned char c);
 extern int tty_chars_in_buffer(struct tty_struct *tty);
 extern int tty_write_room(struct tty_struct *tty);
@@ -428,14 +435,13 @@ extern int is_ignored(int sig);
 extern int tty_signal(int sig, struct tty_struct *tty);
 extern void tty_hangup(struct tty_struct *tty);
 extern void tty_vhangup(struct tty_struct *tty);
-extern void tty_unhangup(struct file *filp);
 extern int tty_hung_up_p(struct file *filp);
 extern void do_SAK(struct tty_struct *tty);
 extern void __do_SAK(struct tty_struct *tty);
 extern void no_tty(void);
 extern void tty_flush_to_ldisc(struct tty_struct *tty);
 extern void tty_buffer_free_all(struct tty_port *port);
-extern void tty_buffer_flush(struct tty_struct *tty);
+extern void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld);
 extern void tty_buffer_init(struct tty_port *port);
 extern speed_t tty_termios_baud_rate(struct ktermios *termios);
 extern speed_t tty_termios_input_baud_rate(struct ktermios *termios);
@@ -489,14 +495,9 @@ extern int tty_init_termios(struct tty_struct *tty);
 extern int tty_standard_install(struct tty_driver *driver,
                 struct tty_struct *tty);
 
-extern struct tty_struct *tty_pair_get_tty(struct tty_struct *tty);
-extern struct tty_struct *tty_pair_get_pty(struct tty_struct *tty);
-
 extern struct mutex tty_mutex;
 extern spinlock_t tty_files_lock;
 
-extern void tty_write_unlock(struct tty_struct *tty);
-extern int tty_write_lock(struct tty_struct *tty, int ndelay);
 #define tty_is_writelocked(tty)  (mutex_is_locked(&tty->atomic_write_lock))
 
 extern void tty_port_init(struct tty_port *port);
@@ -555,7 +556,7 @@ extern int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc);
 extern int tty_unregister_ldisc(int disc);
 extern int tty_set_ldisc(struct tty_struct *tty, int ldisc);
 extern int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty);
-extern void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty);
+extern void tty_ldisc_release(struct tty_struct *tty);
 extern void tty_ldisc_init(struct tty_struct *tty);
 extern void tty_ldisc_deinit(struct tty_struct *tty);
 extern void tty_ldisc_begin(void);
@@ -616,14 +617,6 @@ extern int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
 extern long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
                        unsigned int cmd, unsigned long arg);
 
-/* serial.c */
-
-extern void serial_console_init(void);
-
-/* pcxx.c */
-
-extern int pcxe_open(struct tty_struct *tty, struct file *filp);
-
 /* vt.c */
 
 extern int vt_ioctl(struct tty_struct *tty,
@@ -636,11 +629,9 @@ extern long vt_compat_ioctl(struct tty_struct *tty,
 /* functions for preparation of BKL removal */
 extern void __lockfunc tty_lock(struct tty_struct *tty);
 extern void __lockfunc tty_unlock(struct tty_struct *tty);
-extern void __lockfunc tty_lock_pair(struct tty_struct *tty,
-                                struct tty_struct *tty2);
-extern void __lockfunc tty_unlock_pair(struct tty_struct *tty,
-                                struct tty_struct *tty2);
-
+extern void __lockfunc tty_lock_slave(struct tty_struct *tty);
+extern void __lockfunc tty_unlock_slave(struct tty_struct *tty);
+extern void tty_set_lock_subclass(struct tty_struct *tty);
 /*
  * this shall be called only from where BTM is held (like close)
  *
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index e48c608a8fa8..92e337c18839 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -152,6 +152,8 @@
  *      This routine notifies the tty driver that it should stop
  *      outputting characters to the tty device.  
  *
+ *      Called with ->flow_lock held. Serialized with start() method.
+ *
  *      Optional:
  *
  *      Note: Call stop_tty not this method.
@@ -161,6 +163,8 @@
  *      This routine notifies the tty driver that it resume sending
  *      characters to the tty device.
  *
+ *      Called with ->flow_lock held. Serialized with stop() method.
+ *
  *      Optional:
  *
  *      Note: Call start_tty not this method.
diff --git a/include/linux/udp.h b/include/linux/udp.h
index 247cfdcc4b08..ee3277593222 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -49,7 +49,11 @@ struct udp_sock {
         unsigned int     corkflag;      /* Cork is required */
         __u8             encap_type;    /* Is this an Encapsulation socket? */
         unsigned char    no_check6_tx:1,/* Send zero UDP6 checksums on TX? */
-                         no_check6_rx:1;/* Allow zero UDP6 checksums on RX? */
+                         no_check6_rx:1,/* Allow zero UDP6 checksums on RX? */
+                         convert_csum:1;/* On receive, convert checksum
+                                         * unnecessary to checksum complete
+                                         * if possible.
+                                         */
         /*
          * Following member retains the information to create a UDP header
          * when the socket is uncorked.
@@ -98,6 +102,16 @@ static inline bool udp_get_no_check6_rx(struct sock *sk)
         return udp_sk(sk)->no_check6_rx;
 }
 
+static inline void udp_set_convert_csum(struct sock *sk, bool val)
+{
+        udp_sk(sk)->convert_csum = val;
+}
+
+static inline bool udp_get_convert_csum(struct sock *sk)
+{
+        return udp_sk(sk)->convert_csum;
+}
+
 #define udp_portaddr_for_each_entry(__sk, node, list) \
         hlist_nulls_for_each_entry(__sk, node, list, __sk_common.skc_portaddr_node)
 
diff --git a/include/linux/uio.h b/include/linux/uio.h
index 290fbf0b6b8a..1c5e453f7ea9 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -31,6 +31,7 @@ struct iov_iter {
         size_t count;
         union {
                 const struct iovec *iov;
+                const struct kvec *kvec;
                 const struct bio_vec *bvec;
         };
         unsigned long nr_segs;
@@ -80,9 +81,15 @@ size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
                          struct iov_iter *i);
 size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
                          struct iov_iter *i);
+size_t copy_to_iter(void *addr, size_t bytes, struct iov_iter *i);
+size_t copy_from_iter(void *addr, size_t bytes, struct iov_iter *i);
+size_t copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i);
+size_t iov_iter_zero(size_t bytes, struct iov_iter *);
 unsigned long iov_iter_alignment(const struct iov_iter *i);
 void iov_iter_init(struct iov_iter *i, int direction, const struct iovec *iov,
                         unsigned long nr_segs, size_t count);
+void iov_iter_kvec(struct iov_iter *i, int direction, const struct kvec *iov,
+                        unsigned long nr_segs, size_t count);
 ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages,
                         size_t maxsize, unsigned maxpages, size_t *start);
 ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,
@@ -94,6 +101,11 @@ static inline size_t iov_iter_count(struct iov_iter *i)
         return i->count;
 }
 
+static inline bool iter_is_iovec(struct iov_iter *i)
+{
+        return !(i->type & (ITER_BVEC | ITER_KVEC));
+}
+
 /*
  * Cap the iov_iter by given limit; note that the second argument is
  * *not* the new size - it's upper limit for such.  Passing it a value
@@ -120,9 +132,10 @@ static inline void iov_iter_reexpand(struct iov_iter *i, size_t count)
 {
         i->count = count;
 }
+size_t csum_and_copy_to_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
+size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
 
 int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
-int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len);
 int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
                         int offset, int len);
 int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata,
diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
index 1ad4724458de..32c0e83d6239 100644
--- a/include/linux/uio_driver.h
+++ b/include/linux/uio_driver.h
@@ -35,7 +35,7 @@ struct uio_map;
 struct uio_mem {
         const char              *name;
         phys_addr_t             addr;
-        unsigned long           size;
+        resource_size_t         size;
         int                     memtype;
         void __iomem            *internal_addr;
         struct uio_map          *map;
@@ -63,7 +63,17 @@ struct uio_port {
 
 #define MAX_UIO_PORT_REGIONS    5
 
-struct uio_device;
+struct uio_device {
+        struct module           *owner;
+        struct device           *dev;
+        int                     minor;
+        atomic_t                event;
+        struct fasync_struct    *async_queue;
+        wait_queue_head_t       wait;
+        struct uio_info         *info;
+        struct kobject          *map_dir;
+        struct kobject          *portio_dir;
+};
 
 /**
  * struct uio_info - UIO device capabilities
diff --git a/include/linux/uprobes.h b/include/linux/uprobes.h
index 4f844c6b03ee..60beb5dc7977 100644
--- a/include/linux/uprobes.h
+++ b/include/linux/uprobes.h
@@ -98,11 +98,11 @@ struct uprobes_state {
         struct xol_area         *xol_area;
 };
 
-extern int __weak set_swbp(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);
-extern int __weak set_orig_insn(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);
-extern bool __weak is_swbp_insn(uprobe_opcode_t *insn);
-extern bool __weak is_trap_insn(uprobe_opcode_t *insn);
-extern unsigned long __weak uprobe_get_swbp_addr(struct pt_regs *regs);
+extern int set_swbp(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);
+extern int set_orig_insn(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);
+extern bool is_swbp_insn(uprobe_opcode_t *insn);
+extern bool is_trap_insn(uprobe_opcode_t *insn);
+extern unsigned long uprobe_get_swbp_addr(struct pt_regs *regs);
 extern unsigned long uprobe_get_trap_addr(struct pt_regs *regs);
 extern int uprobe_write_opcode(struct mm_struct *mm, unsigned long vaddr, uprobe_opcode_t);
 extern int uprobe_register(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
@@ -128,8 +128,8 @@ extern bool arch_uprobe_xol_was_trapped(struct task_struct *tsk);
 extern int  arch_uprobe_exception_notify(struct notifier_block *self, unsigned long val, void *data);
 extern void arch_uprobe_abort_xol(struct arch_uprobe *aup, struct pt_regs *regs);
 extern unsigned long arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr, struct pt_regs *regs);
-extern bool __weak arch_uprobe_ignore(struct arch_uprobe *aup, struct pt_regs *regs);
-extern void __weak arch_uprobe_copy_ixol(struct page *page, unsigned long vaddr,
+extern bool arch_uprobe_ignore(struct arch_uprobe *aup, struct pt_regs *regs);
+extern void arch_uprobe_copy_ixol(struct page *page, unsigned long vaddr,
                                          void *src, unsigned long len);
 #else /* !CONFIG_UPROBES */
 struct uprobes_state {
diff --git a/include/linux/usb.h b/include/linux/usb.h
index d2465bc0e73c..f89c24a03bd9 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -637,7 +637,7 @@ static inline bool usb_acpi_power_manageable(struct usb_device *hdev, int index)
 #endif
 
 /* USB autosuspend and autoresume */
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
 extern void usb_enable_autosuspend(struct usb_device *udev);
 extern void usb_disable_autosuspend(struct usb_device *udev);
 
@@ -1862,6 +1862,18 @@ extern void usb_unregister_notify(struct notifier_block *nb);
 /* debugfs stuff */
 extern struct dentry *usb_debug_root;
 
+/* LED triggers */
+enum usb_led_event {
+        USB_LED_EVENT_HOST = 0,
+        USB_LED_EVENT_GADGET = 1,
+};
+
+#ifdef CONFIG_USB_LED_TRIG
+extern void usb_led_activity(enum usb_led_event ev);
+#else
+static inline void usb_led_activity(enum usb_led_event ev) {}
+#endif
+
 #endif  /* __KERNEL__ */
 
 #endif
diff --git a/include/linux/usb/chipidea.h b/include/linux/usb/chipidea.h
index bbe779f640be..535997a6681b 100644
--- a/include/linux/usb/chipidea.h
+++ b/include/linux/usb/chipidea.h
@@ -13,11 +13,12 @@ struct ci_hdrc_platform_data {
         /* offset of the capability registers */
         uintptr_t        capoffset;
         unsigned         power_budget;
-        struct usb_phy  *phy;
+        struct phy      *phy;
+        /* old usb_phy interface */
+        struct usb_phy  *usb_phy;
         enum usb_phy_interface phy_mode;
         unsigned long    flags;
 #define CI_HDRC_REGS_SHARED             BIT(0)
-#define CI_HDRC_REQUIRE_TRANSCEIVER     BIT(1)
 #define CI_HDRC_DISABLE_STREAMING       BIT(3)
         /*
          * Only set it when DCCPARAMS.DC==1 and DCCPARAMS.HC==1,
@@ -31,6 +32,7 @@ struct ci_hdrc_platform_data {
 #define CI_HDRC_CONTROLLER_STOPPED_EVENT        1
         void    (*notify_event) (struct ci_hdrc *ci, unsigned event);
         struct regulator        *reg_vbus;
+        bool                    tpl_support;
 };
 
 /* Default offset of capability registers */
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index c330f5ef42cf..3d87defcc527 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -427,6 +427,8 @@ static inline struct usb_composite_driver *to_cdriver(
  * @b_vendor_code: bMS_VendorCode part of the OS string
  * @use_os_string: false by default, interested gadgets set it
  * @os_desc_config: the configuration to be used with OS descriptors
+ * @setup_pending: true when setup request is queued but not completed
+ * @os_desc_pending: true when os_desc request is queued but not completed
  *
  * One of these devices is allocated and initialized before the
  * associated device driver's bind() is called.
@@ -488,6 +490,9 @@ struct usb_composite_dev {
 
         /* protects deactivations and delayed_status counts*/
         spinlock_t                      lock;
+
+        unsigned                        setup_pending:1;
+        unsigned                        os_desc_pending:1;
 };
 
 extern int usb_string_id(struct usb_composite_dev *c);
@@ -501,6 +506,8 @@ extern int usb_string_ids_n(struct usb_composite_dev *c, unsigned n);
 extern void composite_disconnect(struct usb_gadget *gadget);
 extern int composite_setup(struct usb_gadget *gadget,
                 const struct usb_ctrlrequest *ctrl);
+extern void composite_suspend(struct usb_gadget *gadget);
+extern void composite_resume(struct usb_gadget *gadget);
 
 /*
  * Some systems will need runtime overrides for the  product identifiers
diff --git a/include/linux/usb/ehci-dbgp.h b/include/linux/usb/ehci-dbgp.h
new file mode 100644
index 000000000000..7344d9e591cc
--- /dev/null
+++ b/include/linux/usb/ehci-dbgp.h
@@ -0,0 +1,83 @@
+/*
+ * Standalone EHCI usb debug driver
+ *
+ * Originally written by:
+ *  Eric W. Biederman" <ebiederm@xmission.com> and
+ *  Yinghai Lu <yhlu.kernel@gmail.com>
+ *
+ * Changes for early/late printk and HW errata:
+ *  Jason Wessel <jason.wessel@windriver.com>
+ *  Copyright (C) 2009 Wind River Systems, Inc.
+ *
+ */
+
+#ifndef __LINUX_USB_EHCI_DBGP_H
+#define __LINUX_USB_EHCI_DBGP_H
+
+#include <linux/console.h>
+#include <linux/types.h>
+
+/* Appendix C, Debug port ... intended for use with special "debug devices"
+ * that can help if there's no serial console.  (nonstandard enumeration.)
+ */
+struct ehci_dbg_port {
+        u32     control;
+#define DBGP_OWNER      (1<<30)
+#define DBGP_ENABLED    (1<<28)
+#define DBGP_DONE       (1<<16)
+#define DBGP_INUSE      (1<<10)
+#define DBGP_ERRCODE(x) (((x)>>7)&0x07)
+#       define DBGP_ERR_BAD     1
+#       define DBGP_ERR_SIGNAL  2
+#define DBGP_ERROR      (1<<6)
+#define DBGP_GO         (1<<5)
+#define DBGP_OUT        (1<<4)
+#define DBGP_LEN(x)     (((x)>>0)&0x0f)
+        u32     pids;
+#define DBGP_PID_GET(x)         (((x)>>16)&0xff)
+#define DBGP_PID_SET(data, tok) (((data)<<8)|(tok))
+        u32     data03;
+        u32     data47;
+        u32     address;
+#define DBGP_EPADDR(dev, ep)    (((dev)<<8)|(ep))
+};
+
+#ifdef CONFIG_EARLY_PRINTK_DBGP
+extern int early_dbgp_init(char *s);
+extern struct console early_dbgp_console;
+#endif /* CONFIG_EARLY_PRINTK_DBGP */
+
+struct usb_hcd;
+
+#ifdef CONFIG_XEN_DOM0
+extern int xen_dbgp_reset_prep(struct usb_hcd *);
+extern int xen_dbgp_external_startup(struct usb_hcd *);
+#else
+static inline int xen_dbgp_reset_prep(struct usb_hcd *hcd)
+{
+        return 1; /* Shouldn't this be 0? */
+}
+
+static inline int xen_dbgp_external_startup(struct usb_hcd *hcd)
+{
+        return -1;
+}
+#endif
+
+#ifdef CONFIG_EARLY_PRINTK_DBGP
+/* Call backs from ehci host driver to ehci debug driver */
+extern int dbgp_external_startup(struct usb_hcd *);
+extern int dbgp_reset_prep(struct usb_hcd *);
+#else
+static inline int dbgp_reset_prep(struct usb_hcd *hcd)
+{
+        return xen_dbgp_reset_prep(hcd);
+}
+
+static inline int dbgp_external_startup(struct usb_hcd *hcd)
+{
+        return xen_dbgp_external_startup(hcd);
+}
+#endif
+
+#endif /* __LINUX_USB_EHCI_DBGP_H */
diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
index daec99af5d54..966889a20ea3 100644
--- a/include/linux/usb/ehci_def.h
+++ b/include/linux/usb/ehci_def.h
@@ -19,6 +19,8 @@
 #ifndef __LINUX_USB_EHCI_DEF_H
 #define __LINUX_USB_EHCI_DEF_H
 
+#include <linux/usb/ehci-dbgp.h>
+
 /* EHCI register interface, corresponds to EHCI Revision 0.95 specification */
 
 /* Section 2.2 Host Controller Capability Registers */
@@ -190,67 +192,4 @@ struct ehci_regs {
 #define USBMODE_EX_HC   (3<<0)          /* host controller mode */
 };
 
-/* Appendix C, Debug port ... intended for use with special "debug devices"
- * that can help if there's no serial console.  (nonstandard enumeration.)
- */
-struct ehci_dbg_port {
-        u32     control;
-#define DBGP_OWNER      (1<<30)
-#define DBGP_ENABLED    (1<<28)
-#define DBGP_DONE       (1<<16)
-#define DBGP_INUSE      (1<<10)
-#define DBGP_ERRCODE(x) (((x)>>7)&0x07)
-#       define DBGP_ERR_BAD     1
-#       define DBGP_ERR_SIGNAL  2
-#define DBGP_ERROR      (1<<6)
-#define DBGP_GO         (1<<5)
-#define DBGP_OUT        (1<<4)
-#define DBGP_LEN(x)     (((x)>>0)&0x0f)
-        u32     pids;
-#define DBGP_PID_GET(x)         (((x)>>16)&0xff)
-#define DBGP_PID_SET(data, tok) (((data)<<8)|(tok))
-        u32     data03;
-        u32     data47;
-        u32     address;
-#define DBGP_EPADDR(dev, ep)    (((dev)<<8)|(ep))
-};
-
-#ifdef CONFIG_EARLY_PRINTK_DBGP
-#include <linux/init.h>
-extern int __init early_dbgp_init(char *s);
-extern struct console early_dbgp_console;
-#endif /* CONFIG_EARLY_PRINTK_DBGP */
-
-struct usb_hcd;
-
-#ifdef CONFIG_XEN_DOM0
-extern int xen_dbgp_reset_prep(struct usb_hcd *);
-extern int xen_dbgp_external_startup(struct usb_hcd *);
-#else
-static inline int xen_dbgp_reset_prep(struct usb_hcd *hcd)
-{
-        return 1; /* Shouldn't this be 0? */
-}
-
-static inline int xen_dbgp_external_startup(struct usb_hcd *hcd)
-{
-        return -1;
-}
-#endif
-
-#ifdef CONFIG_EARLY_PRINTK_DBGP
-/* Call backs from ehci host driver to ehci debug driver */
-extern int dbgp_external_startup(struct usb_hcd *);
-extern int dbgp_reset_prep(struct usb_hcd *hcd);
-#else
-static inline int dbgp_reset_prep(struct usb_hcd *hcd)
-{
-        return xen_dbgp_reset_prep(hcd);
-}
-static inline int dbgp_external_startup(struct usb_hcd *hcd)
-{
-        return xen_dbgp_external_startup(hcd);
-}
-#endif
-
 #endif /* __LINUX_USB_EHCI_DEF_H */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index c3a61853cd13..70ddb3943b62 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -345,12 +345,13 @@ static inline int usb_ep_queue(struct usb_ep *ep,
  * @ep:the endpoint associated with the request
  * @req:the request being canceled
  *
- * if the request is still active on the endpoint, it is dequeued and its
+ * If the request is still active on the endpoint, it is dequeued and its
  * completion routine is called (with status -ECONNRESET); else a negative
- * error code is returned.
+ * error code is returned. This is guaranteed to happen before the call to
+ * usb_ep_dequeue() returns.
  *
- * note that some hardware can't clear out write fifos (to unlink the request
- * at the head of the queue) except as part of disconnecting from usb.  such
+ * Note that some hardware can't clear out write fifos (to unlink the request
+ * at the head of the queue) except as part of disconnecting from usb. Such
  * restrictions prevent drivers from supporting configuration changes,
  * even to configuration zero (a "chapter 9" requirement).
  */
@@ -489,8 +490,7 @@ struct usb_gadget_ops {
         void    (*get_config_params)(struct usb_dcd_config_params *);
         int     (*udc_start)(struct usb_gadget *,
                         struct usb_gadget_driver *);
-        int     (*udc_stop)(struct usb_gadget *,
-                        struct usb_gadget_driver *);
+        int     (*udc_stop)(struct usb_gadget *);
 };
 
 /**
@@ -816,6 +816,8 @@ static inline int usb_gadget_disconnect(struct usb_gadget *gadget)
  *      Called in a context that permits sleeping.
  * @suspend: Invoked on USB suspend.  May be called in_interrupt.
  * @resume: Invoked on USB resume.  May be called in_interrupt.
+ * @reset: Invoked on USB bus reset. It is mandatory for all gadget drivers
+ *      and should be called in_interrupt.
  * @driver: Driver model state for this driver.
  *
  * Devices are disabled till a gadget driver successfully bind()s, which
@@ -873,6 +875,7 @@ struct usb_gadget_driver {
         void                    (*disconnect)(struct usb_gadget *);
         void                    (*suspend)(struct usb_gadget *);
         void                    (*resume)(struct usb_gadget *);
+        void                    (*reset)(struct usb_gadget *);
 
         /* FIXME support safe rmmod */
         struct device_driver    driver;
@@ -921,7 +924,7 @@ extern int usb_add_gadget_udc_release(struct device *parent,
                 struct usb_gadget *gadget, void (*release)(struct device *dev));
 extern int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget);
 extern void usb_del_gadget_udc(struct usb_gadget *gadget);
-extern int udc_attach_driver(const char *name,
+extern int usb_udc_attach_driver(const char *name,
                 struct usb_gadget_driver *driver);
 
 /*-------------------------------------------------------------------------*/
@@ -1013,6 +1016,20 @@ extern void usb_gadget_set_state(struct usb_gadget *gadget,
 
 /*-------------------------------------------------------------------------*/
 
+/* utility to tell udc core that the bus reset occurs */
+extern void usb_gadget_udc_reset(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver);
+
+/*-------------------------------------------------------------------------*/
+
+/* utility to give requests back to the gadget layer */
+
+extern void usb_gadget_giveback_request(struct usb_ep *ep,
+                struct usb_request *req);
+
+
+/*-------------------------------------------------------------------------*/
+
 /* utility wrapping a simple endpoint selection policy */
 
 extern struct usb_ep *usb_ep_autoconfig(struct usb_gadget *,
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 485cd5e2100c..086bf13307e6 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -93,7 +93,7 @@ struct usb_hcd {
 
         struct timer_list       rh_timer;       /* drives root-hub polling */
         struct urb              *status_urb;    /* the current status urb */
-#ifdef CONFIG_PM_RUNTIME
+#ifdef CONFIG_PM
         struct work_struct      wakeup_work;    /* for remote wakeup */
 #endif
 
@@ -106,7 +106,8 @@ struct usb_hcd {
          * OTG and some Host controllers need software interaction with phys;
          * other external phys should be software-transparent
          */
-        struct usb_phy  *phy;
+        struct usb_phy          *usb_phy;
+        struct phy              *phy;
 
         /* Flags that need to be manipulated atomically because they can
          * change while the host controller is running.  Always use
@@ -144,6 +145,7 @@ struct usb_hcd {
         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                tpl_support:1; /* OTG & EH TPL support */
 
         unsigned int            irq;            /* irq allocated */
         void __iomem            *regs;          /* device memory/io */
@@ -377,6 +379,9 @@ struct hc_driver {
         int     (*disable_usb3_lpm_timeout)(struct usb_hcd *,
                         struct usb_device *, enum usb3_link_state state);
         int     (*find_raw_port_number)(struct usb_hcd *, int);
+        /* Call for power on/off the port if necessary */
+        int     (*port_power)(struct usb_hcd *hcd, int portnum, bool enable);
+
 };
 
 static inline int hcd_giveback_urb_in_bh(struct usb_hcd *hcd)
@@ -623,16 +628,13 @@ extern int usb_find_interface_driver(struct usb_device *dev,
 extern void usb_root_hub_lost_power(struct usb_device *rhdev);
 extern int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg);
 extern int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg);
-#endif /* CONFIG_PM */
-
-#ifdef CONFIG_PM_RUNTIME
 extern void usb_hcd_resume_root_hub(struct usb_hcd *hcd);
 #else
 static inline void usb_hcd_resume_root_hub(struct usb_hcd *hcd)
 {
         return;
 }
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 /*-------------------------------------------------------------------------*/
 
diff --git a/include/linux/usb/of.h b/include/linux/usb/of.h
index 8c38aa26b3bb..cfe0528cdbb1 100644
--- a/include/linux/usb/of.h
+++ b/include/linux/usb/of.h
@@ -14,6 +14,7 @@
 #if IS_ENABLED(CONFIG_OF)
 enum usb_dr_mode of_usb_get_dr_mode(struct device_node *np);
 enum usb_device_speed of_usb_get_maximum_speed(struct device_node *np);
+bool of_usb_host_tpl_support(struct device_node *np);
 #else
 static inline enum usb_dr_mode of_usb_get_dr_mode(struct device_node *np)
 {
@@ -25,6 +26,10 @@ of_usb_get_maximum_speed(struct device_node *np)
 {
         return USB_SPEED_UNKNOWN;
 }
+static inline bool of_usb_host_tpl_support(struct device_node *np)
+{
+        return false;
+}
 #endif
 
 #if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_USB_SUPPORT)
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index 154332b7c8c0..52661c5da690 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -9,15 +9,20 @@
 #ifndef __LINUX_USB_OTG_H
 #define __LINUX_USB_OTG_H
 
+#include <linux/phy/phy.h>
 #include <linux/usb/phy.h>
 
 struct usb_otg {
         u8                      default_a;
 
-        struct usb_phy          *phy;
+        struct phy              *phy;
+        /* old usb_phy interface */
+        struct usb_phy          *usb_phy;
         struct usb_bus          *host;
         struct usb_gadget       *gadget;
 
+        enum usb_otg_state      state;
+
         /* bind/unbind the host controller */
         int     (*set_host)(struct usb_otg *otg, struct usb_bus *host);
 
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index 353053a33f21..f499c23e6342 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -77,7 +77,6 @@ struct usb_phy {
         unsigned int             flags;
 
         enum usb_phy_type       type;
-        enum usb_otg_state      state;
         enum usb_phy_events     last_event;
 
         struct usb_otg          *otg;
@@ -210,6 +209,7 @@ extern void usb_put_phy(struct usb_phy *);
 extern void devm_usb_put_phy(struct device *dev, struct usb_phy *x);
 extern int usb_bind_phy(const char *dev_name, u8 index,
                                 const char *phy_dev_name);
+extern void usb_phy_set_event(struct usb_phy *x, unsigned long event);
 #else
 static inline struct usb_phy *usb_get_phy(enum usb_phy_type type)
 {
@@ -251,6 +251,10 @@ static inline int usb_bind_phy(const char *dev_name, u8 index,
 {
         return -EOPNOTSUPP;
 }
+
+static inline void usb_phy_set_event(struct usb_phy *x, unsigned long event)
+{
+}
 #endif
 
 static inline int
diff --git a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h
index 55a17b188daa..9948c874e3f1 100644
--- a/include/linux/usb/quirks.h
+++ b/include/linux/usb/quirks.h
@@ -8,27 +8,27 @@
 #define __LINUX_USB_QUIRKS_H
 
 /* string descriptors must not be fetched using a 255-byte read */
-#define USB_QUIRK_STRING_FETCH_255      0x00000001
+#define USB_QUIRK_STRING_FETCH_255              BIT(0)
 
 /* device can't resume correctly so reset it instead */
-#define USB_QUIRK_RESET_RESUME          0x00000002
+#define USB_QUIRK_RESET_RESUME                  BIT(1)
 
 /* device can't handle Set-Interface requests */
-#define USB_QUIRK_NO_SET_INTF           0x00000004
+#define USB_QUIRK_NO_SET_INTF                   BIT(2)
 
 /* device can't handle its Configuration or Interface strings */
-#define USB_QUIRK_CONFIG_INTF_STRINGS   0x00000008
+#define USB_QUIRK_CONFIG_INTF_STRINGS           BIT(3)
 
 /* device can't be reset(e.g morph devices), don't use reset */
-#define USB_QUIRK_RESET                 0x00000010
+#define USB_QUIRK_RESET                         BIT(4)
 
 /* device has more interface descriptions than the bNumInterfaces count,
    and can't handle talking to these interfaces */
-#define USB_QUIRK_HONOR_BNUMINTERFACES  0x00000020
+#define USB_QUIRK_HONOR_BNUMINTERFACES          BIT(5)
 
 /* device needs a pause during initialization, after we read the device
    descriptor */
-#define USB_QUIRK_DELAY_INIT            0x00000040
+#define USB_QUIRK_DELAY_INIT                    BIT(6)
 
 /*
  * For high speed and super speed interupt endpoints, the USB 2.0 and
@@ -39,6 +39,12 @@
  * Devices with this quirk report their bInterval as the result of this
  * calculation instead of the exponent variable used in the calculation.
  */
-#define USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL  0x00000080
+#define USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL  BIT(7)
+
+/* device can't handle device_qualifier descriptor requests */
+#define USB_QUIRK_DEVICE_QUALIFIER              BIT(8)
+
+/* device generates spurious wakeup, ignore remote wakeup capability */
+#define USB_QUIRK_IGNORE_REMOTE_WAKEUP          BIT(9)
 
 #endif /* __LINUX_USB_QUIRKS_H */
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
index d5952bb66752..9fd9e481ea98 100644
--- a/include/linux/usb/renesas_usbhs.h
+++ b/include/linux/usb/renesas_usbhs.h
@@ -145,6 +145,10 @@ struct renesas_usbhs_driver_param {
         int d0_rx_id;
         int d1_tx_id;
         int d1_rx_id;
+        int d2_tx_id;
+        int d2_rx_id;
+        int d3_tx_id;
+        int d3_rx_id;
 
         /*
          * option:
diff --git a/include/linux/usb/usbnet.h b/include/linux/usb/usbnet.h
index 26088feb6608..d9a4905e01d0 100644
--- a/include/linux/usb/usbnet.h
+++ b/include/linux/usb/usbnet.h
@@ -78,6 +78,7 @@ struct usbnet {
 #               define EVENT_NO_RUNTIME_PM      9
 #               define EVENT_RX_KILL    10
 #               define EVENT_LINK_CHANGE        11
+#               define EVENT_SET_RX_MODE        12
 };
 
 static inline struct usb_driver *driver_of(struct usb_interface *intf)
@@ -159,6 +160,9 @@ struct driver_info {
         /* called by minidriver when receiving indication */
         void    (*indication)(struct usbnet *dev, void *ind, int indlen);
 
+        /* rx mode change (device changes address list filtering) */
+        void    (*set_rx_mode)(struct usbnet *dev);
+
         /* for new devices, use the descriptor-reading code instead */
         int             in;             /* rx endpoint */
         int             out;            /* tx endpoint */
diff --git a/include/linux/usb_usual.h b/include/linux/usb_usual.h
index 9b7de1b46437..a7f2604c5f25 100644
--- a/include/linux/usb_usual.h
+++ b/include/linux/usb_usual.h
@@ -73,6 +73,10 @@
                 /* Device advertises UAS but it is broken */    \
         US_FLAG(BROKEN_FUA,     0x01000000)                     \
                 /* Cannot handle FUA in WRITE or READ CDBs */   \
+        US_FLAG(NO_ATA_1X,      0x02000000)                     \
+                /* Cannot handle ATA_12 or ATA_16 CDBs */       \
+        US_FLAG(NO_REPORT_OPCODES,      0x04000000)             \
+                /* Cannot handle MI_REPORT_SUPPORTED_OPERATION_CODES */ \
 
 #define US_FLAG(name, value)    US_FL_##name = value ,
 enum { US_DO_ALL_FLAGS };
diff --git a/include/linux/user_namespace.h b/include/linux/user_namespace.h
index e95372654f09..8297e5b341d8 100644
--- a/include/linux/user_namespace.h
+++ b/include/linux/user_namespace.h
@@ -3,6 +3,7 @@
 
 #include <linux/kref.h>
 #include <linux/nsproxy.h>
+#include <linux/ns_common.h>
 #include <linux/sched.h>
 #include <linux/err.h>
 
@@ -17,6 +18,10 @@ struct uid_gid_map {	/* 64 bytes -- 1 cache line */
         } extent[UID_GID_MAP_MAX_EXTENTS];
 };
 
+#define USERNS_SETGROUPS_ALLOWED 1UL
+
+#define USERNS_INIT_FLAGS USERNS_SETGROUPS_ALLOWED
+
 struct user_namespace {
         struct uid_gid_map      uid_map;
         struct uid_gid_map      gid_map;
@@ -26,7 +31,8 @@ struct user_namespace {
         int                     level;
         kuid_t                  owner;
         kgid_t                  group;
-        unsigned int            proc_inum;
+        struct ns_common        ns;
+        unsigned long           flags;
 
         /* Register of per-UID persistent keyrings for this namespace */
 #ifdef CONFIG_PERSISTENT_KEYRINGS
@@ -63,6 +69,9 @@ extern const struct seq_operations proc_projid_seq_operations;
 extern ssize_t proc_uid_map_write(struct file *, const char __user *, size_t, loff_t *);
 extern ssize_t proc_gid_map_write(struct file *, const char __user *, size_t, loff_t *);
 extern ssize_t proc_projid_map_write(struct file *, const char __user *, size_t, loff_t *);
+extern ssize_t proc_setgroups_write(struct file *, const char __user *, size_t, loff_t *);
+extern int proc_setgroups_show(struct seq_file *m, void *v);
+extern bool userns_may_setgroups(const struct user_namespace *ns);
 #else
 
 static inline struct user_namespace *get_user_ns(struct user_namespace *ns)
@@ -87,6 +96,10 @@ static inline void put_user_ns(struct user_namespace *ns)
 {
 }
 
+static inline bool userns_may_setgroups(const struct user_namespace *ns)
+{
+        return true;
+}
 #endif
 
 #endif /* _LINUX_USER_H */
diff --git a/include/linux/utsname.h b/include/linux/utsname.h
index 239e27733d6c..5093f58ae192 100644
--- a/include/linux/utsname.h
+++ b/include/linux/utsname.h
@@ -5,6 +5,7 @@
 #include <linux/sched.h>
 #include <linux/kref.h>
 #include <linux/nsproxy.h>
+#include <linux/ns_common.h>
 #include <linux/err.h>
 #include <uapi/linux/utsname.h>
 
@@ -23,7 +24,7 @@ struct uts_namespace {
         struct kref kref;
         struct new_utsname name;
         struct user_namespace *user_ns;
-        unsigned int proc_inum;
+        struct ns_common ns;
 };
 extern struct uts_namespace init_uts_ns;
 
diff --git a/include/linux/vexpress.h b/include/linux/vexpress.h
index a4c9547aae64..f8e76e08ebe4 100644
--- a/include/linux/vexpress.h
+++ b/include/linux/vexpress.h
@@ -15,8 +15,6 @@
 #define _LINUX_VEXPRESS_H
 
 #include <linux/device.h>
-#include <linux/platform_device.h>
-#include <linux/reboot.h>
 #include <linux/regmap.h>
 
 #define VEXPRESS_SITE_MB                0
@@ -24,13 +22,6 @@
 #define VEXPRESS_SITE_DB2               2
 #define VEXPRESS_SITE_MASTER            0xf
 
-#define VEXPRESS_RES_FUNC(_site, _func) \
-{                                       \
-        .start = (_site),               \
-        .end = (_func),                 \
-        .flags = IORESOURCE_BUS,        \
-}
-
 /* Config infrastructure */
 
 void vexpress_config_set_master(u32 site);
@@ -58,16 +49,6 @@ struct regmap *devm_regmap_init_vexpress_config(struct device *dev);
 
 /* Platform control */
 
-unsigned int vexpress_get_mci_cardin(struct device *dev);
-u32 vexpress_get_procid(int site);
-void *vexpress_get_24mhz_clock_base(void);
 void vexpress_flags_set(u32 data);
 
-void vexpress_sysreg_early_init(void __iomem *base);
-int vexpress_syscfg_device_register(struct platform_device *pdev);
-
-/* Clocks */
-
-void vexpress_clk_init(void __iomem *sp810_base);
-
 #endif
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index b46671e28de2..28f0e65b9a11 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -75,9 +75,16 @@ unsigned int virtqueue_get_vring_size(struct virtqueue *vq);
 
 bool virtqueue_is_broken(struct virtqueue *vq);
 
+void *virtqueue_get_avail(struct virtqueue *vq);
+void *virtqueue_get_used(struct virtqueue *vq);
+
 /**
  * virtio_device - representation of a device using virtio
  * @index: unique position on the virtio bus
+ * @failed: saved value for VIRTIO_CONFIG_S_FAILED bit (for restore)
+ * @config_enabled: configuration change reporting enabled
+ * @config_change_pending: configuration change reported while disabled
+ * @config_lock: protects configuration change reporting
  * @dev: underlying device.
  * @id: the device type identification (used to match it with a driver).
  * @config: the configuration ops for this device.
@@ -88,16 +95,21 @@ bool virtqueue_is_broken(struct virtqueue *vq);
  */
 struct virtio_device {
         int index;
+        bool failed;
+        bool config_enabled;
+        bool config_change_pending;
+        spinlock_t config_lock;
         struct device dev;
         struct virtio_device_id id;
         const struct virtio_config_ops *config;
         const struct vringh_config_ops *vringh_config;
         struct list_head vqs;
-        /* Note that this is a Linux set_bit-style bitmap. */
-        unsigned long features[1];
+        u64 features;
         void *priv;
 };
 
+bool virtio_device_is_legacy_only(struct virtio_device_id id);
+
 static inline struct virtio_device *dev_to_virtio(struct device *_dev)
 {
         return container_of(_dev, struct virtio_device, dev);
@@ -108,12 +120,20 @@ void unregister_virtio_device(struct virtio_device *dev);
 
 void virtio_break_device(struct virtio_device *dev);
 
+void virtio_config_changed(struct virtio_device *dev);
+#ifdef CONFIG_PM_SLEEP
+int virtio_device_freeze(struct virtio_device *dev);
+int virtio_device_restore(struct virtio_device *dev);
+#endif
+
 /**
  * virtio_driver - operations for a virtio I/O driver
  * @driver: underlying device driver (populate name and owner).
  * @id_table: the ids serviced by this driver.
  * @feature_table: an array of feature numbers supported by this driver.
  * @feature_table_size: number of entries in the feature table array.
+ * @feature_table_legacy: same as feature_table but when working in legacy mode.
+ * @feature_table_size_legacy: number of entries in feature table legacy array.
  * @probe: the function to call when a device is found.  Returns 0 or -errno.
  * @remove: the function to call when a device is removed.
  * @config_changed: optional function to call when the device configuration
@@ -124,6 +144,8 @@ struct virtio_driver {
         const struct virtio_device_id *id_table;
         const unsigned int *feature_table;
         unsigned int feature_table_size;
+        const unsigned int *feature_table_legacy;
+        unsigned int feature_table_size_legacy;
         int (*probe)(struct virtio_device *dev);
         void (*scan)(struct virtio_device *dev);
         void (*remove)(struct virtio_device *dev);
diff --git a/include/linux/virtio_byteorder.h b/include/linux/virtio_byteorder.h
new file mode 100644
index 000000000000..51865d05b267
--- /dev/null
+++ b/include/linux/virtio_byteorder.h
@@ -0,0 +1,59 @@
+#ifndef _LINUX_VIRTIO_BYTEORDER_H
+#define _LINUX_VIRTIO_BYTEORDER_H
+#include <linux/types.h>
+#include <uapi/linux/virtio_types.h>
+
+/*
+ * Low-level memory accessors for handling virtio in modern little endian and in
+ * compatibility native endian format.
+ */
+
+static inline u16 __virtio16_to_cpu(bool little_endian, __virtio16 val)
+{
+        if (little_endian)
+                return le16_to_cpu((__force __le16)val);
+        else
+                return (__force u16)val;
+}
+
+static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
+{
+        if (little_endian)
+                return (__force __virtio16)cpu_to_le16(val);
+        else
+                return (__force __virtio16)val;
+}
+
+static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
+{
+        if (little_endian)
+                return le32_to_cpu((__force __le32)val);
+        else
+                return (__force u32)val;
+}
+
+static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
+{
+        if (little_endian)
+                return (__force __virtio32)cpu_to_le32(val);
+        else
+                return (__force __virtio32)val;
+}
+
+static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
+{
+        if (little_endian)
+                return le64_to_cpu((__force __le64)val);
+        else
+                return (__force u64)val;
+}
+
+static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
+{
+        if (little_endian)
+                return (__force __virtio64)cpu_to_le64(val);
+        else
+                return (__force __virtio64)val;
+}
+
+#endif /* _LINUX_VIRTIO_BYTEORDER */
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index e8f8f71e843c..ca3ed78e5ec7 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -4,6 +4,7 @@
 #include <linux/err.h>
 #include <linux/bug.h>
 #include <linux/virtio.h>
+#include <linux/virtio_byteorder.h>
 #include <uapi/linux/virtio_config.h>
 
 /**
@@ -18,6 +19,9 @@
  *      offset: the offset of the configuration field
  *      buf: the buffer to read the field value from.
  *      len: the length of the buffer
+ * @generation: config generation counter
+ *      vdev: the virtio_device
+ *      Returns the config generation counter
  * @get_status: read the status byte
  *      vdev: the virtio_device
  *      Returns the status byte
@@ -46,6 +50,7 @@
  *      vdev: the virtio_device
  *      This gives the final feature bits for the device: it can change
  *      the dev->feature bits if it wants.
+ *      Returns 0 on success or error status
  * @bus_name: return the bus name associated with the device
  *      vdev: the virtio_device
  *      This returns a pointer to the bus name a la pci_name from which
@@ -58,6 +63,7 @@ struct virtio_config_ops {
                     void *buf, unsigned len);
         void (*set)(struct virtio_device *vdev, unsigned offset,
                     const void *buf, unsigned len);
+        u32 (*generation)(struct virtio_device *vdev);
         u8 (*get_status)(struct virtio_device *vdev);
         void (*set_status)(struct virtio_device *vdev, u8 status);
         void (*reset)(struct virtio_device *vdev);
@@ -66,8 +72,8 @@ struct virtio_config_ops {
                         vq_callback_t *callbacks[],
                         const char *names[]);
         void (*del_vqs)(struct virtio_device *);
-        u32 (*get_features)(struct virtio_device *vdev);
-        void (*finalize_features)(struct virtio_device *vdev);
+        u64 (*get_features)(struct virtio_device *vdev);
+        int (*finalize_features)(struct virtio_device *vdev);
         const char *(*bus_name)(struct virtio_device *vdev);
         int (*set_vq_affinity)(struct virtqueue *vq, int cpu);
 };
@@ -77,23 +83,70 @@ void virtio_check_driver_offered_feature(const struct virtio_device *vdev,
                                          unsigned int fbit);
 
 /**
- * virtio_has_feature - helper to determine if this device has this feature.
+ * __virtio_test_bit - helper to test feature bits. For use by transports.
+ *                     Devices should normally use virtio_has_feature,
+ *                     which includes more checks.
  * @vdev: the device
  * @fbit: the feature bit
  */
-static inline bool virtio_has_feature(const struct virtio_device *vdev,
+static inline bool __virtio_test_bit(const struct virtio_device *vdev,
+                                     unsigned int fbit)
+{
+        /* Did you forget to fix assumptions on max features? */
+        if (__builtin_constant_p(fbit))
+                BUILD_BUG_ON(fbit >= 64);
+        else
+                BUG_ON(fbit >= 64);
+
+        return vdev->features & BIT_ULL(fbit);
+}
+
+/**
+ * __virtio_set_bit - helper to set feature bits. For use by transports.
+ * @vdev: the device
+ * @fbit: the feature bit
+ */
+static inline void __virtio_set_bit(struct virtio_device *vdev,
+                                    unsigned int fbit)
+{
+        /* Did you forget to fix assumptions on max features? */
+        if (__builtin_constant_p(fbit))
+                BUILD_BUG_ON(fbit >= 64);
+        else
+                BUG_ON(fbit >= 64);
+
+        vdev->features |= BIT_ULL(fbit);
+}
+
+/**
+ * __virtio_clear_bit - helper to clear feature bits. For use by transports.
+ * @vdev: the device
+ * @fbit: the feature bit
+ */
+static inline void __virtio_clear_bit(struct virtio_device *vdev,
                                       unsigned int fbit)
 {
         /* Did you forget to fix assumptions on max features? */
         if (__builtin_constant_p(fbit))
-                BUILD_BUG_ON(fbit >= 32);
+                BUILD_BUG_ON(fbit >= 64);
         else
-                BUG_ON(fbit >= 32);
+                BUG_ON(fbit >= 64);
+
+        vdev->features &= ~BIT_ULL(fbit);
+}
 
+/**
+ * virtio_has_feature - helper to determine if this device has this feature.
+ * @vdev: the device
+ * @fbit: the feature bit
+ */
+static inline bool virtio_has_feature(const struct virtio_device *vdev,
+                                      unsigned int fbit)
+{
         if (fbit < VIRTIO_TRANSPORT_F_START)
                 virtio_check_driver_offered_feature(vdev, fbit);
 
-        return test_bit(fbit, vdev->features);
+        return __virtio_test_bit(vdev, fbit);
 }
 
 static inline
@@ -109,6 +162,23 @@ struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,
         return vq;
 }
 
+/**
+ * virtio_device_ready - enable vq use in probe function
+ * @vdev: the device
+ *
+ * Driver must call this to use vqs in the probe function.
+ *
+ * Note: vqs are enabled automatically after probe returns.
+ */
+static inline
+void virtio_device_ready(struct virtio_device *dev)
+{
+        unsigned status = dev->config->get_status(dev);
+
+        BUG_ON(status & VIRTIO_CONFIG_S_DRIVER_OK);
+        dev->config->set_status(dev, status | VIRTIO_CONFIG_S_DRIVER_OK);
+}
+
 static inline
 const char *virtio_bus_name(struct virtio_device *vdev)
 {
@@ -135,6 +205,37 @@ int virtqueue_set_affinity(struct virtqueue *vq, int cpu)
         return 0;
 }
 
+/* Memory accessors */
+static inline u16 virtio16_to_cpu(struct virtio_device *vdev, __virtio16 val)
+{
+        return __virtio16_to_cpu(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+}
+
+static inline __virtio16 cpu_to_virtio16(struct virtio_device *vdev, u16 val)
+{
+        return __cpu_to_virtio16(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+}
+
+static inline u32 virtio32_to_cpu(struct virtio_device *vdev, __virtio32 val)
+{
+        return __virtio32_to_cpu(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+}
+
+static inline __virtio32 cpu_to_virtio32(struct virtio_device *vdev, u32 val)
+{
+        return __cpu_to_virtio32(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+}
+
+static inline u64 virtio64_to_cpu(struct virtio_device *vdev, __virtio64 val)
+{
+        return __virtio64_to_cpu(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+}
+
+static inline __virtio64 cpu_to_virtio64(struct virtio_device *vdev, u64 val)
+{
+        return __cpu_to_virtio64(virtio_has_feature(vdev, VIRTIO_F_VERSION_1), val);
+}
+
 /* Config space accessors. */
 #define virtio_cread(vdev, structname, member, ptr)                     \
         do {                                                            \
@@ -204,11 +305,33 @@ static inline u8 virtio_cread8(struct virtio_device *vdev, unsigned int offset)
         return ret;
 }
 
+/* Read @count fields, @bytes each. */
+static inline void __virtio_cread_many(struct virtio_device *vdev,
+                                       unsigned int offset,
+                                       void *buf, size_t count, size_t bytes)
+{
+        u32 old, gen = vdev->config->generation ?
+                vdev->config->generation(vdev) : 0;
+        int i;
+
+        do {
+                old = gen;
+
+                for (i = 0; i < count; i++)
+                        vdev->config->get(vdev, offset + bytes * i,
+                                          buf + i * bytes, bytes);
+
+                gen = vdev->config->generation ?
+                        vdev->config->generation(vdev) : 0;
+        } while (gen != old);
+}
+
+
 static inline void virtio_cread_bytes(struct virtio_device *vdev,
                                       unsigned int offset,
                                       void *buf, size_t len)
 {
-        vdev->config->get(vdev, offset, buf, len);
+        __virtio_cread_many(vdev, offset, buf, len, 1);
 }
 
 static inline void virtio_cwrite8(struct virtio_device *vdev,
@@ -222,12 +345,13 @@ static inline u16 virtio_cread16(struct virtio_device *vdev,
 {
         u16 ret;
         vdev->config->get(vdev, offset, &ret, sizeof(ret));
-        return ret;
+        return virtio16_to_cpu(vdev, (__force __virtio16)ret);
 }
 
 static inline void virtio_cwrite16(struct virtio_device *vdev,
                                    unsigned int offset, u16 val)
 {
+        val = (__force u16)cpu_to_virtio16(vdev, val);
         vdev->config->set(vdev, offset, &val, sizeof(val));
 }
 
@@ -236,12 +360,13 @@ static inline u32 virtio_cread32(struct virtio_device *vdev,
 {
         u32 ret;
         vdev->config->get(vdev, offset, &ret, sizeof(ret));
-        return ret;
+        return virtio32_to_cpu(vdev, (__force __virtio32)ret);
 }
 
 static inline void virtio_cwrite32(struct virtio_device *vdev,
                                    unsigned int offset, u32 val)
 {
+        val = (__force u32)cpu_to_virtio32(vdev, val);
         vdev->config->set(vdev, offset, &val, sizeof(val));
 }
 
@@ -250,12 +375,14 @@ static inline u64 virtio_cread64(struct virtio_device *vdev,
 {
         u64 ret;
         vdev->config->get(vdev, offset, &ret, sizeof(ret));
-        return ret;
+        __virtio_cread_many(vdev, offset, &ret, 1, sizeof(ret));
+        return virtio64_to_cpu(vdev, (__force __virtio64)ret);
 }
 
 static inline void virtio_cwrite64(struct virtio_device *vdev,
                                    unsigned int offset, u64 val)
 {
+        val = (__force u64)cpu_to_virtio64(vdev, val);
         vdev->config->set(vdev, offset, &val, sizeof(val));
 }
 
diff --git a/include/linux/virtio_scsi.h b/include/linux/virtio_scsi.h
deleted file mode 100644
index de429d1f4357..000000000000
--- a/include/linux/virtio_scsi.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#ifndef _LINUX_VIRTIO_SCSI_H
-#define _LINUX_VIRTIO_SCSI_H
-
-#define VIRTIO_SCSI_CDB_SIZE   32
-#define VIRTIO_SCSI_SENSE_SIZE 96
-
-/* SCSI command request, followed by data-out */
-struct virtio_scsi_cmd_req {
-        u8 lun[8];              /* Logical Unit Number */
-        u64 tag;                /* Command identifier */
-        u8 task_attr;           /* Task attribute */
-        u8 prio;                /* SAM command priority field */
-        u8 crn;
-        u8 cdb[VIRTIO_SCSI_CDB_SIZE];
-} __packed;
-
-/* SCSI command request, followed by protection information */
-struct virtio_scsi_cmd_req_pi {
-        u8 lun[8];              /* Logical Unit Number */
-        u64 tag;                /* Command identifier */
-        u8 task_attr;           /* Task attribute */
-        u8 prio;                /* SAM command priority field */
-        u8 crn;
-        u32 pi_bytesout;        /* DataOUT PI Number of bytes */
-        u32 pi_bytesin;         /* DataIN PI Number of bytes */
-        u8 cdb[VIRTIO_SCSI_CDB_SIZE];
-} __packed;
-
-/* Response, followed by sense data and data-in */
-struct virtio_scsi_cmd_resp {
-        u32 sense_len;          /* Sense data length */
-        u32 resid;              /* Residual bytes in data buffer */
-        u16 status_qualifier;   /* Status qualifier */
-        u8 status;              /* Command completion status */
-        u8 response;            /* Response values */
-        u8 sense[VIRTIO_SCSI_SENSE_SIZE];
-} __packed;
-
-/* Task Management Request */
-struct virtio_scsi_ctrl_tmf_req {
-        u32 type;
-        u32 subtype;
-        u8 lun[8];
-        u64 tag;
-} __packed;
-
-struct virtio_scsi_ctrl_tmf_resp {
-        u8 response;
-} __packed;
-
-/* Asynchronous notification query/subscription */
-struct virtio_scsi_ctrl_an_req {
-        u32 type;
-        u8 lun[8];
-        u32 event_requested;
-} __packed;
-
-struct virtio_scsi_ctrl_an_resp {
-        u32 event_actual;
-        u8 response;
-} __packed;
-
-struct virtio_scsi_event {
-        u32 event;
-        u8 lun[8];
-        u32 reason;
-} __packed;
-
-struct virtio_scsi_config {
-        u32 num_queues;
-        u32 seg_max;
-        u32 max_sectors;
-        u32 cmd_per_lun;
-        u32 event_info_size;
-        u32 sense_size;
-        u32 cdb_size;
-        u16 max_channel;
-        u16 max_target;
-        u32 max_lun;
-} __packed;
-
-/* Feature Bits */
-#define VIRTIO_SCSI_F_INOUT                    0
-#define VIRTIO_SCSI_F_HOTPLUG                  1
-#define VIRTIO_SCSI_F_CHANGE                   2
-#define VIRTIO_SCSI_F_T10_PI                   3
-
-/* Response codes */
-#define VIRTIO_SCSI_S_OK                       0
-#define VIRTIO_SCSI_S_OVERRUN                  1
-#define VIRTIO_SCSI_S_ABORTED                  2
-#define VIRTIO_SCSI_S_BAD_TARGET               3
-#define VIRTIO_SCSI_S_RESET                    4
-#define VIRTIO_SCSI_S_BUSY                     5
-#define VIRTIO_SCSI_S_TRANSPORT_FAILURE        6
-#define VIRTIO_SCSI_S_TARGET_FAILURE           7
-#define VIRTIO_SCSI_S_NEXUS_FAILURE            8
-#define VIRTIO_SCSI_S_FAILURE                  9
-#define VIRTIO_SCSI_S_FUNCTION_SUCCEEDED       10
-#define VIRTIO_SCSI_S_FUNCTION_REJECTED        11
-#define VIRTIO_SCSI_S_INCORRECT_LUN            12
-
-/* Controlq type codes.  */
-#define VIRTIO_SCSI_T_TMF                      0
-#define VIRTIO_SCSI_T_AN_QUERY                 1
-#define VIRTIO_SCSI_T_AN_SUBSCRIBE             2
-
-/* Valid TMF subtypes.  */
-#define VIRTIO_SCSI_T_TMF_ABORT_TASK           0
-#define VIRTIO_SCSI_T_TMF_ABORT_TASK_SET       1
-#define VIRTIO_SCSI_T_TMF_CLEAR_ACA            2
-#define VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET       3
-#define VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET      4
-#define VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET   5
-#define VIRTIO_SCSI_T_TMF_QUERY_TASK           6
-#define VIRTIO_SCSI_T_TMF_QUERY_TASK_SET       7
-
-/* Events.  */
-#define VIRTIO_SCSI_T_EVENTS_MISSED            0x80000000
-#define VIRTIO_SCSI_T_NO_EVENT                 0
-#define VIRTIO_SCSI_T_TRANSPORT_RESET          1
-#define VIRTIO_SCSI_T_ASYNC_NOTIFY             2
-#define VIRTIO_SCSI_T_PARAM_CHANGE             3
-
-/* Reasons of transport reset event */
-#define VIRTIO_SCSI_EVT_RESET_HARD             0
-#define VIRTIO_SCSI_EVT_RESET_RESCAN           1
-#define VIRTIO_SCSI_EVT_RESET_REMOVED          2
-
-#define VIRTIO_SCSI_S_SIMPLE                   0
-#define VIRTIO_SCSI_S_ORDERED                  1
-#define VIRTIO_SCSI_S_HEAD                     2
-#define VIRTIO_SCSI_S_ACA                      3
-
-
-#endif /* _LINUX_VIRTIO_SCSI_H */
diff --git a/include/linux/vm_event_item.h b/include/linux/vm_event_item.h
index ced92345c963..9246d32dc973 100644
--- a/include/linux/vm_event_item.h
+++ b/include/linux/vm_event_item.h
@@ -72,6 +72,13 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                 THP_ZERO_PAGE_ALLOC,
                 THP_ZERO_PAGE_ALLOC_FAILED,
 #endif
+#ifdef CONFIG_MEMORY_BALLOON
+                BALLOON_INFLATE,
+                BALLOON_DEFLATE,
+#ifdef CONFIG_BALLOON_COMPACTION
+                BALLOON_MIGRATE,
+#endif
+#endif
 #ifdef CONFIG_DEBUG_TLBFLUSH
 #ifdef CONFIG_SMP
                 NR_TLB_REMOTE_FLUSH,    /* cpu tried to flush others' tlbs */
@@ -83,6 +90,7 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
 #ifdef CONFIG_DEBUG_VM_VMACACHE
                 VMACACHE_FIND_CALLS,
                 VMACACHE_FIND_HITS,
+                VMACACHE_FULL_FLUSHES,
 #endif
                 NR_VM_EVENT_ITEMS
 };
diff --git a/include/linux/vmw_vmci_api.h b/include/linux/vmw_vmci_api.h
index 023430e265fe..5691f752ce8f 100644
--- a/include/linux/vmw_vmci_api.h
+++ b/include/linux/vmw_vmci_api.h
@@ -24,6 +24,7 @@
 #define VMCI_KERNEL_API_VERSION_2 2
 #define VMCI_KERNEL_API_VERSION   VMCI_KERNEL_API_VERSION_2
 
+struct msghdr;
 typedef void (vmci_device_shutdown_fn) (void *device_registration,
                                         void *user_data);
 
@@ -75,8 +76,8 @@ ssize_t vmci_qpair_peek(struct vmci_qp *qpair, void *buf, size_t buf_size,
 ssize_t vmci_qpair_enquev(struct vmci_qp *qpair,
                           void *iov, size_t iov_size, int mode);
 ssize_t vmci_qpair_dequev(struct vmci_qp *qpair,
-                          void *iov, size_t iov_size, int mode);
-ssize_t vmci_qpair_peekv(struct vmci_qp *qpair, void *iov, size_t iov_size,
+                          struct msghdr *msg, size_t iov_size, int mode);
+ssize_t vmci_qpair_peekv(struct vmci_qp *qpair, struct msghdr *msg, size_t iov_size,
                          int mode);
 
 #endif /* !__VMW_VMCI_API_H__ */
diff --git a/include/linux/vringh.h b/include/linux/vringh.h
index 749cde28728b..a3fa537e717a 100644
--- a/include/linux/vringh.h
+++ b/include/linux/vringh.h
@@ -24,12 +24,16 @@
 #ifndef _LINUX_VRINGH_H
 #define _LINUX_VRINGH_H
 #include <uapi/linux/virtio_ring.h>
+#include <linux/virtio_byteorder.h>
 #include <linux/uio.h>
 #include <linux/slab.h>
 #include <asm/barrier.h>
 
 /* virtio_ring with information needed for host access. */
 struct vringh {
+        /* Everything is little endian */
+        bool little_endian;
+
         /* Guest publishes used event idx (note: we always do). */
         bool event_indices;
 
@@ -105,7 +109,7 @@ struct vringh_kiov {
 #define VRINGH_IOV_ALLOCATED 0x8000000
 
 /* Helpers for userspace vrings. */
-int vringh_init_user(struct vringh *vrh, u32 features,
+int vringh_init_user(struct vringh *vrh, u64 features,
                      unsigned int num, bool weak_barriers,
                      struct vring_desc __user *desc,
                      struct vring_avail __user *avail,
@@ -167,7 +171,7 @@ bool vringh_notify_enable_user(struct vringh *vrh);
 void vringh_notify_disable_user(struct vringh *vrh);
 
 /* Helpers for kernelspace vrings. */
-int vringh_init_kern(struct vringh *vrh, u32 features,
+int vringh_init_kern(struct vringh *vrh, u64 features,
                      unsigned int num, bool weak_barriers,
                      struct vring_desc *desc,
                      struct vring_avail *avail,
@@ -222,4 +226,33 @@ static inline void vringh_notify(struct vringh *vrh)
                 vrh->notify(vrh);
 }
 
+static inline u16 vringh16_to_cpu(const struct vringh *vrh, __virtio16 val)
+{
+        return __virtio16_to_cpu(vrh->little_endian, val);
+}
+
+static inline __virtio16 cpu_to_vringh16(const struct vringh *vrh, u16 val)
+{
+        return __cpu_to_virtio16(vrh->little_endian, val);
+}
+
+static inline u32 vringh32_to_cpu(const struct vringh *vrh, __virtio32 val)
+{
+        return __virtio32_to_cpu(vrh->little_endian, val);
+}
+
+static inline __virtio32 cpu_to_vringh32(const struct vringh *vrh, u32 val)
+{
+        return __cpu_to_virtio32(vrh->little_endian, val);
+}
+
+static inline u64 vringh64_to_cpu(const struct vringh *vrh, __virtio64 val)
+{
+        return __virtio64_to_cpu(vrh->little_endian, val);
+}
+
+static inline __virtio64 cpu_to_vringh64(const struct vringh *vrh, u64 val)
+{
+        return __cpu_to_virtio64(vrh->little_endian, val);
+}
 #endif /* _LINUX_VRINGH_H */
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 6fb1ba5f9b2f..2232ed16635a 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -13,9 +13,12 @@ typedef struct __wait_queue wait_queue_t;
 typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);
 int default_wake_function(wait_queue_t *wait, unsigned mode, int flags, void *key);
 
+/* __wait_queue::flags */
+#define WQ_FLAG_EXCLUSIVE       0x01
+#define WQ_FLAG_WOKEN           0x02
+
 struct __wait_queue {
         unsigned int            flags;
-#define WQ_FLAG_EXCLUSIVE       0x01
         void                    *private;
         wait_queue_func_t       func;
         struct list_head        task_list;
@@ -25,7 +28,7 @@ struct wait_bit_key {
         void                    *flags;
         int                     bit_nr;
 #define WAIT_ATOMIC_T_BIT_NR    -1
-        unsigned long           private;
+        unsigned long           timeout;
 };
 
 struct wait_bit_queue {
@@ -154,6 +157,7 @@ int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, wait_bit_ac
 void wake_up_bit(void *, int);
 void wake_up_atomic_t(atomic_t *);
 int out_of_line_wait_on_bit(void *, int, wait_bit_action_f *, unsigned);
+int out_of_line_wait_on_bit_timeout(void *, int, wait_bit_action_f *, unsigned, unsigned long);
 int out_of_line_wait_on_bit_lock(void *, int, wait_bit_action_f *, unsigned);
 int out_of_line_wait_on_atomic_t(atomic_t *, int (*)(atomic_t *), unsigned);
 wait_queue_head_t *bit_waitqueue(void *, int);
@@ -257,11 +261,37 @@ __out:	__ret;								\
  */
 #define wait_event(wq, condition)                                       \
 do {                                                                    \
+        might_sleep();                                                  \
         if (condition)                                                  \
                 break;                                                  \
         __wait_event(wq, condition);                                    \
 } while (0)
 
+#define __wait_event_freezable(wq, condition)                           \
+        ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0,          \
+                            schedule(); try_to_freeze())
+
+/**
+ * wait_event - sleep (or freeze) until a condition gets true
+ * @wq: the waitqueue to wait on
+ * @condition: a C expression for the event to wait for
+ *
+ * The process is put to sleep (TASK_INTERRUPTIBLE -- so as not to contribute
+ * to system load) until the @condition evaluates to true. The
+ * @condition is checked each time the waitqueue @wq is woken up.
+ *
+ * wake_up() has to be called after changing any variable that could
+ * change the result of the wait condition.
+ */
+#define wait_event_freezable(wq, condition)                             \
+({                                                                      \
+        int __ret = 0;                                                  \
+        might_sleep();                                                  \
+        if (!(condition))                                               \
+                __ret = __wait_event_freezable(wq, condition);          \
+        __ret;                                                          \
+})
+
 #define __wait_event_timeout(wq, condition, timeout)                    \
         ___wait_event(wq, ___wait_cond_timeout(condition),              \
                       TASK_UNINTERRUPTIBLE, 0, timeout,                 \
@@ -280,18 +310,39 @@ do {									\
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
- * The function returns 0 if the @timeout elapsed, or the remaining
- * jiffies (at least 1) if the @condition evaluated to %true before
- * the @timeout elapsed.
+ * Returns:
+ * 0 if the @condition evaluated to %false after the @timeout elapsed,
+ * 1 if the @condition evaluated to %true after the @timeout elapsed,
+ * or the remaining jiffies (at least 1) if the @condition evaluated
+ * to %true before the @timeout elapsed.
  */
 #define wait_event_timeout(wq, condition, timeout)                      \
 ({                                                                      \
         long __ret = timeout;                                           \
+        might_sleep();                                                  \
         if (!___wait_cond_timeout(condition))                           \
                 __ret = __wait_event_timeout(wq, condition, timeout);   \
         __ret;                                                          \
 })
 
+#define __wait_event_freezable_timeout(wq, condition, timeout)          \
+        ___wait_event(wq, ___wait_cond_timeout(condition),              \
+                      TASK_INTERRUPTIBLE, 0, timeout,                   \
+                      __ret = schedule_timeout(__ret); try_to_freeze())
+
+/*
+ * like wait_event_timeout() -- except it uses TASK_INTERRUPTIBLE to avoid
+ * increasing load and is freezable.
+ */
+#define wait_event_freezable_timeout(wq, condition, timeout)            \
+({                                                                      \
+        long __ret = timeout;                                           \
+        might_sleep();                                                  \
+        if (!___wait_cond_timeout(condition))                           \
+                __ret = __wait_event_freezable_timeout(wq, condition, timeout); \
+        __ret;                                                          \
+})
+
 #define __wait_event_cmd(wq, condition, cmd1, cmd2)                     \
         (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,  \
                             cmd1; schedule(); cmd2)
@@ -312,6 +363,7 @@ do {									\
  */
 #define wait_event_cmd(wq, condition, cmd1, cmd2)                       \
 do {                                                                    \
+        might_sleep();                                                  \
         if (condition)                                                  \
                 break;                                                  \
         __wait_event_cmd(wq, condition, cmd1, cmd2);                    \
@@ -339,6 +391,7 @@ do {									\
 #define wait_event_interruptible(wq, condition)                         \
 ({                                                                      \
         int __ret = 0;                                                  \
+        might_sleep();                                                  \
         if (!(condition))                                               \
                 __ret = __wait_event_interruptible(wq, condition);      \
         __ret;                                                          \
@@ -363,13 +416,16 @@ do {									\
  * change the result of the wait condition.
  *
  * Returns:
- * 0 if the @timeout elapsed, -%ERESTARTSYS if it was interrupted by
- * a signal, or the remaining jiffies (at least 1) if the @condition
- * evaluated to %true before the @timeout elapsed.
+ * 0 if the @condition evaluated to %false after the @timeout elapsed,
+ * 1 if the @condition evaluated to %true after the @timeout elapsed,
+ * the remaining jiffies (at least 1) if the @condition evaluated
+ * to %true before the @timeout elapsed, or -%ERESTARTSYS if it was
+ * interrupted by a signal.
  */
 #define wait_event_interruptible_timeout(wq, condition, timeout)        \
 ({                                                                      \
         long __ret = timeout;                                           \
+        might_sleep();                                                  \
         if (!___wait_cond_timeout(condition))                           \
                 __ret = __wait_event_interruptible_timeout(wq,          \
                                                 condition, timeout);    \
@@ -420,6 +476,7 @@ do {									\
 #define wait_event_hrtimeout(wq, condition, timeout)                    \
 ({                                                                      \
         int __ret = 0;                                                  \
+        might_sleep();                                                  \
         if (!(condition))                                               \
                 __ret = __wait_event_hrtimeout(wq, condition, timeout,  \
                                                TASK_UNINTERRUPTIBLE);   \
@@ -445,6 +502,7 @@ do {									\
 #define wait_event_interruptible_hrtimeout(wq, condition, timeout)      \
 ({                                                                      \
         long __ret = 0;                                                 \
+        might_sleep();                                                  \
         if (!(condition))                                               \
                 __ret = __wait_event_hrtimeout(wq, condition, timeout,  \
                                                TASK_INTERRUPTIBLE);     \
@@ -458,12 +516,27 @@ do {									\
 #define wait_event_interruptible_exclusive(wq, condition)               \
 ({                                                                      \
         int __ret = 0;                                                  \
+        might_sleep();                                                  \
         if (!(condition))                                               \
                 __ret = __wait_event_interruptible_exclusive(wq, condition);\
         __ret;                                                          \
 })
 
 
+#define __wait_event_freezable_exclusive(wq, condition)                 \
+        ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0,          \
+                        schedule(); try_to_freeze())
+
+#define wait_event_freezable_exclusive(wq, condition)                   \
+({                                                                      \
+        int __ret = 0;                                                  \
+        might_sleep();                                                  \
+        if (!(condition))                                               \
+                __ret = __wait_event_freezable_exclusive(wq, condition);\
+        __ret;                                                          \
+})
+
+
 #define __wait_event_interruptible_locked(wq, condition, exclusive, irq) \
 ({                                                                      \
         int __ret = 0;                                                  \
@@ -632,6 +705,7 @@ do {									\
 #define wait_event_killable(wq, condition)                              \
 ({                                                                      \
         int __ret = 0;                                                  \
+        might_sleep();                                                  \
         if (!(condition))                                               \
                 __ret = __wait_event_killable(wq, condition);           \
         __ret;                                                          \
@@ -825,6 +899,8 @@ void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int sta
 long prepare_to_wait_event(wait_queue_head_t *q, wait_queue_t *wait, int state);
 void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
 void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait, unsigned int mode, void *key);
+long wait_woken(wait_queue_t *wait, unsigned mode, long timeout);
+int woken_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 
@@ -859,6 +935,8 @@ int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 
 extern int bit_wait(struct wait_bit_key *);
 extern int bit_wait_io(struct wait_bit_key *);
+extern int bit_wait_timeout(struct wait_bit_key *);
+extern int bit_wait_io_timeout(struct wait_bit_key *);
 
 /**
  * wait_on_bit - wait for a bit to be cleared
@@ -879,6 +957,7 @@ extern int bit_wait_io(struct wait_bit_key *);
 static inline int
 wait_on_bit(void *word, int bit, unsigned mode)
 {
+        might_sleep();
         if (!test_bit(bit, word))
                 return 0;
         return out_of_line_wait_on_bit(word, bit,
@@ -903,6 +982,7 @@ wait_on_bit(void *word, int bit, unsigned mode)
 static inline int
 wait_on_bit_io(void *word, int bit, unsigned mode)
 {
+        might_sleep();
         if (!test_bit(bit, word))
                 return 0;
         return out_of_line_wait_on_bit(word, bit,
@@ -929,6 +1009,7 @@ wait_on_bit_io(void *word, int bit, unsigned mode)
 static inline int
 wait_on_bit_action(void *word, int bit, wait_bit_action_f *action, unsigned mode)
 {
+        might_sleep();
         if (!test_bit(bit, word))
                 return 0;
         return out_of_line_wait_on_bit(word, bit, action, mode);
@@ -956,6 +1037,7 @@ wait_on_bit_action(void *word, int bit, wait_bit_action_f *action, unsigned mode
 static inline int
 wait_on_bit_lock(void *word, int bit, unsigned mode)
 {
+        might_sleep();
         if (!test_and_set_bit(bit, word))
                 return 0;
         return out_of_line_wait_on_bit_lock(word, bit, bit_wait, mode);
@@ -979,6 +1061,7 @@ wait_on_bit_lock(void *word, int bit, unsigned mode)
 static inline int
 wait_on_bit_lock_io(void *word, int bit, unsigned mode)
 {
+        might_sleep();
         if (!test_and_set_bit(bit, word))
                 return 0;
         return out_of_line_wait_on_bit_lock(word, bit, bit_wait_io, mode);
@@ -1004,6 +1087,7 @@ wait_on_bit_lock_io(void *word, int bit, unsigned mode)
 static inline int
 wait_on_bit_lock_action(void *word, int bit, wait_bit_action_f *action, unsigned mode)
 {
+        might_sleep();
         if (!test_and_set_bit(bit, word))
                 return 0;
         return out_of_line_wait_on_bit_lock(word, bit, action, mode);
@@ -1022,6 +1106,7 @@ wait_on_bit_lock_action(void *word, int bit, wait_bit_action_f *action, unsigned
 static inline
 int wait_on_atomic_t(atomic_t *val, int (*action)(atomic_t *), unsigned mode)
 {
+        might_sleep();
         if (atomic_read(val) == 0)
                 return 0;
         return out_of_line_wait_on_atomic_t(val, action, mode);
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index 2a3038ee17a3..395b70e0eccf 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -97,13 +97,8 @@ struct watchdog_device {
 #define WDOG_UNREGISTERED       4       /* Has the device been unregistered */
 };
 
-#ifdef CONFIG_WATCHDOG_NOWAYOUT
-#define WATCHDOG_NOWAYOUT               1
-#define WATCHDOG_NOWAYOUT_INIT_STATUS   (1 << WDOG_NO_WAY_OUT)
-#else
-#define WATCHDOG_NOWAYOUT               0
-#define WATCHDOG_NOWAYOUT_INIT_STATUS   0
-#endif
+#define WATCHDOG_NOWAYOUT               IS_BUILTIN(CONFIG_WATCHDOG_NOWAYOUT)
+#define WATCHDOG_NOWAYOUT_INIT_STATUS   (WATCHDOG_NOWAYOUT << WDOG_NO_WAY_OUT)
 
 /* Use the following function to check whether or not the watchdog is active */
 static inline bool watchdog_active(struct watchdog_device *wdd)
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index a219be961c0a..00048339c23e 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -177,7 +177,6 @@ int write_cache_pages(struct address_space *mapping,
                       struct writeback_control *wbc, writepage_t writepage,
                       void *data);
 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
-void set_page_dirty_balance(struct page *page);
 void writeback_set_ratelimit(void);
 void tag_pages_for_writeback(struct address_space *mapping,
                              pgoff_t start, pgoff_t end);
diff --git a/include/linux/zsmalloc.h b/include/linux/zsmalloc.h
index e44d634e7fb7..05c214760977 100644
--- a/include/linux/zsmalloc.h
+++ b/include/linux/zsmalloc.h
@@ -46,6 +46,6 @@ void *zs_map_object(struct zs_pool *pool, unsigned long handle,
                         enum zs_mapmode mm);
 void zs_unmap_object(struct zs_pool *pool, unsigned long handle);
 
-u64 zs_get_total_size_bytes(struct zs_pool *pool);
+unsigned long zs_get_total_pages(struct zs_pool *pool);
 
 #endif