293 files changed, 18315 insertions, 4829 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index f57c440642cd..d2445fa9999f 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -53,11 +53,24 @@ static inline acpi_handle acpi_device_handle(struct acpi_device *adev)
         return adev ? adev->handle : NULL;
 }
 
-#define ACPI_COMPANION(dev)             acpi_node((dev)->fwnode)
+#define ACPI_COMPANION(dev)             to_acpi_node((dev)->fwnode)
 #define ACPI_COMPANION_SET(dev, adev)   set_primary_fwnode(dev, (adev) ? \
         acpi_fwnode_handle(adev) : NULL)
 #define ACPI_HANDLE(dev)                acpi_device_handle(ACPI_COMPANION(dev))
 
+/**
+ * ACPI_DEVICE_CLASS - macro used to describe an ACPI device with
+ * the PCI-defined class-code information
+ *
+ * @_cls : the class, subclass, prog-if triple for this device
+ * @_msk : the class mask for this device
+ *
+ * This macro is used to create a struct acpi_device_id that matches a
+ * specific PCI class. The .id and .driver_data fields will be left
+ * initialized with the default value.
+ */
+#define ACPI_DEVICE_CLASS(_cls, _msk)   .cls = (_cls), .cls_msk = (_msk),
+
 static inline bool has_acpi_companion(struct device *dev)
 {
         return is_acpi_node(dev->fwnode);
@@ -158,6 +171,16 @@ typedef u32 phys_cpuid_t;
 #define PHYS_CPUID_INVALID (phys_cpuid_t)(-1)
 #endif
 
+static inline bool invalid_logical_cpuid(u32 cpuid)
+{
+        return (int)cpuid < 0;
+}
+
+static inline bool invalid_phys_cpuid(phys_cpuid_t phys_id)
+{
+        return phys_id == PHYS_CPUID_INVALID;
+}
+
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 /* Arch dependent functions for cpu hotplug support */
 int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, int *pcpu);
@@ -243,54 +266,21 @@ extern bool wmi_has_guid(const char *guid);
 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VENDOR          0x0400
 #define ACPI_VIDEO_OUTPUT_SWITCHING_DMI_VIDEO           0x0800
 
-#if defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE)
-
-extern long acpi_video_get_capabilities(acpi_handle graphics_dev_handle);
+extern char acpi_video_backlight_string[];
 extern long acpi_is_video_device(acpi_handle handle);
-extern void acpi_video_dmi_promote_vendor(void);
-extern void acpi_video_dmi_demote_vendor(void);
-extern int acpi_video_backlight_support(void);
-extern int acpi_video_display_switch_support(void);
-
-#else
-
-static inline long acpi_video_get_capabilities(acpi_handle graphics_dev_handle)
-{
-        return 0;
-}
-
-static inline long acpi_is_video_device(acpi_handle handle)
-{
-        return 0;
-}
-
-static inline void acpi_video_dmi_promote_vendor(void)
-{
-}
-
-static inline void acpi_video_dmi_demote_vendor(void)
-{
-}
-
-static inline int acpi_video_backlight_support(void)
-{
-        return 0;
-}
-
-static inline int acpi_video_display_switch_support(void)
-{
-        return 0;
-}
-
-#endif /* defined(CONFIG_ACPI_VIDEO) || defined(CONFIG_ACPI_VIDEO_MODULE) */
-
 extern int acpi_blacklisted(void);
 extern void acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d);
 extern void acpi_osi_setup(char *str);
+extern bool acpi_osi_is_win8(void);
 
 #ifdef CONFIG_ACPI_NUMA
+int acpi_map_pxm_to_online_node(int pxm);
 int acpi_get_node(acpi_handle handle);
 #else
+static inline int acpi_map_pxm_to_online_node(int pxm)
+{
+        return 0;
+}
 static inline int acpi_get_node(acpi_handle handle)
 {
         return 0;
@@ -440,6 +430,7 @@ extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
 #define ACPI_OST_SC_INSERT_NOT_SUPPORTED        0x82
 
 extern void acpi_early_init(void);
+extern void acpi_subsystem_init(void);
 
 extern int acpi_nvs_register(__u64 start, __u64 size);
 
@@ -465,6 +456,7 @@ struct platform_device *acpi_create_platform_device(struct acpi_device *);
 #define ACPI_COMPANION(dev)             (NULL)
 #define ACPI_COMPANION_SET(dev, adev)   do { } while (0)
 #define ACPI_HANDLE(dev)                (NULL)
+#define ACPI_DEVICE_CLASS(_cls, _msk)   .cls = (0), .cls_msk = (0),
 
 struct fwnode_handle;
 
@@ -473,7 +465,7 @@ static inline bool is_acpi_node(struct fwnode_handle *fwnode)
         return false;
 }
 
-static inline struct acpi_device *acpi_node(struct fwnode_handle *fwnode)
+static inline struct acpi_device *to_acpi_node(struct fwnode_handle *fwnode)
 {
         return NULL;
 }
@@ -494,6 +486,7 @@ static inline const char *acpi_dev_name(struct acpi_device *adev)
 }
 
 static inline void acpi_early_init(void) { }
+static inline void acpi_subsystem_init(void) { }
 
 static inline int early_acpi_boot_init(void)
 {
@@ -569,6 +562,11 @@ static inline int acpi_device_modalias(struct device *dev,
         return -ENODEV;
 }
 
+static inline bool acpi_check_dma(struct acpi_device *adev, bool *coherent)
+{
+        return false;
+}
+
 #define ACPI_PTR(_ptr)  (NULL)
 
 #endif  /* !CONFIG_ACPI */
diff --git a/include/linux/amba/sp810.h b/include/linux/amba/sp810.h
index c7df89f99115..58fe9e8b6fd7 100644
--- a/include/linux/amba/sp810.h
+++ b/include/linux/amba/sp810.h
@@ -2,7 +2,7 @@
  * ARM PrimeXsys System Controller SP810 header file
  *
  * Copyright (C) 2009 ST Microelectronics
- * Viresh Kumar <viresh.linux@gmail.com>
+ * Viresh Kumar <vireshk@kernel.org>
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2. This program is licensed "as is" without any
diff --git a/include/linux/ata.h b/include/linux/ata.h
index b666b773e111..6c78956aa470 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -45,6 +45,7 @@ enum {
         ATA_SECT_SIZE           = 512,
         ATA_MAX_SECTORS_128     = 128,
         ATA_MAX_SECTORS         = 256,
+        ATA_MAX_SECTORS_1024    = 1024,
         ATA_MAX_SECTORS_LBA48   = 65535,/* TODO: 65536? */
         ATA_MAX_SECTORS_TAPE    = 65535,
 
@@ -704,9 +705,19 @@ static inline bool ata_id_wcache_enabled(const u16 *id)
 
 static inline bool ata_id_has_read_log_dma_ext(const u16 *id)
 {
+        /* Word 86 must have bit 15 set */
         if (!(id[ATA_ID_CFS_ENABLE_2] & (1 << 15)))
                 return false;
-        return id[ATA_ID_COMMAND_SET_3] & (1 << 3);
+
+        /* READ LOG DMA EXT support can be signaled either from word 119
+         * or from word 120. The format is the same for both words: Bit
+         * 15 must be cleared, bit 14 set and bit 3 set.
+         */
+        if ((id[ATA_ID_COMMAND_SET_3] & 0xC008) == 0x4008 ||
+            (id[ATA_ID_COMMAND_SET_4] & 0xC008) == 0x4008)
+                return true;
+
+        return false;
 }
 
 static inline bool ata_id_has_sense_reporting(const u16 *id)
diff --git a/include/linux/backing-dev-defs.h b/include/linux/backing-dev-defs.h
new file mode 100644
index 000000000000..a23209b43842
--- /dev/null
+++ b/include/linux/backing-dev-defs.h
@@ -0,0 +1,256 @@
+#ifndef __LINUX_BACKING_DEV_DEFS_H
+#define __LINUX_BACKING_DEV_DEFS_H
+
+#include <linux/list.h>
+#include <linux/radix-tree.h>
+#include <linux/rbtree.h>
+#include <linux/spinlock.h>
+#include <linux/percpu_counter.h>
+#include <linux/percpu-refcount.h>
+#include <linux/flex_proportions.h>
+#include <linux/timer.h>
+#include <linux/workqueue.h>
+
+struct page;
+struct device;
+struct dentry;
+
+/*
+ * Bits in bdi_writeback.state
+ */
+enum wb_state {
+        WB_registered,          /* bdi_register() was done */
+        WB_writeback_running,   /* Writeback is in progress */
+        WB_has_dirty_io,        /* Dirty inodes on ->b_{dirty|io|more_io} */
+};
+
+enum wb_congested_state {
+        WB_async_congested,     /* The async (write) queue is getting full */
+        WB_sync_congested,      /* The sync queue is getting full */
+};
+
+typedef int (congested_fn)(void *, int);
+
+enum wb_stat_item {
+        WB_RECLAIMABLE,
+        WB_WRITEBACK,
+        WB_DIRTIED,
+        WB_WRITTEN,
+        NR_WB_STAT_ITEMS
+};
+
+#define WB_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
+
+/*
+ * For cgroup writeback, multiple wb's may map to the same blkcg.  Those
+ * wb's can operate mostly independently but should share the congested
+ * state.  To facilitate such sharing, the congested state is tracked using
+ * the following struct which is created on demand, indexed by blkcg ID on
+ * its bdi, and refcounted.
+ */
+struct bdi_writeback_congested {
+        unsigned long state;            /* WB_[a]sync_congested flags */
+        atomic_t refcnt;                /* nr of attached wb's and blkg */
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct backing_dev_info *bdi;   /* the associated bdi */
+        int blkcg_id;                   /* ID of the associated blkcg */
+        struct rb_node rb_node;         /* on bdi->cgwb_congestion_tree */
+#endif
+};
+
+/*
+ * Each wb (bdi_writeback) can perform writeback operations, is measured
+ * and throttled, independently.  Without cgroup writeback, each bdi
+ * (bdi_writeback) is served by its embedded bdi->wb.
+ *
+ * On the default hierarchy, blkcg implicitly enables memcg.  This allows
+ * using memcg's page ownership for attributing writeback IOs, and every
+ * memcg - blkcg combination can be served by its own wb by assigning a
+ * dedicated wb to each memcg, which enables isolation across different
+ * cgroups and propagation of IO back pressure down from the IO layer upto
+ * the tasks which are generating the dirty pages to be written back.
+ *
+ * A cgroup wb is indexed on its bdi by the ID of the associated memcg,
+ * refcounted with the number of inodes attached to it, and pins the memcg
+ * and the corresponding blkcg.  As the corresponding blkcg for a memcg may
+ * change as blkcg is disabled and enabled higher up in the hierarchy, a wb
+ * is tested for blkcg after lookup and removed from index on mismatch so
+ * that a new wb for the combination can be created.
+ */
+struct bdi_writeback {
+        struct backing_dev_info *bdi;   /* our parent bdi */
+
+        unsigned long state;            /* Always use atomic bitops on this */
+        unsigned long last_old_flush;   /* last old data flush */
+
+        struct list_head b_dirty;       /* dirty inodes */
+        struct list_head b_io;          /* parked for writeback */
+        struct list_head b_more_io;     /* parked for more writeback */
+        struct list_head b_dirty_time;  /* time stamps are dirty */
+        spinlock_t list_lock;           /* protects the b_* lists */
+
+        struct percpu_counter stat[NR_WB_STAT_ITEMS];
+
+        struct bdi_writeback_congested *congested;
+
+        unsigned long bw_time_stamp;    /* last time write bw is updated */
+        unsigned long dirtied_stamp;
+        unsigned long written_stamp;    /* pages written at bw_time_stamp */
+        unsigned long write_bandwidth;  /* the estimated write bandwidth */
+        unsigned long avg_write_bandwidth; /* further smoothed write bw, > 0 */
+
+        /*
+         * The base dirty throttle rate, re-calculated on every 200ms.
+         * All the bdi tasks' dirty rate will be curbed under it.
+         * @dirty_ratelimit tracks the estimated @balanced_dirty_ratelimit
+         * in small steps and is much more smooth/stable than the latter.
+         */
+        unsigned long dirty_ratelimit;
+        unsigned long balanced_dirty_ratelimit;
+
+        struct fprop_local_percpu completions;
+        int dirty_exceeded;
+
+        spinlock_t work_lock;           /* protects work_list & dwork scheduling */
+        struct list_head work_list;
+        struct delayed_work dwork;      /* work item used for writeback */
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct percpu_ref refcnt;       /* used only for !root wb's */
+        struct fprop_local_percpu memcg_completions;
+        struct cgroup_subsys_state *memcg_css; /* the associated memcg */
+        struct cgroup_subsys_state *blkcg_css; /* and blkcg */
+        struct list_head memcg_node;    /* anchored at memcg->cgwb_list */
+        struct list_head blkcg_node;    /* anchored at blkcg->cgwb_list */
+
+        union {
+                struct work_struct release_work;
+                struct rcu_head rcu;
+        };
+#endif
+};
+
+struct backing_dev_info {
+        struct list_head bdi_list;
+        unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
+        unsigned int capabilities; /* Device capabilities */
+        congested_fn *congested_fn; /* Function pointer if device is md/dm */
+        void *congested_data;   /* Pointer to aux data for congested func */
+
+        char *name;
+
+        unsigned int min_ratio;
+        unsigned int max_ratio, max_prop_frac;
+
+        /*
+         * Sum of avg_write_bw of wbs with dirty inodes.  > 0 if there are
+         * any dirty wbs, which is depended upon by bdi_has_dirty().
+         */
+        atomic_long_t tot_write_bandwidth;
+
+        struct bdi_writeback wb;  /* the root writeback info for this bdi */
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct radix_tree_root cgwb_tree; /* radix tree of active cgroup wbs */
+        struct rb_root cgwb_congested_tree; /* their congested states */
+        atomic_t usage_cnt; /* counts both cgwbs and cgwb_contested's */
+#else
+        struct bdi_writeback_congested *wb_congested;
+#endif
+        wait_queue_head_t wb_waitq;
+
+        struct device *dev;
+
+        struct timer_list laptop_mode_wb_timer;
+
+#ifdef CONFIG_DEBUG_FS
+        struct dentry *debug_dir;
+        struct dentry *debug_stats;
+#endif
+};
+
+enum {
+        BLK_RW_ASYNC    = 0,
+        BLK_RW_SYNC     = 1,
+};
+
+void clear_wb_congested(struct bdi_writeback_congested *congested, int sync);
+void set_wb_congested(struct bdi_writeback_congested *congested, int sync);
+
+static inline void clear_bdi_congested(struct backing_dev_info *bdi, int sync)
+{
+        clear_wb_congested(bdi->wb.congested, sync);
+}
+
+static inline void set_bdi_congested(struct backing_dev_info *bdi, int sync)
+{
+        set_wb_congested(bdi->wb.congested, sync);
+}
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+/**
+ * wb_tryget - try to increment a wb's refcount
+ * @wb: bdi_writeback to get
+ */
+static inline bool wb_tryget(struct bdi_writeback *wb)
+{
+        if (wb != &wb->bdi->wb)
+                return percpu_ref_tryget(&wb->refcnt);
+        return true;
+}
+
+/**
+ * wb_get - increment a wb's refcount
+ * @wb: bdi_writeback to get
+ */
+static inline void wb_get(struct bdi_writeback *wb)
+{
+        if (wb != &wb->bdi->wb)
+                percpu_ref_get(&wb->refcnt);
+}
+
+/**
+ * wb_put - decrement a wb's refcount
+ * @wb: bdi_writeback to put
+ */
+static inline void wb_put(struct bdi_writeback *wb)
+{
+        if (wb != &wb->bdi->wb)
+                percpu_ref_put(&wb->refcnt);
+}
+
+/**
+ * wb_dying - is a wb dying?
+ * @wb: bdi_writeback of interest
+ *
+ * Returns whether @wb is unlinked and being drained.
+ */
+static inline bool wb_dying(struct bdi_writeback *wb)
+{
+        return percpu_ref_is_dying(&wb->refcnt);
+}
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline bool wb_tryget(struct bdi_writeback *wb)
+{
+        return true;
+}
+
+static inline void wb_get(struct bdi_writeback *wb)
+{
+}
+
+static inline void wb_put(struct bdi_writeback *wb)
+{
+}
+
+static inline bool wb_dying(struct bdi_writeback *wb)
+{
+        return false;
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
+#endif  /* __LINUX_BACKING_DEV_DEFS_H */
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index d87d8eced064..0fe9df983ab7 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -8,106 +8,14 @@
 #ifndef _LINUX_BACKING_DEV_H
 #define _LINUX_BACKING_DEV_H
 
-#include <linux/percpu_counter.h>
-#include <linux/log2.h>
-#include <linux/flex_proportions.h>
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/sched.h>
-#include <linux/timer.h>
+#include <linux/blkdev.h>
 #include <linux/writeback.h>
-#include <linux/atomic.h>
-#include <linux/sysctl.h>
-#include <linux/workqueue.h>
-
-struct page;
-struct device;
-struct dentry;
-
-/*
- * Bits in backing_dev_info.state
- */
-enum bdi_state {
-        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 */
-};
-
-typedef int (congested_fn)(void *, int);
-
-enum bdi_stat_item {
-        BDI_RECLAIMABLE,
-        BDI_WRITEBACK,
-        BDI_DIRTIED,
-        BDI_WRITTEN,
-        NR_BDI_STAT_ITEMS
-};
-
-#define BDI_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))
-
-struct bdi_writeback {
-        struct backing_dev_info *bdi;   /* our parent bdi */
-
-        unsigned long last_old_flush;   /* last old data flush */
-
-        struct delayed_work dwork;      /* work item used for writeback */
-        struct list_head b_dirty;       /* dirty inodes */
-        struct list_head b_io;          /* parked for writeback */
-        struct list_head b_more_io;     /* parked for more writeback */
-        struct list_head b_dirty_time;  /* time stamps are dirty */
-        spinlock_t list_lock;           /* protects the b_* lists */
-};
-
-struct backing_dev_info {
-        struct list_head bdi_list;
-        unsigned long ra_pages; /* max readahead in PAGE_CACHE_SIZE units */
-        unsigned long state;    /* Always use atomic bitops on this */
-        unsigned int capabilities; /* Device capabilities */
-        congested_fn *congested_fn; /* Function pointer if device is md/dm */
-        void *congested_data;   /* Pointer to aux data for congested func */
-
-        char *name;
-
-        struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
-
-        unsigned long bw_time_stamp;    /* last time write bw is updated */
-        unsigned long dirtied_stamp;
-        unsigned long written_stamp;    /* pages written at bw_time_stamp */
-        unsigned long write_bandwidth;  /* the estimated write bandwidth */
-        unsigned long avg_write_bandwidth; /* further smoothed write bw */
-
-        /*
-         * The base dirty throttle rate, re-calculated on every 200ms.
-         * All the bdi tasks' dirty rate will be curbed under it.
-         * @dirty_ratelimit tracks the estimated @balanced_dirty_ratelimit
-         * in small steps and is much more smooth/stable than the latter.
-         */
-        unsigned long dirty_ratelimit;
-        unsigned long balanced_dirty_ratelimit;
-
-        struct fprop_local_percpu completions;
-        int dirty_exceeded;
-
-        unsigned int min_ratio;
-        unsigned int max_ratio, max_prop_frac;
-
-        struct bdi_writeback wb;  /* default writeback info for this bdi */
-        spinlock_t wb_lock;       /* protects work_list & wb.dwork scheduling */
-
-        struct list_head work_list;
-
-        struct device *dev;
-
-        struct timer_list laptop_mode_wb_timer;
-
-#ifdef CONFIG_DEBUG_FS
-        struct dentry *debug_dir;
-        struct dentry *debug_stats;
-#endif
-};
-
-struct backing_dev_info *inode_to_bdi(struct inode *inode);
+#include <linux/blk-cgroup.h>
+#include <linux/backing-dev-defs.h>
+#include <linux/slab.h>
 
 int __must_check bdi_init(struct backing_dev_info *bdi);
 void bdi_destroy(struct backing_dev_info *bdi);
@@ -117,97 +25,99 @@ int bdi_register(struct backing_dev_info *bdi, struct device *parent,
                 const char *fmt, ...);
 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
 int __must_check bdi_setup_and_register(struct backing_dev_info *, char *);
-void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages,
-                        enum wb_reason reason);
-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 wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
+                        bool range_cyclic, enum wb_reason reason);
+void wb_start_background_writeback(struct bdi_writeback *wb);
+void wb_workfn(struct work_struct *work);
+void wb_wakeup_delayed(struct bdi_writeback *wb);
 
 extern spinlock_t bdi_lock;
 extern struct list_head bdi_list;
 
 extern struct workqueue_struct *bdi_wq;
 
-static inline int wb_has_dirty_io(struct bdi_writeback *wb)
+static inline bool wb_has_dirty_io(struct bdi_writeback *wb)
 {
-        return !list_empty(&wb->b_dirty) ||
-               !list_empty(&wb->b_io) ||
-               !list_empty(&wb->b_more_io);
+        return test_bit(WB_has_dirty_io, &wb->state);
+}
+
+static inline bool bdi_has_dirty_io(struct backing_dev_info *bdi)
+{
+        /*
+         * @bdi->tot_write_bandwidth is guaranteed to be > 0 if there are
+         * any dirty wbs.  See wb_update_write_bandwidth().
+         */
+        return atomic_long_read(&bdi->tot_write_bandwidth);
 }
 
-static inline void __add_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item, s64 amount)
+static inline void __add_wb_stat(struct bdi_writeback *wb,
+                                 enum wb_stat_item item, s64 amount)
 {
-        __percpu_counter_add(&bdi->bdi_stat[item], amount, BDI_STAT_BATCH);
+        __percpu_counter_add(&wb->stat[item], amount, WB_STAT_BATCH);
 }
 
-static inline void __inc_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void __inc_wb_stat(struct bdi_writeback *wb,
+                                 enum wb_stat_item item)
 {
-        __add_bdi_stat(bdi, item, 1);
+        __add_wb_stat(wb, item, 1);
 }
 
-static inline void inc_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void inc_wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 {
         unsigned long flags;
 
         local_irq_save(flags);
-        __inc_bdi_stat(bdi, item);
+        __inc_wb_stat(wb, item);
         local_irq_restore(flags);
 }
 
-static inline void __dec_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void __dec_wb_stat(struct bdi_writeback *wb,
+                                 enum wb_stat_item item)
 {
-        __add_bdi_stat(bdi, item, -1);
+        __add_wb_stat(wb, item, -1);
 }
 
-static inline void dec_bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline void dec_wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 {
         unsigned long flags;
 
         local_irq_save(flags);
-        __dec_bdi_stat(bdi, item);
+        __dec_wb_stat(wb, item);
         local_irq_restore(flags);
 }
 
-static inline s64 bdi_stat(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline s64 wb_stat(struct bdi_writeback *wb, enum wb_stat_item item)
 {
-        return percpu_counter_read_positive(&bdi->bdi_stat[item]);
+        return percpu_counter_read_positive(&wb->stat[item]);
 }
 
-static inline s64 __bdi_stat_sum(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline s64 __wb_stat_sum(struct bdi_writeback *wb,
+                                enum wb_stat_item item)
 {
-        return percpu_counter_sum_positive(&bdi->bdi_stat[item]);
+        return percpu_counter_sum_positive(&wb->stat[item]);
 }
 
-static inline s64 bdi_stat_sum(struct backing_dev_info *bdi,
-                enum bdi_stat_item item)
+static inline s64 wb_stat_sum(struct bdi_writeback *wb, enum wb_stat_item item)
 {
         s64 sum;
         unsigned long flags;
 
         local_irq_save(flags);
-        sum = __bdi_stat_sum(bdi, item);
+        sum = __wb_stat_sum(wb, item);
         local_irq_restore(flags);
 
         return sum;
 }
 
-extern void bdi_writeout_inc(struct backing_dev_info *bdi);
+extern void wb_writeout_inc(struct bdi_writeback *wb);
 
 /*
  * maximal error of a stat counter.
  */
-static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
+static inline unsigned long wb_stat_error(struct bdi_writeback *wb)
 {
 #ifdef CONFIG_SMP
-        return nr_cpu_ids * BDI_STAT_BATCH;
+        return nr_cpu_ids * WB_STAT_BATCH;
 #else
         return 1;
 #endif
@@ -231,50 +141,57 @@ int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
  * BDI_CAP_NO_WRITEBACK:   Don't write pages back
  * BDI_CAP_NO_ACCT_WB:     Don't automatically account writeback pages
  * BDI_CAP_STRICTLIMIT:    Keep number of dirty pages below bdi threshold.
+ *
+ * BDI_CAP_CGROUP_WRITEBACK: Supports cgroup-aware writeback.
  */
 #define BDI_CAP_NO_ACCT_DIRTY   0x00000001
 #define BDI_CAP_NO_WRITEBACK    0x00000002
 #define BDI_CAP_NO_ACCT_WB      0x00000004
 #define BDI_CAP_STABLE_WRITES   0x00000008
 #define BDI_CAP_STRICTLIMIT     0x00000010
+#define BDI_CAP_CGROUP_WRITEBACK 0x00000020
 
 #define BDI_CAP_NO_ACCT_AND_WRITEBACK \
         (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB)
 
 extern struct backing_dev_info noop_backing_dev_info;
 
-int writeback_in_progress(struct backing_dev_info *bdi);
-
-static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
+/**
+ * writeback_in_progress - determine whether there is writeback in progress
+ * @wb: bdi_writeback of interest
+ *
+ * Determine whether there is writeback waiting to be handled against a
+ * bdi_writeback.
+ */
+static inline bool writeback_in_progress(struct bdi_writeback *wb)
 {
-        if (bdi->congested_fn)
-                return bdi->congested_fn(bdi->congested_data, bdi_bits);
-        return (bdi->state & bdi_bits);
+        return test_bit(WB_writeback_running, &wb->state);
 }
 
-static inline int bdi_read_congested(struct backing_dev_info *bdi)
+static inline struct backing_dev_info *inode_to_bdi(struct inode *inode)
 {
-        return bdi_congested(bdi, 1 << BDI_sync_congested);
-}
+        struct super_block *sb;
 
-static inline int bdi_write_congested(struct backing_dev_info *bdi)
-{
-        return bdi_congested(bdi, 1 << BDI_async_congested);
+        if (!inode)
+                return &noop_backing_dev_info;
+
+        sb = inode->i_sb;
+#ifdef CONFIG_BLOCK
+        if (sb_is_blkdev_sb(sb))
+                return blk_get_backing_dev_info(I_BDEV(inode));
+#endif
+        return sb->s_bdi;
 }
 
-static inline int bdi_rw_congested(struct backing_dev_info *bdi)
+static inline int wb_congested(struct bdi_writeback *wb, int cong_bits)
 {
-        return bdi_congested(bdi, (1 << BDI_sync_congested) |
-                                  (1 << BDI_async_congested));
-}
+        struct backing_dev_info *bdi = wb->bdi;
 
-enum {
-        BLK_RW_ASYNC    = 0,
-        BLK_RW_SYNC     = 1,
-};
+        if (bdi->congested_fn)
+                return bdi->congested_fn(bdi->congested_data, cong_bits);
+        return wb->congested->state & cong_bits;
+}
 
-void clear_bdi_congested(struct backing_dev_info *bdi, int sync);
-void set_bdi_congested(struct backing_dev_info *bdi, int sync);
 long congestion_wait(int sync, long timeout);
 long wait_iff_congested(struct zone *zone, int sync, long timeout);
 int pdflush_proc_obsolete(struct ctl_table *table, int write,
@@ -318,4 +235,336 @@ static inline int bdi_sched_wait(void *word)
         return 0;
 }
 
-#endif          /* _LINUX_BACKING_DEV_H */
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+struct bdi_writeback_congested *
+wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp);
+void wb_congested_put(struct bdi_writeback_congested *congested);
+struct bdi_writeback *wb_get_create(struct backing_dev_info *bdi,
+                                    struct cgroup_subsys_state *memcg_css,
+                                    gfp_t gfp);
+void wb_memcg_offline(struct mem_cgroup *memcg);
+void wb_blkcg_offline(struct blkcg *blkcg);
+int inode_congested(struct inode *inode, int cong_bits);
+
+/**
+ * inode_cgwb_enabled - test whether cgroup writeback is enabled on an inode
+ * @inode: inode of interest
+ *
+ * cgroup writeback requires support from both the bdi and filesystem.
+ * Test whether @inode has both.
+ */
+static inline bool inode_cgwb_enabled(struct inode *inode)
+{
+        struct backing_dev_info *bdi = inode_to_bdi(inode);
+
+        return bdi_cap_account_dirty(bdi) &&
+                (bdi->capabilities & BDI_CAP_CGROUP_WRITEBACK) &&
+                (inode->i_sb->s_iflags & SB_I_CGROUPWB);
+}
+
+/**
+ * wb_find_current - find wb for %current on a bdi
+ * @bdi: bdi of interest
+ *
+ * Find the wb of @bdi which matches both the memcg and blkcg of %current.
+ * Must be called under rcu_read_lock() which protects the returend wb.
+ * NULL if not found.
+ */
+static inline struct bdi_writeback *wb_find_current(struct backing_dev_info *bdi)
+{
+        struct cgroup_subsys_state *memcg_css;
+        struct bdi_writeback *wb;
+
+        memcg_css = task_css(current, memory_cgrp_id);
+        if (!memcg_css->parent)
+                return &bdi->wb;
+
+        wb = radix_tree_lookup(&bdi->cgwb_tree, memcg_css->id);
+
+        /*
+         * %current's blkcg equals the effective blkcg of its memcg.  No
+         * need to use the relatively expensive cgroup_get_e_css().
+         */
+        if (likely(wb && wb->blkcg_css == task_css(current, blkio_cgrp_id)))
+                return wb;
+        return NULL;
+}
+
+/**
+ * wb_get_create_current - get or create wb for %current on a bdi
+ * @bdi: bdi of interest
+ * @gfp: allocation mask
+ *
+ * Equivalent to wb_get_create() on %current's memcg.  This function is
+ * called from a relatively hot path and optimizes the common cases using
+ * wb_find_current().
+ */
+static inline struct bdi_writeback *
+wb_get_create_current(struct backing_dev_info *bdi, gfp_t gfp)
+{
+        struct bdi_writeback *wb;
+
+        rcu_read_lock();
+        wb = wb_find_current(bdi);
+        if (wb && unlikely(!wb_tryget(wb)))
+                wb = NULL;
+        rcu_read_unlock();
+
+        if (unlikely(!wb)) {
+                struct cgroup_subsys_state *memcg_css;
+
+                memcg_css = task_get_css(current, memory_cgrp_id);
+                wb = wb_get_create(bdi, memcg_css, gfp);
+                css_put(memcg_css);
+        }
+        return wb;
+}
+
+/**
+ * inode_to_wb_is_valid - test whether an inode has a wb associated
+ * @inode: inode of interest
+ *
+ * Returns %true if @inode has a wb associated.  May be called without any
+ * locking.
+ */
+static inline bool inode_to_wb_is_valid(struct inode *inode)
+{
+        return inode->i_wb;
+}
+
+/**
+ * inode_to_wb - determine the wb of an inode
+ * @inode: inode of interest
+ *
+ * Returns the wb @inode is currently associated with.  The caller must be
+ * holding either @inode->i_lock, @inode->i_mapping->tree_lock, or the
+ * associated wb's list_lock.
+ */
+static inline struct bdi_writeback *inode_to_wb(struct inode *inode)
+{
+#ifdef CONFIG_LOCKDEP
+        WARN_ON_ONCE(debug_locks &&
+                     (!lockdep_is_held(&inode->i_lock) &&
+                      !lockdep_is_held(&inode->i_mapping->tree_lock) &&
+                      !lockdep_is_held(&inode->i_wb->list_lock)));
+#endif
+        return inode->i_wb;
+}
+
+/**
+ * unlocked_inode_to_wb_begin - begin unlocked inode wb access transaction
+ * @inode: target inode
+ * @lockedp: temp bool output param, to be passed to the end function
+ *
+ * The caller wants to access the wb associated with @inode but isn't
+ * holding inode->i_lock, mapping->tree_lock or wb->list_lock.  This
+ * function determines the wb associated with @inode and ensures that the
+ * association doesn't change until the transaction is finished with
+ * unlocked_inode_to_wb_end().
+ *
+ * The caller must call unlocked_inode_to_wb_end() with *@lockdep
+ * afterwards and can't sleep during transaction.  IRQ may or may not be
+ * disabled on return.
+ */
+static inline struct bdi_writeback *
+unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
+{
+        rcu_read_lock();
+
+        /*
+         * Paired with store_release in inode_switch_wb_work_fn() and
+         * ensures that we see the new wb if we see cleared I_WB_SWITCH.
+         */
+        *lockedp = smp_load_acquire(&inode->i_state) & I_WB_SWITCH;
+
+        if (unlikely(*lockedp))
+                spin_lock_irq(&inode->i_mapping->tree_lock);
+
+        /*
+         * Protected by either !I_WB_SWITCH + rcu_read_lock() or tree_lock.
+         * inode_to_wb() will bark.  Deref directly.
+         */
+        return inode->i_wb;
+}
+
+/**
+ * unlocked_inode_to_wb_end - end inode wb access transaction
+ * @inode: target inode
+ * @locked: *@lockedp from unlocked_inode_to_wb_begin()
+ */
+static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
+{
+        if (unlikely(locked))
+                spin_unlock_irq(&inode->i_mapping->tree_lock);
+
+        rcu_read_unlock();
+}
+
+struct wb_iter {
+        int                     start_blkcg_id;
+        struct radix_tree_iter  tree_iter;
+        void                    **slot;
+};
+
+static inline struct bdi_writeback *__wb_iter_next(struct wb_iter *iter,
+                                                   struct backing_dev_info *bdi)
+{
+        struct radix_tree_iter *titer = &iter->tree_iter;
+
+        WARN_ON_ONCE(!rcu_read_lock_held());
+
+        if (iter->start_blkcg_id >= 0) {
+                iter->slot = radix_tree_iter_init(titer, iter->start_blkcg_id);
+                iter->start_blkcg_id = -1;
+        } else {
+                iter->slot = radix_tree_next_slot(iter->slot, titer, 0);
+        }
+
+        if (!iter->slot)
+                iter->slot = radix_tree_next_chunk(&bdi->cgwb_tree, titer, 0);
+        if (iter->slot)
+                return *iter->slot;
+        return NULL;
+}
+
+static inline struct bdi_writeback *__wb_iter_init(struct wb_iter *iter,
+                                                   struct backing_dev_info *bdi,
+                                                   int start_blkcg_id)
+{
+        iter->start_blkcg_id = start_blkcg_id;
+
+        if (start_blkcg_id)
+                return __wb_iter_next(iter, bdi);
+        else
+                return &bdi->wb;
+}
+
+/**
+ * bdi_for_each_wb - walk all wb's of a bdi in ascending blkcg ID order
+ * @wb_cur: cursor struct bdi_writeback pointer
+ * @bdi: bdi to walk wb's of
+ * @iter: pointer to struct wb_iter to be used as iteration buffer
+ * @start_blkcg_id: blkcg ID to start iteration from
+ *
+ * Iterate @wb_cur through the wb's (bdi_writeback's) of @bdi in ascending
+ * blkcg ID order starting from @start_blkcg_id.  @iter is struct wb_iter
+ * to be used as temp storage during iteration.  rcu_read_lock() must be
+ * held throughout iteration.
+ */
+#define bdi_for_each_wb(wb_cur, bdi, iter, start_blkcg_id)              \
+        for ((wb_cur) = __wb_iter_init(iter, bdi, start_blkcg_id);      \
+             (wb_cur); (wb_cur) = __wb_iter_next(iter, bdi))
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline bool inode_cgwb_enabled(struct inode *inode)
+{
+        return false;
+}
+
+static inline struct bdi_writeback_congested *
+wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
+{
+        atomic_inc(&bdi->wb_congested->refcnt);
+        return bdi->wb_congested;
+}
+
+static inline void wb_congested_put(struct bdi_writeback_congested *congested)
+{
+        if (atomic_dec_and_test(&congested->refcnt))
+                kfree(congested);
+}
+
+static inline struct bdi_writeback *wb_find_current(struct backing_dev_info *bdi)
+{
+        return &bdi->wb;
+}
+
+static inline struct bdi_writeback *
+wb_get_create_current(struct backing_dev_info *bdi, gfp_t gfp)
+{
+        return &bdi->wb;
+}
+
+static inline bool inode_to_wb_is_valid(struct inode *inode)
+{
+        return true;
+}
+
+static inline struct bdi_writeback *inode_to_wb(struct inode *inode)
+{
+        return &inode_to_bdi(inode)->wb;
+}
+
+static inline struct bdi_writeback *
+unlocked_inode_to_wb_begin(struct inode *inode, bool *lockedp)
+{
+        return inode_to_wb(inode);
+}
+
+static inline void unlocked_inode_to_wb_end(struct inode *inode, bool locked)
+{
+}
+
+static inline void wb_memcg_offline(struct mem_cgroup *memcg)
+{
+}
+
+static inline void wb_blkcg_offline(struct blkcg *blkcg)
+{
+}
+
+struct wb_iter {
+        int             next_id;
+};
+
+#define bdi_for_each_wb(wb_cur, bdi, iter, start_blkcg_id)              \
+        for ((iter)->next_id = (start_blkcg_id);                        \
+             ({ (wb_cur) = !(iter)->next_id++ ? &(bdi)->wb : NULL; }); )
+
+static inline int inode_congested(struct inode *inode, int cong_bits)
+{
+        return wb_congested(&inode_to_bdi(inode)->wb, cong_bits);
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
+static inline int inode_read_congested(struct inode *inode)
+{
+        return inode_congested(inode, 1 << WB_sync_congested);
+}
+
+static inline int inode_write_congested(struct inode *inode)
+{
+        return inode_congested(inode, 1 << WB_async_congested);
+}
+
+static inline int inode_rw_congested(struct inode *inode)
+{
+        return inode_congested(inode, (1 << WB_sync_congested) |
+                                      (1 << WB_async_congested));
+}
+
+static inline int bdi_congested(struct backing_dev_info *bdi, int cong_bits)
+{
+        return wb_congested(&bdi->wb, cong_bits);
+}
+
+static inline int bdi_read_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, 1 << WB_sync_congested);
+}
+
+static inline int bdi_write_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, 1 << WB_async_congested);
+}
+
+static inline int bdi_rw_congested(struct backing_dev_info *bdi)
+{
+        return bdi_congested(bdi, (1 << WB_sync_congested) |
+                                  (1 << WB_async_congested));
+}
+
+#endif  /* _LINUX_BACKING_DEV_H */
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index adb14a8616df..1e7a69adbe6f 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -117,12 +117,16 @@ struct backlight_device {
         int use_count;
 };
 
-static inline void backlight_update_status(struct backlight_device *bd)
+static inline int backlight_update_status(struct backlight_device *bd)
 {
+        int ret = -ENOENT;
+
         mutex_lock(&bd->update_lock);
         if (bd->ops && bd->ops->update_status)
-                bd->ops->update_status(bd);
+                ret = bd->ops->update_status(bd);
         mutex_unlock(&bd->update_lock);
+
+        return ret;
 }
 
 extern struct backlight_device *backlight_device_register(const char *name,
diff --git a/include/linux/bcm47xx_nvram.h b/include/linux/bcm47xx_nvram.h
index b12b07e75929..2793652fbf66 100644
--- a/include/linux/bcm47xx_nvram.h
+++ b/include/linux/bcm47xx_nvram.h
@@ -10,11 +10,17 @@
 
 #include <linux/types.h>
 #include <linux/kernel.h>
+#include <linux/vmalloc.h>
 
-#ifdef CONFIG_BCM47XX
+#ifdef CONFIG_BCM47XX_NVRAM
 int bcm47xx_nvram_init_from_mem(u32 base, u32 lim);
 int bcm47xx_nvram_getenv(const char *name, char *val, size_t val_len);
 int bcm47xx_nvram_gpio_pin(const char *name);
+char *bcm47xx_nvram_get_contents(size_t *val_len);
+static inline void bcm47xx_nvram_release_contents(char *nvram)
+{
+        vfree(nvram);
+};
 #else
 static inline int bcm47xx_nvram_init_from_mem(u32 base, u32 lim)
 {
@@ -29,6 +35,15 @@ static inline int bcm47xx_nvram_gpio_pin(const char *name)
 {
         return -ENOTSUPP;
 };
+
+static inline char *bcm47xx_nvram_get_contents(size_t *val_len)
+{
+        return NULL;
+};
+
+static inline void bcm47xx_nvram_release_contents(char *nvram)
+{
+};
 #endif
 
 #endif /* __BCM47XX_NVRAM_H */
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index e34f906647d3..2ff4a9961e1d 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -305,6 +305,15 @@ int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
 
 extern void bcma_driver_unregister(struct bcma_driver *drv);
 
+/* module_bcma_driver() - Helper macro for drivers that don't do
+ * anything special in module init/exit.  This eliminates a lot of
+ * boilerplate.  Each module may only use this macro once, and
+ * calling it replaces module_init() and module_exit()
+ */
+#define module_bcma_driver(__bcma_driver) \
+        module_driver(__bcma_driver, bcma_driver_register, \
+                        bcma_driver_unregister)
+
 /* Set a fallback SPROM.
  * See kdoc at the function definition for complete documentation. */
 extern int bcma_arch_register_fallback_sprom(
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
index 5ba6918ca20b..9657f11d48a7 100644
--- a/include/linux/bcma/bcma_driver_pci.h
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -246,7 +246,18 @@ static inline void bcma_core_pci_power_save(struct bcma_bus *bus, bool up)
 }
 #endif
 
+#ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
 extern int bcma_core_pci_pcibios_map_irq(const struct pci_dev *dev);
 extern int bcma_core_pci_plat_dev_init(struct pci_dev *dev);
+#else
+static inline int bcma_core_pci_pcibios_map_irq(const struct pci_dev *dev)
+{
+        return -ENOTSUPP;
+}
+static inline int bcma_core_pci_plat_dev_init(struct pci_dev *dev)
+{
+        return -ENOTSUPP;
+}
+#endif
 
 #endif /* LINUX_BCMA_DRIVER_PCI_H_ */
diff --git a/include/linux/bio.h b/include/linux/bio.h
index da3a127c9958..5e963a6d7c14 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -290,7 +290,21 @@ static inline unsigned bio_segments(struct bio *bio)
  * returns. and then bio would be freed memory when if (bio->bi_flags ...)
  * runs
  */
-#define bio_get(bio)    atomic_inc(&(bio)->bi_cnt)
+static inline void bio_get(struct bio *bio)
+{
+        bio->bi_flags |= (1 << BIO_REFFED);
+        smp_mb__before_atomic();
+        atomic_inc(&bio->__bi_cnt);
+}
+
+static inline void bio_cnt_set(struct bio *bio, unsigned int count)
+{
+        if (count != 1) {
+                bio->bi_flags |= (1 << BIO_REFFED);
+                smp_mb__before_atomic();
+        }
+        atomic_set(&bio->__bi_cnt, count);
+}
 
 enum bip_flags {
         BIP_BLOCK_INTEGRITY     = 1 << 0, /* block layer owns integrity data */
@@ -413,7 +427,6 @@ static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
 }
 
 extern void bio_endio(struct bio *, int);
-extern void bio_endio_nodec(struct bio *, int);
 struct request_queue;
 extern int bio_phys_segments(struct request_queue *, struct bio *);
 
@@ -469,9 +482,12 @@ extern void bvec_free(mempool_t *, struct bio_vec *, unsigned int);
 extern unsigned int bvec_nr_vecs(unsigned short idx);
 
 #ifdef CONFIG_BLK_CGROUP
+int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
 int bio_associate_current(struct bio *bio);
 void bio_disassociate_task(struct bio *bio);
 #else   /* CONFIG_BLK_CGROUP */
+static inline int bio_associate_blkcg(struct bio *bio,
+                        struct cgroup_subsys_state *blkcg_css) { return 0; }
 static inline int bio_associate_current(struct bio *bio) { return -ENOENT; }
 static inline void bio_disassociate_task(struct bio *bio) { }
 #endif  /* CONFIG_BLK_CGROUP */
diff --git a/include/linux/blk-cgroup.h b/include/linux/blk-cgroup.h
new file mode 100644
index 000000000000..1b62d768c7df
--- /dev/null
+++ b/include/linux/blk-cgroup.h
@@ -0,0 +1,650 @@
+#ifndef _BLK_CGROUP_H
+#define _BLK_CGROUP_H
+/*
+ * Common Block IO controller cgroup interface
+ *
+ * Based on ideas and code from CFQ, CFS and BFQ:
+ * Copyright (C) 2003 Jens Axboe <axboe@kernel.dk>
+ *
+ * Copyright (C) 2008 Fabio Checconi <fabio@gandalf.sssup.it>
+ *                    Paolo Valente <paolo.valente@unimore.it>
+ *
+ * Copyright (C) 2009 Vivek Goyal <vgoyal@redhat.com>
+ *                    Nauman Rafique <nauman@google.com>
+ */
+
+#include <linux/cgroup.h>
+#include <linux/u64_stats_sync.h>
+#include <linux/seq_file.h>
+#include <linux/radix-tree.h>
+#include <linux/blkdev.h>
+#include <linux/atomic.h>
+
+/* Max limits for throttle policy */
+#define THROTL_IOPS_MAX         UINT_MAX
+
+#ifdef CONFIG_BLK_CGROUP
+
+enum blkg_rwstat_type {
+        BLKG_RWSTAT_READ,
+        BLKG_RWSTAT_WRITE,
+        BLKG_RWSTAT_SYNC,
+        BLKG_RWSTAT_ASYNC,
+
+        BLKG_RWSTAT_NR,
+        BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
+};
+
+struct blkcg_gq;
+
+struct blkcg {
+        struct cgroup_subsys_state      css;
+        spinlock_t                      lock;
+
+        struct radix_tree_root          blkg_tree;
+        struct blkcg_gq                 *blkg_hint;
+        struct hlist_head               blkg_list;
+
+        struct blkcg_policy_data        *pd[BLKCG_MAX_POLS];
+
+        struct list_head                all_blkcgs_node;
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct list_head                cgwb_list;
+#endif
+};
+
+struct blkg_stat {
+        struct u64_stats_sync           syncp;
+        uint64_t                        cnt;
+};
+
+struct blkg_rwstat {
+        struct u64_stats_sync           syncp;
+        uint64_t                        cnt[BLKG_RWSTAT_NR];
+};
+
+/*
+ * A blkcg_gq (blkg) is association between a block cgroup (blkcg) and a
+ * request_queue (q).  This is used by blkcg policies which need to track
+ * information per blkcg - q pair.
+ *
+ * There can be multiple active blkcg policies and each has its private
+ * data on each blkg, the size of which is determined by
+ * blkcg_policy->pd_size.  blkcg core allocates and frees such areas
+ * together with blkg and invokes pd_init/exit_fn() methods.
+ *
+ * Such private data must embed struct blkg_policy_data (pd) at the
+ * beginning and pd_size can't be smaller than pd.
+ */
+struct blkg_policy_data {
+        /* the blkg and policy id this per-policy data belongs to */
+        struct blkcg_gq                 *blkg;
+        int                             plid;
+
+        /* used during policy activation */
+        struct list_head                alloc_node;
+};
+
+/*
+ * Policies that need to keep per-blkcg data which is independent
+ * from any request_queue associated to it must specify its size
+ * with the cpd_size field of the blkcg_policy structure and
+ * embed a blkcg_policy_data in it.  cpd_init() is invoked to let
+ * each policy handle per-blkcg data.
+ */
+struct blkcg_policy_data {
+        /* the policy id this per-policy data belongs to */
+        int                             plid;
+};
+
+/* association between a blk cgroup and a request queue */
+struct blkcg_gq {
+        /* Pointer to the associated request_queue */
+        struct request_queue            *q;
+        struct list_head                q_node;
+        struct hlist_node               blkcg_node;
+        struct blkcg                    *blkcg;
+
+        /*
+         * Each blkg gets congested separately and the congestion state is
+         * propagated to the matching bdi_writeback_congested.
+         */
+        struct bdi_writeback_congested  *wb_congested;
+
+        /* all non-root blkcg_gq's are guaranteed to have access to parent */
+        struct blkcg_gq                 *parent;
+
+        /* request allocation list for this blkcg-q pair */
+        struct request_list             rl;
+
+        /* reference count */
+        atomic_t                        refcnt;
+
+        /* is this blkg online? protected by both blkcg and q locks */
+        bool                            online;
+
+        struct blkg_policy_data         *pd[BLKCG_MAX_POLS];
+
+        struct rcu_head                 rcu_head;
+};
+
+typedef void (blkcg_pol_init_cpd_fn)(const struct blkcg *blkcg);
+typedef void (blkcg_pol_init_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_online_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_offline_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_exit_pd_fn)(struct blkcg_gq *blkg);
+typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkcg_gq *blkg);
+
+struct blkcg_policy {
+        int                             plid;
+        /* policy specific private data size */
+        size_t                          pd_size;
+        /* policy specific per-blkcg data size */
+        size_t                          cpd_size;
+        /* cgroup files for the policy */
+        struct cftype                   *cftypes;
+
+        /* operations */
+        blkcg_pol_init_cpd_fn           *cpd_init_fn;
+        blkcg_pol_init_pd_fn            *pd_init_fn;
+        blkcg_pol_online_pd_fn          *pd_online_fn;
+        blkcg_pol_offline_pd_fn         *pd_offline_fn;
+        blkcg_pol_exit_pd_fn            *pd_exit_fn;
+        blkcg_pol_reset_pd_stats_fn     *pd_reset_stats_fn;
+};
+
+extern struct blkcg blkcg_root;
+extern struct cgroup_subsys_state * const blkcg_root_css;
+
+struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, struct request_queue *q);
+struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
+                                    struct request_queue *q);
+int blkcg_init_queue(struct request_queue *q);
+void blkcg_drain_queue(struct request_queue *q);
+void blkcg_exit_queue(struct request_queue *q);
+
+/* Blkio controller policy registration */
+int blkcg_policy_register(struct blkcg_policy *pol);
+void blkcg_policy_unregister(struct blkcg_policy *pol);
+int blkcg_activate_policy(struct request_queue *q,
+                          const struct blkcg_policy *pol);
+void blkcg_deactivate_policy(struct request_queue *q,
+                             const struct blkcg_policy *pol);
+
+void blkcg_print_blkgs(struct seq_file *sf, struct blkcg *blkcg,
+                       u64 (*prfill)(struct seq_file *,
+                                     struct blkg_policy_data *, int),
+                       const struct blkcg_policy *pol, int data,
+                       bool show_total);
+u64 __blkg_prfill_u64(struct seq_file *sf, struct blkg_policy_data *pd, u64 v);
+u64 __blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
+                         const struct blkg_rwstat *rwstat);
+u64 blkg_prfill_stat(struct seq_file *sf, struct blkg_policy_data *pd, int off);
+u64 blkg_prfill_rwstat(struct seq_file *sf, struct blkg_policy_data *pd,
+                       int off);
+
+u64 blkg_stat_recursive_sum(struct blkg_policy_data *pd, int off);
+struct blkg_rwstat blkg_rwstat_recursive_sum(struct blkg_policy_data *pd,
+                                             int off);
+
+struct blkg_conf_ctx {
+        struct gendisk                  *disk;
+        struct blkcg_gq                 *blkg;
+        u64                             v;
+};
+
+int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
+                   const char *input, struct blkg_conf_ctx *ctx);
+void blkg_conf_finish(struct blkg_conf_ctx *ctx);
+
+
+static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css)
+{
+        return css ? container_of(css, struct blkcg, css) : NULL;
+}
+
+static inline struct blkcg *task_blkcg(struct task_struct *tsk)
+{
+        return css_to_blkcg(task_css(tsk, blkio_cgrp_id));
+}
+
+static inline struct blkcg *bio_blkcg(struct bio *bio)
+{
+        if (bio && bio->bi_css)
+                return css_to_blkcg(bio->bi_css);
+        return task_blkcg(current);
+}
+
+static inline struct cgroup_subsys_state *
+task_get_blkcg_css(struct task_struct *task)
+{
+        return task_get_css(task, blkio_cgrp_id);
+}
+
+/**
+ * blkcg_parent - get the parent of a blkcg
+ * @blkcg: blkcg of interest
+ *
+ * Return the parent blkcg of @blkcg.  Can be called anytime.
+ */
+static inline struct blkcg *blkcg_parent(struct blkcg *blkcg)
+{
+        return css_to_blkcg(blkcg->css.parent);
+}
+
+/**
+ * blkg_to_pdata - get policy private data
+ * @blkg: blkg of interest
+ * @pol: policy of interest
+ *
+ * Return pointer to private data associated with the @blkg-@pol pair.
+ */
+static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
+                                                  struct blkcg_policy *pol)
+{
+        return blkg ? blkg->pd[pol->plid] : NULL;
+}
+
+static inline struct blkcg_policy_data *blkcg_to_cpd(struct blkcg *blkcg,
+                                                     struct blkcg_policy *pol)
+{
+        return blkcg ? blkcg->pd[pol->plid] : NULL;
+}
+
+/**
+ * pdata_to_blkg - get blkg associated with policy private data
+ * @pd: policy private data of interest
+ *
+ * @pd is policy private data.  Determine the blkg it's associated with.
+ */
+static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd)
+{
+        return pd ? pd->blkg : NULL;
+}
+
+/**
+ * blkg_path - format cgroup path of blkg
+ * @blkg: blkg of interest
+ * @buf: target buffer
+ * @buflen: target buffer length
+ *
+ * Format the path of the cgroup of @blkg into @buf.
+ */
+static inline int blkg_path(struct blkcg_gq *blkg, char *buf, int buflen)
+{
+        char *p;
+
+        p = cgroup_path(blkg->blkcg->css.cgroup, buf, buflen);
+        if (!p) {
+                strncpy(buf, "<unavailable>", buflen);
+                return -ENAMETOOLONG;
+        }
+
+        memmove(buf, p, buf + buflen - p);
+        return 0;
+}
+
+/**
+ * blkg_get - get a blkg reference
+ * @blkg: blkg to get
+ *
+ * The caller should be holding an existing reference.
+ */
+static inline void blkg_get(struct blkcg_gq *blkg)
+{
+        WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
+        atomic_inc(&blkg->refcnt);
+}
+
+void __blkg_release_rcu(struct rcu_head *rcu);
+
+/**
+ * blkg_put - put a blkg reference
+ * @blkg: blkg to put
+ */
+static inline void blkg_put(struct blkcg_gq *blkg)
+{
+        WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
+        if (atomic_dec_and_test(&blkg->refcnt))
+                call_rcu(&blkg->rcu_head, __blkg_release_rcu);
+}
+
+struct blkcg_gq *__blkg_lookup(struct blkcg *blkcg, struct request_queue *q,
+                               bool update_hint);
+
+/**
+ * blkg_for_each_descendant_pre - pre-order walk of a blkg's descendants
+ * @d_blkg: loop cursor pointing to the current descendant
+ * @pos_css: used for iteration
+ * @p_blkg: target blkg to walk descendants of
+ *
+ * Walk @c_blkg through the descendants of @p_blkg.  Must be used with RCU
+ * read locked.  If called under either blkcg or queue lock, the iteration
+ * is guaranteed to include all and only online blkgs.  The caller may
+ * update @pos_css by calling css_rightmost_descendant() to skip subtree.
+ * @p_blkg is included in the iteration and the first node to be visited.
+ */
+#define blkg_for_each_descendant_pre(d_blkg, pos_css, p_blkg)           \
+        css_for_each_descendant_pre((pos_css), &(p_blkg)->blkcg->css)   \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
+                                              (p_blkg)->q, false)))
+
+/**
+ * blkg_for_each_descendant_post - post-order walk of a blkg's descendants
+ * @d_blkg: loop cursor pointing to the current descendant
+ * @pos_css: used for iteration
+ * @p_blkg: target blkg to walk descendants of
+ *
+ * Similar to blkg_for_each_descendant_pre() but performs post-order
+ * traversal instead.  Synchronization rules are the same.  @p_blkg is
+ * included in the iteration and the last node to be visited.
+ */
+#define blkg_for_each_descendant_post(d_blkg, pos_css, p_blkg)          \
+        css_for_each_descendant_post((pos_css), &(p_blkg)->blkcg->css)  \
+                if (((d_blkg) = __blkg_lookup(css_to_blkcg(pos_css),    \
+                                              (p_blkg)->q, false)))
+
+/**
+ * blk_get_rl - get request_list to use
+ * @q: request_queue of interest
+ * @bio: bio which will be attached to the allocated request (may be %NULL)
+ *
+ * The caller wants to allocate a request from @q to use for @bio.  Find
+ * the request_list to use and obtain a reference on it.  Should be called
+ * under queue_lock.  This function is guaranteed to return non-%NULL
+ * request_list.
+ */
+static inline struct request_list *blk_get_rl(struct request_queue *q,
+                                              struct bio *bio)
+{
+        struct blkcg *blkcg;
+        struct blkcg_gq *blkg;
+
+        rcu_read_lock();
+
+        blkcg = bio_blkcg(bio);
+
+        /* bypass blkg lookup and use @q->root_rl directly for root */
+        if (blkcg == &blkcg_root)
+                goto root_rl;
+
+        /*
+         * Try to use blkg->rl.  blkg lookup may fail under memory pressure
+         * or if either the blkcg or queue is going away.  Fall back to
+         * root_rl in such cases.
+         */
+        blkg = blkg_lookup_create(blkcg, q);
+        if (unlikely(IS_ERR(blkg)))
+                goto root_rl;
+
+        blkg_get(blkg);
+        rcu_read_unlock();
+        return &blkg->rl;
+root_rl:
+        rcu_read_unlock();
+        return &q->root_rl;
+}
+
+/**
+ * blk_put_rl - put request_list
+ * @rl: request_list to put
+ *
+ * Put the reference acquired by blk_get_rl().  Should be called under
+ * queue_lock.
+ */
+static inline void blk_put_rl(struct request_list *rl)
+{
+        /* root_rl may not have blkg set */
+        if (rl->blkg && rl->blkg->blkcg != &blkcg_root)
+                blkg_put(rl->blkg);
+}
+
+/**
+ * blk_rq_set_rl - associate a request with a request_list
+ * @rq: request of interest
+ * @rl: target request_list
+ *
+ * Associate @rq with @rl so that accounting and freeing can know the
+ * request_list @rq came from.
+ */
+static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl)
+{
+        rq->rl = rl;
+}
+
+/**
+ * blk_rq_rl - return the request_list a request came from
+ * @rq: request of interest
+ *
+ * Return the request_list @rq is allocated from.
+ */
+static inline struct request_list *blk_rq_rl(struct request *rq)
+{
+        return rq->rl;
+}
+
+struct request_list *__blk_queue_next_rl(struct request_list *rl,
+                                         struct request_queue *q);
+/**
+ * blk_queue_for_each_rl - iterate through all request_lists of a request_queue
+ *
+ * Should be used under queue_lock.
+ */
+#define blk_queue_for_each_rl(rl, q)    \
+        for ((rl) = &(q)->root_rl; (rl); (rl) = __blk_queue_next_rl((rl), (q)))
+
+static inline void blkg_stat_init(struct blkg_stat *stat)
+{
+        u64_stats_init(&stat->syncp);
+}
+
+/**
+ * blkg_stat_add - add a value to a blkg_stat
+ * @stat: target blkg_stat
+ * @val: value to add
+ *
+ * Add @val to @stat.  The caller is responsible for synchronizing calls to
+ * this function.
+ */
+static inline void blkg_stat_add(struct blkg_stat *stat, uint64_t val)
+{
+        u64_stats_update_begin(&stat->syncp);
+        stat->cnt += val;
+        u64_stats_update_end(&stat->syncp);
+}
+
+/**
+ * blkg_stat_read - read the current value of a blkg_stat
+ * @stat: blkg_stat to read
+ *
+ * Read the current value of @stat.  This function can be called without
+ * synchroniztion and takes care of u64 atomicity.
+ */
+static inline uint64_t blkg_stat_read(struct blkg_stat *stat)
+{
+        unsigned int start;
+        uint64_t v;
+
+        do {
+                start = u64_stats_fetch_begin_irq(&stat->syncp);
+                v = stat->cnt;
+        } while (u64_stats_fetch_retry_irq(&stat->syncp, start));
+
+        return v;
+}
+
+/**
+ * blkg_stat_reset - reset a blkg_stat
+ * @stat: blkg_stat to reset
+ */
+static inline void blkg_stat_reset(struct blkg_stat *stat)
+{
+        stat->cnt = 0;
+}
+
+/**
+ * blkg_stat_merge - merge a blkg_stat into another
+ * @to: the destination blkg_stat
+ * @from: the source
+ *
+ * Add @from's count to @to.
+ */
+static inline void blkg_stat_merge(struct blkg_stat *to, struct blkg_stat *from)
+{
+        blkg_stat_add(to, blkg_stat_read(from));
+}
+
+static inline void blkg_rwstat_init(struct blkg_rwstat *rwstat)
+{
+        u64_stats_init(&rwstat->syncp);
+}
+
+/**
+ * blkg_rwstat_add - add a value to a blkg_rwstat
+ * @rwstat: target blkg_rwstat
+ * @rw: mask of REQ_{WRITE|SYNC}
+ * @val: value to add
+ *
+ * Add @val to @rwstat.  The counters are chosen according to @rw.  The
+ * caller is responsible for synchronizing calls to this function.
+ */
+static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
+                                   int rw, uint64_t val)
+{
+        u64_stats_update_begin(&rwstat->syncp);
+
+        if (rw & REQ_WRITE)
+                rwstat->cnt[BLKG_RWSTAT_WRITE] += val;
+        else
+                rwstat->cnt[BLKG_RWSTAT_READ] += val;
+        if (rw & REQ_SYNC)
+                rwstat->cnt[BLKG_RWSTAT_SYNC] += val;
+        else
+                rwstat->cnt[BLKG_RWSTAT_ASYNC] += val;
+
+        u64_stats_update_end(&rwstat->syncp);
+}
+
+/**
+ * blkg_rwstat_read - read the current values of a blkg_rwstat
+ * @rwstat: blkg_rwstat to read
+ *
+ * Read the current snapshot of @rwstat and return it as the return value.
+ * This function can be called without synchronization and takes care of
+ * u64 atomicity.
+ */
+static inline struct blkg_rwstat blkg_rwstat_read(struct blkg_rwstat *rwstat)
+{
+        unsigned int start;
+        struct blkg_rwstat tmp;
+
+        do {
+                start = u64_stats_fetch_begin_irq(&rwstat->syncp);
+                tmp = *rwstat;
+        } while (u64_stats_fetch_retry_irq(&rwstat->syncp, start));
+
+        return tmp;
+}
+
+/**
+ * blkg_rwstat_total - read the total count of a blkg_rwstat
+ * @rwstat: blkg_rwstat to read
+ *
+ * Return the total count of @rwstat regardless of the IO direction.  This
+ * function can be called without synchronization and takes care of u64
+ * atomicity.
+ */
+static inline uint64_t blkg_rwstat_total(struct blkg_rwstat *rwstat)
+{
+        struct blkg_rwstat tmp = blkg_rwstat_read(rwstat);
+
+        return tmp.cnt[BLKG_RWSTAT_READ] + tmp.cnt[BLKG_RWSTAT_WRITE];
+}
+
+/**
+ * blkg_rwstat_reset - reset a blkg_rwstat
+ * @rwstat: blkg_rwstat to reset
+ */
+static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
+{
+        memset(rwstat->cnt, 0, sizeof(rwstat->cnt));
+}
+
+/**
+ * blkg_rwstat_merge - merge a blkg_rwstat into another
+ * @to: the destination blkg_rwstat
+ * @from: the source
+ *
+ * Add @from's counts to @to.
+ */
+static inline void blkg_rwstat_merge(struct blkg_rwstat *to,
+                                     struct blkg_rwstat *from)
+{
+        struct blkg_rwstat v = blkg_rwstat_read(from);
+        int i;
+
+        u64_stats_update_begin(&to->syncp);
+        for (i = 0; i < BLKG_RWSTAT_NR; i++)
+                to->cnt[i] += v.cnt[i];
+        u64_stats_update_end(&to->syncp);
+}
+
+#else   /* CONFIG_BLK_CGROUP */
+
+struct blkcg {
+};
+
+struct blkg_policy_data {
+};
+
+struct blkcg_policy_data {
+};
+
+struct blkcg_gq {
+};
+
+struct blkcg_policy {
+};
+
+#define blkcg_root_css  ((struct cgroup_subsys_state *)ERR_PTR(-EINVAL))
+
+static inline struct cgroup_subsys_state *
+task_get_blkcg_css(struct task_struct *task)
+{
+        return NULL;
+}
+
+#ifdef CONFIG_BLOCK
+
+static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; }
+static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
+static inline void blkcg_drain_queue(struct request_queue *q) { }
+static inline void blkcg_exit_queue(struct request_queue *q) { }
+static inline int blkcg_policy_register(struct blkcg_policy *pol) { return 0; }
+static inline void blkcg_policy_unregister(struct blkcg_policy *pol) { }
+static inline int blkcg_activate_policy(struct request_queue *q,
+                                        const struct blkcg_policy *pol) { return 0; }
+static inline void blkcg_deactivate_policy(struct request_queue *q,
+                                           const struct blkcg_policy *pol) { }
+
+static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
+
+static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
+                                                  struct blkcg_policy *pol) { return NULL; }
+static inline struct blkcg_gq *pd_to_blkg(struct blkg_policy_data *pd) { return NULL; }
+static inline char *blkg_path(struct blkcg_gq *blkg) { return NULL; }
+static inline void blkg_get(struct blkcg_gq *blkg) { }
+static inline void blkg_put(struct blkcg_gq *blkg) { }
+
+static inline struct request_list *blk_get_rl(struct request_queue *q,
+                                              struct bio *bio) { return &q->root_rl; }
+static inline void blk_put_rl(struct request_list *rl) { }
+static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl) { }
+static inline struct request_list *blk_rq_rl(struct request *rq) { return &rq->q->root_rl; }
+
+#define blk_queue_for_each_rl(rl, q)    \
+        for ((rl) = &(q)->root_rl; (rl); (rl) = NULL)
+
+#endif  /* CONFIG_BLOCK */
+#endif  /* CONFIG_BLK_CGROUP */
+#endif  /* _BLK_CGROUP_H */
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 2056a99b92f8..37d1602c4f7a 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -96,6 +96,7 @@ typedef void (exit_request_fn)(void *, struct request *, unsigned int,
 
 typedef void (busy_iter_fn)(struct blk_mq_hw_ctx *, struct request *, void *,
                 bool);
+typedef void (busy_tag_iter_fn)(struct request *, void *, bool);
 
 struct blk_mq_ops {
         /*
@@ -182,6 +183,7 @@ 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);
+struct cpumask *blk_mq_tags_cpumask(struct blk_mq_tags *tags);
 
 enum {
         BLK_MQ_UNIQUE_TAG_BITS = 16,
@@ -224,6 +226,8 @@ void blk_mq_run_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_hw_ctx *hctx, busy_iter_fn *fn,
                 void *priv);
+void blk_mq_all_tag_busy_iter(struct blk_mq_tags *tags, busy_tag_iter_fn *fn,
+                void *priv);
 void blk_mq_freeze_queue(struct request_queue *q);
 void blk_mq_unfreeze_queue(struct request_queue *q);
 void blk_mq_freeze_queue_start(struct request_queue *q);
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index b7299febc4b4..7303b3405520 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -65,7 +65,7 @@ struct bio {
         unsigned int            bi_seg_front_size;
         unsigned int            bi_seg_back_size;
 
-        atomic_t                bi_remaining;
+        atomic_t                __bi_remaining;
 
         bio_end_io_t            *bi_end_io;
 
@@ -92,7 +92,7 @@ struct bio {
 
         unsigned short          bi_max_vecs;    /* max bvl_vecs we can hold */
 
-        atomic_t                bi_cnt;         /* pin count */
+        atomic_t                __bi_cnt;       /* pin count */
 
         struct bio_vec          *bi_io_vec;     /* the actual vec list */
 
@@ -112,16 +112,15 @@ struct bio {
  * bio flags
  */
 #define BIO_UPTODATE    0       /* ok after I/O completion */
-#define BIO_RW_BLOCK    1       /* RW_AHEAD set, and read/write would block */
-#define BIO_EOF         2       /* out-out-bounds error */
-#define BIO_SEG_VALID   3       /* bi_phys_segments valid */
-#define BIO_CLONED      4       /* doesn't own data */
-#define BIO_BOUNCED     5       /* bio is a bounce 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_QUIET       9       /* Make BIO Quiet */
-#define BIO_SNAP_STABLE 10      /* bio data must be snapshotted during write */
+#define BIO_SEG_VALID   1       /* bi_phys_segments valid */
+#define BIO_CLONED      2       /* doesn't own data */
+#define BIO_BOUNCED     3       /* bio is a bounce bio */
+#define BIO_USER_MAPPED 4       /* contains user pages */
+#define BIO_NULL_MAPPED 5       /* contains invalid user pages */
+#define BIO_QUIET       6       /* Make BIO Quiet */
+#define BIO_SNAP_STABLE 7       /* bio data must be snapshotted during write */
+#define BIO_CHAIN       8       /* chained bio, ->bi_remaining in effect */
+#define BIO_REFFED      9       /* bio has elevated ->bi_cnt */
 
 /*
  * Flags starting here get preserved by bio_reset() - this includes
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 5d93a6645e88..d4068c17d0df 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -12,7 +12,7 @@
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/pagemap.h>
-#include <linux/backing-dev.h>
+#include <linux/backing-dev-defs.h>
 #include <linux/wait.h>
 #include <linux/mempool.h>
 #include <linux/bio.h>
@@ -22,15 +22,13 @@
 #include <linux/smp.h>
 #include <linux/rcupdate.h>
 #include <linux/percpu-refcount.h>
-
-#include <asm/scatterlist.h>
+#include <linux/scatterlist.h>
 
 struct module;
 struct scsi_ioctl_command;
 
 struct request_queue;
 struct elevator_queue;
-struct request_pm_state;
 struct blk_trace;
 struct request;
 struct sg_io_hdr;
@@ -75,18 +73,7 @@ struct request_list {
 enum rq_cmd_type_bits {
         REQ_TYPE_FS             = 1,    /* fs request */
         REQ_TYPE_BLOCK_PC,              /* scsi command */
-        REQ_TYPE_SENSE,                 /* sense request */
-        REQ_TYPE_PM_SUSPEND,            /* suspend request */
-        REQ_TYPE_PM_RESUME,             /* resume request */
-        REQ_TYPE_PM_SHUTDOWN,           /* shutdown request */
-        REQ_TYPE_SPECIAL,               /* driver defined type */
-        /*
-         * for ATA/ATAPI devices. this really doesn't belong here, ide should
-         * use REQ_TYPE_SPECIAL and use rq->cmd[0] with the range of driver
-         * private REQ_LB opcodes to differentiate what type of request this is
-         */
-        REQ_TYPE_ATA_TASKFILE,
-        REQ_TYPE_ATA_PC,
+        REQ_TYPE_DRV_PRIV,              /* driver defined types from here */
 };
 
 #define BLK_MAX_CDB     16
@@ -108,7 +95,7 @@ struct request {
         struct blk_mq_ctx *mq_ctx;
 
         u64 cmd_flags;
-        enum rq_cmd_type_bits cmd_type;
+        unsigned cmd_type;
         unsigned long atomic_flags;
 
         int cpu;
@@ -216,19 +203,6 @@ static inline unsigned short req_get_ioprio(struct request *req)
         return req->ioprio;
 }
 
-/*
- * State information carried for REQ_TYPE_PM_SUSPEND and REQ_TYPE_PM_RESUME
- * requests. Some step values could eventually be made generic.
- */
-struct request_pm_state
-{
-        /* PM state machine step value, currently driver specific */
-        int     pm_step;
-        /* requested PM state value (S1, S2, S3, S4, ...) */
-        u32     pm_state;
-        void*   data;           /* for driver use */
-};
-
 #include <linux/elevator.h>
 
 struct blk_queue_ctx;
@@ -469,7 +443,7 @@ struct request_queue {
         struct mutex            sysfs_lock;
 
         int                     bypass_depth;
-        int                     mq_freeze_depth;
+        atomic_t                mq_freeze_depth;
 
 #if defined(CONFIG_BLK_DEV_BSG)
         bsg_job_fn              *bsg_job_fn;
@@ -610,10 +584,6 @@ static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
         (((rq)->cmd_flags & REQ_STARTED) && \
          ((rq)->cmd_type == REQ_TYPE_FS))
 
-#define blk_pm_request(rq)      \
-        ((rq)->cmd_type == REQ_TYPE_PM_SUSPEND || \
-         (rq)->cmd_type == REQ_TYPE_PM_RESUME)
-
 #define blk_rq_cpu_valid(rq)    ((rq)->cpu != -1)
 #define blk_bidi_rq(rq)         ((rq)->next_rq != NULL)
 /* rq->queuelist of dequeued request must be list_empty() */
@@ -821,30 +791,12 @@ extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
 extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
                          struct scsi_ioctl_command __user *);
 
-/*
- * A queue has just exitted congestion.  Note this in the global counter of
- * congested queues, and wake up anyone who was waiting for requests to be
- * put back.
- */
-static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
-{
-        clear_bdi_congested(&q->backing_dev_info, sync);
-}
-
-/*
- * A queue has just entered congestion.  Flag that in the queue's VM-visible
- * state flags and increment the global gounter of congested queues.
- */
-static inline void blk_set_queue_congested(struct request_queue *q, int sync)
-{
-        set_bdi_congested(&q->backing_dev_info, sync);
-}
-
 extern void blk_start_queue(struct request_queue *q);
 extern void blk_stop_queue(struct request_queue *q);
 extern void blk_sync_queue(struct request_queue *q);
 extern void __blk_stop_queue(struct request_queue *q);
 extern void __blk_run_queue(struct request_queue *q);
+extern void __blk_run_queue_uncond(struct request_queue *q);
 extern void blk_run_queue(struct request_queue *);
 extern void blk_run_queue_async(struct request_queue *q);
 extern int blk_rq_map_user(struct request_queue *, struct request *,
@@ -933,7 +885,7 @@ static inline unsigned int blk_rq_get_max_sectors(struct request *rq)
         if (unlikely(rq->cmd_type == REQ_TYPE_BLOCK_PC))
                 return q->limits.max_hw_sectors;
 
-        if (!q->limits.chunk_sectors)
+        if (!q->limits.chunk_sectors || (rq->cmd_flags & REQ_DISCARD))
                 return blk_queue_get_max_sectors(q, rq->cmd_flags);
 
         return min(blk_max_size_offset(q, blk_rq_pos(rq)),
@@ -1054,6 +1006,7 @@ bool __must_check blk_get_queue(struct request_queue *);
 struct request_queue *blk_alloc_queue(gfp_t);
 struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
+extern void blk_set_queue_dying(struct request_queue *);
 
 /*
  * block layer runtime pm functions
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 0995c2de8162..f589222bfa87 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -357,12 +357,12 @@ extern void *alloc_large_system_hash(const char *tablename,
 /* Only NUMA needs hash distribution. 64bit NUMA architectures have
  * sufficient vmalloc space.
  */
-#if defined(CONFIG_NUMA) && defined(CONFIG_64BIT)
-#define HASHDIST_DEFAULT 1
+#ifdef CONFIG_NUMA
+#define HASHDIST_DEFAULT IS_ENABLED(CONFIG_64BIT)
+extern int hashdist;            /* Distribute hashes across NUMA nodes? */
 #else
-#define HASHDIST_DEFAULT 0
+#define hashdist (0)
 #endif
-extern int hashdist;            /* Distribute hashes across NUMA nodes? */
 
 
 #endif /* _LINUX_BOOTMEM_H */
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index d5cda067115a..4383476a0d48 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -105,7 +105,8 @@ struct bpf_verifier_ops {
          */
         bool (*is_valid_access)(int off, int size, enum bpf_access_type type);
 
-        u32 (*convert_ctx_access)(int dst_reg, int src_reg, int ctx_off,
+        u32 (*convert_ctx_access)(enum bpf_access_type type, int dst_reg,
+                                  int src_reg, int ctx_off,
                                   struct bpf_insn *insn);
 };
 
@@ -123,15 +124,41 @@ struct bpf_prog_aux {
         const struct bpf_verifier_ops *ops;
         struct bpf_map **used_maps;
         struct bpf_prog *prog;
-        struct work_struct work;
+        union {
+                struct work_struct work;
+                struct rcu_head rcu;
+        };
 };
 
+struct bpf_array {
+        struct bpf_map map;
+        u32 elem_size;
+        /* 'ownership' of prog_array is claimed by the first program that
+         * is going to use this map or by the first program which FD is stored
+         * in the map to make sure that all callers and callees have the same
+         * prog_type and JITed flag
+         */
+        enum bpf_prog_type owner_prog_type;
+        bool owner_jited;
+        union {
+                char value[0] __aligned(8);
+                struct bpf_prog *prog[0] __aligned(8);
+        };
+};
+#define MAX_TAIL_CALL_CNT 32
+
+u64 bpf_tail_call(u64 ctx, u64 r2, u64 index, u64 r4, u64 r5);
+void bpf_prog_array_map_clear(struct bpf_map *map);
+bool bpf_prog_array_compatible(struct bpf_array *array, const struct bpf_prog *fp);
+const struct bpf_func_proto *bpf_get_trace_printk_proto(void);
+
 #ifdef CONFIG_BPF_SYSCALL
 void bpf_register_prog_type(struct bpf_prog_type_list *tl);
 void bpf_register_map_type(struct bpf_map_type_list *tl);
 
 struct bpf_prog *bpf_prog_get(u32 ufd);
 void bpf_prog_put(struct bpf_prog *prog);
+void bpf_prog_put_rcu(struct bpf_prog *prog);
 
 struct bpf_map *bpf_map_get(struct fd f);
 void bpf_map_put(struct bpf_map *map);
@@ -160,5 +187,10 @@ extern const struct bpf_func_proto bpf_map_delete_elem_proto;
 
 extern const struct bpf_func_proto bpf_get_prandom_u32_proto;
 extern const struct bpf_func_proto bpf_get_smp_processor_id_proto;
+extern const struct bpf_func_proto bpf_tail_call_proto;
+extern const struct bpf_func_proto bpf_ktime_get_ns_proto;
+extern const struct bpf_func_proto bpf_get_current_pid_tgid_proto;
+extern const struct bpf_func_proto bpf_get_current_uid_gid_proto;
+extern const struct bpf_func_proto bpf_get_current_comm_proto;
 
 #endif /* _LINUX_BPF_H */
diff --git a/include/linux/brcmphy.h b/include/linux/brcmphy.h
index 656da2a12ffe..697ca7795bd9 100644
--- a/include/linux/brcmphy.h
+++ b/include/linux/brcmphy.h
@@ -1,6 +1,13 @@
 #ifndef _LINUX_BRCMPHY_H
 #define _LINUX_BRCMPHY_H
 
+#include <linux/phy.h>
+
+/* All Broadcom Ethernet switches have a pseudo-PHY at address 30 which is used
+ * to configure the switch internal registers via MDIO accesses.
+ */
+#define BRCM_PSEUDO_PHY_ADDR           30
+
 #define PHY_ID_BCM50610                 0x0143bd60
 #define PHY_ID_BCM50610M                0x0143bd70
 #define PHY_ID_BCM5241                  0x0143bc30
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 73b45225a7ca..e6797ded700e 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -317,6 +317,13 @@ sb_getblk(struct super_block *sb, sector_t block)
         return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE);
 }
 
+
+static inline struct buffer_head *
+sb_getblk_gfp(struct super_block *sb, sector_t block, gfp_t gfp)
+{
+        return __getblk_gfp(sb->s_bdev, block, sb->s_blocksize, gfp);
+}
+
 static inline struct buffer_head *
 sb_find_get_block(struct super_block *sb, sector_t block)
 {
diff --git a/include/linux/cacheinfo.h b/include/linux/cacheinfo.h
index 3daf5ed392c9..2189935075b4 100644
--- a/include/linux/cacheinfo.h
+++ b/include/linux/cacheinfo.h
@@ -19,7 +19,7 @@ enum cache_type {
 /**
  * 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
+ * @level: represents the hierarchy 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
diff --git a/include/linux/can/skb.h b/include/linux/can/skb.h
index b6a52a4b457a..51bb6532785c 100644
--- a/include/linux/can/skb.h
+++ b/include/linux/can/skb.h
@@ -27,10 +27,12 @@
 /**
  * struct can_skb_priv - private additional data inside CAN sk_buffs
  * @ifindex:    ifindex of the first interface the CAN frame appeared on
+ * @skbcnt:     atomic counter to have an unique id together with skb pointer
  * @cf:         align to the following CAN frame at skb->data
  */
 struct can_skb_priv {
         int ifindex;
+        int skbcnt;
         struct can_frame cf[0];
 };
 
diff --git a/include/linux/ceph/libceph.h b/include/linux/ceph/libceph.h
index 30f92cefaa72..9ebee53d3bf5 100644
--- a/include/linux/ceph/libceph.h
+++ b/include/linux/ceph/libceph.h
@@ -43,9 +43,9 @@ struct ceph_options {
         int flags;
         struct ceph_fsid fsid;
         struct ceph_entity_addr my_addr;
-        int mount_timeout;
-        int osd_idle_ttl;
-        int osd_keepalive_timeout;
+        unsigned long mount_timeout;            /* jiffies */
+        unsigned long osd_idle_ttl;             /* jiffies */
+        unsigned long osd_keepalive_timeout;    /* jiffies */
 
         /*
          * any type that can't be simply compared or doesn't need need
@@ -63,9 +63,9 @@ struct ceph_options {
 /*
  * defaults
  */
-#define CEPH_MOUNT_TIMEOUT_DEFAULT  60
-#define CEPH_OSD_KEEPALIVE_DEFAULT  5
-#define CEPH_OSD_IDLE_TTL_DEFAULT    60
+#define CEPH_MOUNT_TIMEOUT_DEFAULT      msecs_to_jiffies(60 * 1000)
+#define CEPH_OSD_KEEPALIVE_DEFAULT      msecs_to_jiffies(5 * 1000)
+#define CEPH_OSD_IDLE_TTL_DEFAULT       msecs_to_jiffies(60 * 1000)
 
 #define CEPH_MSG_MAX_FRONT_LEN  (16*1024*1024)
 #define CEPH_MSG_MAX_MIDDLE_LEN (16*1024*1024)
@@ -93,13 +93,9 @@ enum {
         CEPH_MOUNT_SHUTDOWN,
 };
 
-/*
- * subtract jiffies
- */
-static inline unsigned long time_sub(unsigned long a, unsigned long b)
+static inline unsigned long ceph_timeout_jiffies(unsigned long timeout)
 {
-        BUG_ON(time_after(b, a));
-        return (long)a - (long)b;
+        return timeout ?: MAX_SCHEDULE_TIMEOUT;
 }
 
 struct ceph_mds_client;
@@ -178,6 +174,7 @@ static inline int calc_pages_for(u64 off, u64 len)
 
 extern struct kmem_cache *ceph_inode_cachep;
 extern struct kmem_cache *ceph_cap_cachep;
+extern struct kmem_cache *ceph_cap_flush_cachep;
 extern struct kmem_cache *ceph_dentry_cachep;
 extern struct kmem_cache *ceph_file_cachep;
 
diff --git a/include/linux/ceph/messenger.h b/include/linux/ceph/messenger.h
index e15499422fdc..37753278987a 100644
--- a/include/linux/ceph/messenger.h
+++ b/include/linux/ceph/messenger.h
@@ -8,6 +8,7 @@
 #include <linux/radix-tree.h>
 #include <linux/uio.h>
 #include <linux/workqueue.h>
+#include <net/net_namespace.h>
 
 #include <linux/ceph/types.h>
 #include <linux/ceph/buffer.h>
@@ -56,6 +57,7 @@ struct ceph_messenger {
         struct ceph_entity_addr my_enc_addr;
 
         atomic_t stopping;
+        possible_net_t net;
         bool nocrc;
         bool tcp_nodelay;
 
@@ -267,6 +269,7 @@ extern void ceph_messenger_init(struct ceph_messenger *msgr,
                         u64 required_features,
                         bool nocrc,
                         bool tcp_nodelay);
+extern void ceph_messenger_fini(struct ceph_messenger *msgr);
 
 extern void ceph_con_init(struct ceph_connection *con, void *private,
                         const struct ceph_connection_operations *ops,
diff --git a/include/linux/ceph/osd_client.h b/include/linux/ceph/osd_client.h
index 61b19c46bdb3..7506b485bb6d 100644
--- a/include/linux/ceph/osd_client.h
+++ b/include/linux/ceph/osd_client.h
@@ -249,7 +249,7 @@ extern void ceph_osdc_handle_map(struct ceph_osd_client *osdc,
                                  struct ceph_msg *msg);
 
 extern void osd_req_op_init(struct ceph_osd_request *osd_req,
-                                        unsigned int which, u16 opcode);
+                            unsigned int which, u16 opcode, u32 flags);
 
 extern void osd_req_op_raw_data_in_pages(struct ceph_osd_request *,
                                         unsigned int which,
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
new file mode 100644
index 000000000000..93755a629299
--- /dev/null
+++ b/include/linux/cgroup-defs.h
@@ -0,0 +1,501 @@
+/*
+ * linux/cgroup-defs.h - basic definitions for cgroup
+ *
+ * This file provides basic type and interface.  Include this file directly
+ * only if necessary to avoid cyclic dependencies.
+ */
+#ifndef _LINUX_CGROUP_DEFS_H
+#define _LINUX_CGROUP_DEFS_H
+
+#include <linux/limits.h>
+#include <linux/list.h>
+#include <linux/idr.h>
+#include <linux/wait.h>
+#include <linux/mutex.h>
+#include <linux/rcupdate.h>
+#include <linux/percpu-refcount.h>
+#include <linux/percpu-rwsem.h>
+#include <linux/workqueue.h>
+
+#ifdef CONFIG_CGROUPS
+
+struct cgroup;
+struct cgroup_root;
+struct cgroup_subsys;
+struct cgroup_taskset;
+struct kernfs_node;
+struct kernfs_ops;
+struct kernfs_open_file;
+struct seq_file;
+
+#define MAX_CGROUP_TYPE_NAMELEN 32
+#define MAX_CGROUP_ROOT_NAMELEN 64
+#define MAX_CFTYPE_NAME         64
+
+/* define the enumeration of all cgroup subsystems */
+#define SUBSYS(_x) _x ## _cgrp_id,
+enum cgroup_subsys_id {
+#include <linux/cgroup_subsys.h>
+        CGROUP_SUBSYS_COUNT,
+};
+#undef SUBSYS
+
+/* bits in struct cgroup_subsys_state flags field */
+enum {
+        CSS_NO_REF      = (1 << 0), /* no reference counting for this css */
+        CSS_ONLINE      = (1 << 1), /* between ->css_online() and ->css_offline() */
+        CSS_RELEASED    = (1 << 2), /* refcnt reached zero, released */
+};
+
+/* bits in struct cgroup flags field */
+enum {
+        /* Control Group requires release notifications to userspace */
+        CGRP_NOTIFY_ON_RELEASE,
+        /*
+         * Clone the parent's configuration when creating a new child
+         * cpuset cgroup.  For historical reasons, this option can be
+         * specified at mount time and thus is implemented here.
+         */
+        CGRP_CPUSET_CLONE_CHILDREN,
+};
+
+/* cgroup_root->flags */
+enum {
+        CGRP_ROOT_SANE_BEHAVIOR = (1 << 0), /* __DEVEL__sane_behavior specified */
+        CGRP_ROOT_NOPREFIX      = (1 << 1), /* mounted subsystems have no named prefix */
+        CGRP_ROOT_XATTR         = (1 << 2), /* supports extended attributes */
+};
+
+/* cftype->flags */
+enum {
+        CFTYPE_ONLY_ON_ROOT     = (1 << 0),     /* only create on root cgrp */
+        CFTYPE_NOT_ON_ROOT      = (1 << 1),     /* don't create on root cgrp */
+        CFTYPE_NO_PREFIX        = (1 << 3),     /* (DON'T USE FOR NEW FILES) no subsys prefix */
+
+        /* internal flags, do not use outside cgroup core proper */
+        __CFTYPE_ONLY_ON_DFL    = (1 << 16),    /* only on default hierarchy */
+        __CFTYPE_NOT_ON_DFL     = (1 << 17),    /* not on default hierarchy */
+};
+
+/*
+ * Per-subsystem/per-cgroup state maintained by the system.  This is the
+ * fundamental structural building block that controllers deal with.
+ *
+ * Fields marked with "PI:" are public and immutable and may be accessed
+ * directly without synchronization.
+ */
+struct cgroup_subsys_state {
+        /* PI: the cgroup that this css is attached to */
+        struct cgroup *cgroup;
+
+        /* PI: the cgroup subsystem that this css is attached to */
+        struct cgroup_subsys *ss;
+
+        /* reference count - access via css_[try]get() and css_put() */
+        struct percpu_ref refcnt;
+
+        /* PI: the parent css */
+        struct cgroup_subsys_state *parent;
+
+        /* siblings list anchored at the parent's ->children */
+        struct list_head sibling;
+        struct list_head children;
+
+        /*
+         * PI: Subsys-unique ID.  0 is unused and root is always 1.  The
+         * matching css can be looked up using css_from_id().
+         */
+        int id;
+
+        unsigned int flags;
+
+        /*
+         * Monotonically increasing unique serial number which defines a
+         * uniform order among all csses.  It's guaranteed that all
+         * ->children lists are in the ascending order of ->serial_nr and
+         * used to allow interrupting and resuming iterations.
+         */
+        u64 serial_nr;
+
+        /* percpu_ref killing and RCU release */
+        struct rcu_head rcu_head;
+        struct work_struct destroy_work;
+};
+
+/*
+ * A css_set is a structure holding pointers to a set of
+ * cgroup_subsys_state objects. This saves space in the task struct
+ * object and speeds up fork()/exit(), since a single inc/dec and a
+ * list_add()/del() can bump the reference count on the entire cgroup
+ * set for a task.
+ */
+struct css_set {
+        /* Reference count */
+        atomic_t refcount;
+
+        /*
+         * List running through all cgroup groups in the same hash
+         * slot. Protected by css_set_lock
+         */
+        struct hlist_node hlist;
+
+        /*
+         * Lists running through all tasks using this cgroup group.
+         * mg_tasks lists tasks which belong to this cset but are in the
+         * process of being migrated out or in.  Protected by
+         * css_set_rwsem, but, during migration, once tasks are moved to
+         * mg_tasks, it can be read safely while holding cgroup_mutex.
+         */
+        struct list_head tasks;
+        struct list_head mg_tasks;
+
+        /*
+         * List of cgrp_cset_links pointing at cgroups referenced from this
+         * css_set.  Protected by css_set_lock.
+         */
+        struct list_head cgrp_links;
+
+        /* the default cgroup associated with this css_set */
+        struct cgroup *dfl_cgrp;
+
+        /*
+         * Set of subsystem states, one for each subsystem. This array is
+         * immutable after creation apart from the init_css_set during
+         * subsystem registration (at boot time).
+         */
+        struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
+
+        /*
+         * List of csets participating in the on-going migration either as
+         * source or destination.  Protected by cgroup_mutex.
+         */
+        struct list_head mg_preload_node;
+        struct list_head mg_node;
+
+        /*
+         * If this cset is acting as the source of migration the following
+         * two fields are set.  mg_src_cgrp is the source cgroup of the
+         * on-going migration and mg_dst_cset is the destination cset the
+         * target tasks on this cset should be migrated to.  Protected by
+         * cgroup_mutex.
+         */
+        struct cgroup *mg_src_cgrp;
+        struct css_set *mg_dst_cset;
+
+        /*
+         * On the default hierarhcy, ->subsys[ssid] may point to a css
+         * attached to an ancestor instead of the cgroup this css_set is
+         * associated with.  The following node is anchored at
+         * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
+         * iterate through all css's attached to a given cgroup.
+         */
+        struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
+
+        /* For RCU-protected deletion */
+        struct rcu_head rcu_head;
+};
+
+struct cgroup {
+        /* self css with NULL ->ss, points back to this cgroup */
+        struct cgroup_subsys_state self;
+
+        unsigned long flags;            /* "unsigned long" so bitops work */
+
+        /*
+         * idr allocated in-hierarchy ID.
+         *
+         * ID 0 is not used, the ID of the root cgroup is always 1, and a
+         * new cgroup will be assigned with a smallest available ID.
+         *
+         * Allocating/Removing ID must be protected by cgroup_mutex.
+         */
+        int id;
+
+        /*
+         * If this cgroup contains any tasks, it contributes one to
+         * populated_cnt.  All children with non-zero popuplated_cnt of
+         * their own contribute one.  The count is zero iff there's no task
+         * in this cgroup or its subtree.
+         */
+        int populated_cnt;
+
+        struct kernfs_node *kn;         /* cgroup kernfs entry */
+        struct kernfs_node *procs_kn;   /* kn for "cgroup.procs" */
+        struct kernfs_node *populated_kn; /* kn for "cgroup.subtree_populated" */
+
+        /*
+         * The bitmask of subsystems enabled on the child cgroups.
+         * ->subtree_control is the one configured through
+         * "cgroup.subtree_control" while ->child_subsys_mask is the
+         * effective one which may have more subsystems enabled.
+         * Controller knobs are made available iff it's enabled in
+         * ->subtree_control.
+         */
+        unsigned int subtree_control;
+        unsigned int child_subsys_mask;
+
+        /* Private pointers for each registered subsystem */
+        struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
+
+        struct cgroup_root *root;
+
+        /*
+         * List of cgrp_cset_links pointing at css_sets with tasks in this
+         * cgroup.  Protected by css_set_lock.
+         */
+        struct list_head cset_links;
+
+        /*
+         * On the default hierarchy, a css_set for a cgroup with some
+         * susbsys disabled will point to css's which are associated with
+         * the closest ancestor which has the subsys enabled.  The
+         * following lists all css_sets which point to this cgroup's css
+         * for the given subsystem.
+         */
+        struct list_head e_csets[CGROUP_SUBSYS_COUNT];
+
+        /*
+         * list of pidlists, up to two for each namespace (one for procs, one
+         * for tasks); created on demand.
+         */
+        struct list_head pidlists;
+        struct mutex pidlist_mutex;
+
+        /* used to wait for offlining of csses */
+        wait_queue_head_t offline_waitq;
+
+        /* used to schedule release agent */
+        struct work_struct release_agent_work;
+};
+
+/*
+ * A cgroup_root represents the root of a cgroup hierarchy, and may be
+ * associated with a kernfs_root to form an active hierarchy.  This is
+ * internal to cgroup core.  Don't access directly from controllers.
+ */
+struct cgroup_root {
+        struct kernfs_root *kf_root;
+
+        /* The bitmask of subsystems attached to this hierarchy */
+        unsigned int subsys_mask;
+
+        /* Unique id for this hierarchy. */
+        int hierarchy_id;
+
+        /* The root cgroup.  Root is destroyed on its release. */
+        struct cgroup cgrp;
+
+        /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
+        atomic_t nr_cgrps;
+
+        /* A list running through the active hierarchies */
+        struct list_head root_list;
+
+        /* Hierarchy-specific flags */
+        unsigned int flags;
+
+        /* IDs for cgroups in this hierarchy */
+        struct idr cgroup_idr;
+
+        /* The path to use for release notifications. */
+        char release_agent_path[PATH_MAX];
+
+        /* The name for this hierarchy - may be empty */
+        char name[MAX_CGROUP_ROOT_NAMELEN];
+};
+
+/*
+ * struct cftype: handler definitions for cgroup control files
+ *
+ * When reading/writing to a file:
+ *      - 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
+ */
+struct cftype {
+        /*
+         * By convention, the name should begin with the name of the
+         * subsystem, followed by a period.  Zero length string indicates
+         * end of cftype array.
+         */
+        char name[MAX_CFTYPE_NAME];
+        int private;
+        /*
+         * If not 0, file mode is set to this value, otherwise it will
+         * be figured out automatically
+         */
+        umode_t mode;
+
+        /*
+         * The maximum length of string, excluding trailing nul, that can
+         * be passed to write.  If < PAGE_SIZE-1, PAGE_SIZE-1 is assumed.
+         */
+        size_t max_write_len;
+
+        /* CFTYPE_* flags */
+        unsigned int flags;
+
+        /*
+         * Fields used for internal bookkeeping.  Initialized automatically
+         * during registration.
+         */
+        struct cgroup_subsys *ss;       /* NULL for cgroup core files */
+        struct list_head node;          /* anchored at ss->cfts */
+        struct kernfs_ops *kf_ops;
+
+        /*
+         * read_u64() is a shortcut for the common case of returning a
+         * single integer. Use it in place of read()
+         */
+        u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
+        /*
+         * read_s64() is a signed version of read_u64()
+         */
+        s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
+
+        /* generic seq_file read interface */
+        int (*seq_show)(struct seq_file *sf, void *v);
+
+        /* optional ops, implement all or none */
+        void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
+        void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
+        void (*seq_stop)(struct seq_file *sf, void *v);
+
+        /*
+         * write_u64() is a shortcut for the common case of accepting
+         * a single integer (as parsed by simple_strtoull) from
+         * userspace. Use in place of write(); return 0 or error.
+         */
+        int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
+                         u64 val);
+        /*
+         * write_s64() is a signed version of write_u64()
+         */
+        int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
+                         s64 val);
+
+        /*
+         * write() is the generic write callback which maps directly to
+         * kernfs write operation and overrides all other operations.
+         * Maximum write size is determined by ->max_write_len.  Use
+         * of_css/cft() to access the associated css and cft.
+         */
+        ssize_t (*write)(struct kernfs_open_file *of,
+                         char *buf, size_t nbytes, loff_t off);
+
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        struct lock_class_key   lockdep_key;
+#endif
+};
+
+/*
+ * Control Group subsystem type.
+ * See Documentation/cgroups/cgroups.txt for details
+ */
+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);
+        void (*cancel_attach)(struct cgroup_subsys_state *css,
+                              struct cgroup_taskset *tset);
+        void (*attach)(struct cgroup_subsys_state *css,
+                       struct cgroup_taskset *tset);
+        void (*fork)(struct task_struct *task);
+        void (*exit)(struct cgroup_subsys_state *css,
+                     struct cgroup_subsys_state *old_css,
+                     struct task_struct *task);
+        void (*bind)(struct cgroup_subsys_state *root_css);
+
+        int disabled;
+        int early_init;
+
+        /*
+         * If %false, this subsystem is properly hierarchical -
+         * configuration, resource accounting and restriction on a parent
+         * cgroup cover those of its children.  If %true, hierarchy support
+         * is broken in some ways - some subsystems ignore hierarchy
+         * completely while others are only implemented half-way.
+         *
+         * It's now disallowed to create nested cgroups if the subsystem is
+         * broken and cgroup core will emit a warning message on such
+         * cases.  Eventually, all subsystems will be made properly
+         * hierarchical and this will go away.
+         */
+        bool broken_hierarchy;
+        bool warned_broken_hierarchy;
+
+        /* the following two fields are initialized automtically during boot */
+        int id;
+        const char *name;
+
+        /* link to parent, protected by cgroup_lock() */
+        struct cgroup_root *root;
+
+        /* idr for css->id */
+        struct idr css_idr;
+
+        /*
+         * List of cftypes.  Each entry is the first entry of an array
+         * terminated by zero length name.
+         */
+        struct list_head cfts;
+
+        /*
+         * Base cftypes which are automatically registered.  The two can
+         * point to the same array.
+         */
+        struct cftype *dfl_cftypes;     /* for the default hierarchy */
+        struct cftype *legacy_cftypes;  /* for the legacy hierarchies */
+
+        /*
+         * A subsystem may depend on other subsystems.  When such subsystem
+         * is enabled on a cgroup, the depended-upon subsystems are enabled
+         * together if available.  Subsystems enabled due to dependency are
+         * not visible to userland until explicitly enabled.  The following
+         * specifies the mask of subsystems that this one depends on.
+         */
+        unsigned int depends_on;
+};
+
+extern struct percpu_rw_semaphore cgroup_threadgroup_rwsem;
+
+/**
+ * cgroup_threadgroup_change_begin - threadgroup exclusion for cgroups
+ * @tsk: target task
+ *
+ * Called from threadgroup_change_begin() and allows cgroup operations to
+ * synchronize against threadgroup changes using a percpu_rw_semaphore.
+ */
+static inline void cgroup_threadgroup_change_begin(struct task_struct *tsk)
+{
+        percpu_down_read(&cgroup_threadgroup_rwsem);
+}
+
+/**
+ * cgroup_threadgroup_change_end - threadgroup exclusion for cgroups
+ * @tsk: target task
+ *
+ * Called from threadgroup_change_end().  Counterpart of
+ * cgroup_threadcgroup_change_begin().
+ */
+static inline void cgroup_threadgroup_change_end(struct task_struct *tsk)
+{
+        percpu_up_read(&cgroup_threadgroup_rwsem);
+}
+
+#else   /* CONFIG_CGROUPS */
+
+#define CGROUP_SUBSYS_COUNT 0
+
+static inline void cgroup_threadgroup_change_begin(struct task_struct *tsk) {}
+static inline void cgroup_threadgroup_change_end(struct task_struct *tsk) {}
+
+#endif  /* CONFIG_CGROUPS */
+
+#endif  /* _LINUX_CGROUP_DEFS_H */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index b9cb94c3102a..a593e299162e 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -11,94 +11,200 @@
 #include <linux/sched.h>
 #include <linux/cpumask.h>
 #include <linux/nodemask.h>
-#include <linux/rcupdate.h>
 #include <linux/rculist.h>
 #include <linux/cgroupstats.h>
 #include <linux/rwsem.h>
-#include <linux/idr.h>
-#include <linux/workqueue.h>
 #include <linux/fs.h>
-#include <linux/percpu-refcount.h>
 #include <linux/seq_file.h>
 #include <linux/kernfs.h>
-#include <linux/wait.h>
+
+#include <linux/cgroup-defs.h>
 
 #ifdef CONFIG_CGROUPS
 
-struct cgroup_root;
-struct cgroup_subsys;
-struct cgroup;
+/* a css_task_iter should be treated as an opaque object */
+struct css_task_iter {
+        struct cgroup_subsys            *ss;
 
-extern int cgroup_init_early(void);
-extern int cgroup_init(void);
-extern void cgroup_fork(struct task_struct *p);
-extern void cgroup_post_fork(struct task_struct *p);
-extern void cgroup_exit(struct task_struct *p);
-extern int cgroupstats_build(struct cgroupstats *stats,
-                                struct dentry *dentry);
+        struct list_head                *cset_pos;
+        struct list_head                *cset_head;
 
-extern int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
-                            struct pid *pid, struct task_struct *tsk);
+        struct list_head                *task_pos;
+        struct list_head                *tasks_head;
+        struct list_head                *mg_tasks_head;
+};
 
-/* define the enumeration of all cgroup subsystems */
-#define SUBSYS(_x) _x ## _cgrp_id,
-enum cgroup_subsys_id {
+extern struct cgroup_root cgrp_dfl_root;
+extern struct css_set init_css_set;
+
+#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
 #include <linux/cgroup_subsys.h>
-        CGROUP_SUBSYS_COUNT,
-};
 #undef SUBSYS
 
+bool css_has_online_children(struct cgroup_subsys_state *css);
+struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
+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);
+
+bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
+int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
+int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
+
+int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
+int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
+int cgroup_rm_cftypes(struct cftype *cfts);
+
+char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
+int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry);
+int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
+                     struct pid *pid, struct task_struct *tsk);
+
+void cgroup_fork(struct task_struct *p);
+void cgroup_post_fork(struct task_struct *p);
+void cgroup_exit(struct task_struct *p);
+
+int cgroup_init_early(void);
+int cgroup_init(void);
+
 /*
- * Per-subsystem/per-cgroup state maintained by the system.  This is the
- * fundamental structural building block that controllers deal with.
+ * Iteration helpers and macros.
+ */
+
+struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
+                                           struct cgroup_subsys_state *parent);
+struct cgroup_subsys_state *css_next_descendant_pre(struct cgroup_subsys_state *pos,
+                                                    struct cgroup_subsys_state *css);
+struct cgroup_subsys_state *css_rightmost_descendant(struct cgroup_subsys_state *pos);
+struct cgroup_subsys_state *css_next_descendant_post(struct cgroup_subsys_state *pos,
+                                                     struct cgroup_subsys_state *css);
+
+struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
+struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
+
+void css_task_iter_start(struct cgroup_subsys_state *css,
+                         struct css_task_iter *it);
+struct task_struct *css_task_iter_next(struct css_task_iter *it);
+void css_task_iter_end(struct css_task_iter *it);
+
+/**
+ * css_for_each_child - iterate through children of a css
+ * @pos: the css * to use as the loop cursor
+ * @parent: css whose children to walk
  *
- * Fields marked with "PI:" are public and immutable and may be accessed
- * directly without synchronization.
+ * Walk @parent's children.  Must be called under rcu_read_lock().
+ *
+ * If a subsystem synchronizes ->css_online() and the start of iteration, a
+ * css which finished ->css_online() is guaranteed to be visible in the
+ * future iterations and will stay visible until the last reference is put.
+ * A css which hasn't finished ->css_online() or already finished
+ * ->css_offline() may show up during traversal.  It's each subsystem's
+ * responsibility to synchronize against on/offlining.
+ *
+ * It is allowed to temporarily drop RCU read lock during iteration.  The
+ * caller is responsible for ensuring that @pos remains accessible until
+ * the start of the next iteration by, for example, bumping the css refcnt.
  */
-struct cgroup_subsys_state {
-        /* PI: the cgroup that this css is attached to */
-        struct cgroup *cgroup;
-
-        /* PI: the cgroup subsystem that this css is attached to */
-        struct cgroup_subsys *ss;
-
-        /* reference count - access via css_[try]get() and css_put() */
-        struct percpu_ref refcnt;
-
-        /* PI: the parent css */
-        struct cgroup_subsys_state *parent;
-
-        /* siblings list anchored at the parent's ->children */
-        struct list_head sibling;
-        struct list_head children;
-
-        /*
-         * PI: Subsys-unique ID.  0 is unused and root is always 1.  The
-         * matching css can be looked up using css_from_id().
-         */
-        int id;
-
-        unsigned int flags;
-
-        /*
-         * Monotonically increasing unique serial number which defines a
-         * uniform order among all csses.  It's guaranteed that all
-         * ->children lists are in the ascending order of ->serial_nr and
-         * used to allow interrupting and resuming iterations.
-         */
-        u64 serial_nr;
-
-        /* percpu_ref killing and RCU release */
-        struct rcu_head rcu_head;
-        struct work_struct destroy_work;
-};
+#define css_for_each_child(pos, parent)                                 \
+        for ((pos) = css_next_child(NULL, (parent)); (pos);             \
+             (pos) = css_next_child((pos), (parent)))
 
-/* bits in struct cgroup_subsys_state flags field */
-enum {
-        CSS_NO_REF      = (1 << 0), /* no reference counting for this css */
-        CSS_ONLINE      = (1 << 1), /* between ->css_online() and ->css_offline() */
-        CSS_RELEASED    = (1 << 2), /* refcnt reached zero, released */
-};
+/**
+ * css_for_each_descendant_pre - pre-order walk of a css's descendants
+ * @pos: the css * to use as the loop cursor
+ * @root: css whose descendants to walk
+ *
+ * Walk @root's descendants.  @root is included in the iteration and the
+ * first node to be visited.  Must be called under rcu_read_lock().
+ *
+ * If a subsystem synchronizes ->css_online() and the start of iteration, a
+ * css which finished ->css_online() is guaranteed to be visible in the
+ * future iterations and will stay visible until the last reference is put.
+ * A css which hasn't finished ->css_online() or already finished
+ * ->css_offline() may show up during traversal.  It's each subsystem's
+ * responsibility to synchronize against on/offlining.
+ *
+ * For example, the following guarantees that a descendant can't escape
+ * state updates of its ancestors.
+ *
+ * my_online(@css)
+ * {
+ *      Lock @css's parent and @css;
+ *      Inherit state from the parent;
+ *      Unlock both.
+ * }
+ *
+ * my_update_state(@css)
+ * {
+ *      css_for_each_descendant_pre(@pos, @css) {
+ *              Lock @pos;
+ *              if (@pos == @css)
+ *                      Update @css's state;
+ *              else
+ *                      Verify @pos is alive and inherit state from its parent;
+ *              Unlock @pos;
+ *      }
+ * }
+ *
+ * As long as the inheriting step, including checking the parent state, is
+ * enclosed inside @pos locking, double-locking the parent isn't necessary
+ * while inheriting.  The state update to the parent is guaranteed to be
+ * visible by walking order and, as long as inheriting operations to the
+ * same @pos are atomic to each other, multiple updates racing each other
+ * still result in the correct state.  It's guaranateed that at least one
+ * inheritance happens for any css after the latest update to its parent.
+ *
+ * If checking parent's state requires locking the parent, each inheriting
+ * iteration should lock and unlock both @pos->parent and @pos.
+ *
+ * Alternatively, a subsystem may choose to use a single global lock to
+ * synchronize ->css_online() and ->css_offline() against tree-walking
+ * operations.
+ *
+ * It is allowed to temporarily drop RCU read lock during iteration.  The
+ * caller is responsible for ensuring that @pos remains accessible until
+ * the start of the next iteration by, for example, bumping the css refcnt.
+ */
+#define css_for_each_descendant_pre(pos, css)                           \
+        for ((pos) = css_next_descendant_pre(NULL, (css)); (pos);       \
+             (pos) = css_next_descendant_pre((pos), (css)))
+
+/**
+ * css_for_each_descendant_post - post-order walk of a css's descendants
+ * @pos: the css * to use as the loop cursor
+ * @css: css whose descendants to walk
+ *
+ * Similar to css_for_each_descendant_pre() but performs post-order
+ * traversal instead.  @root is included in the iteration and the last
+ * node to be visited.
+ *
+ * If a subsystem synchronizes ->css_online() and the start of iteration, a
+ * css which finished ->css_online() is guaranteed to be visible in the
+ * future iterations and will stay visible until the last reference is put.
+ * A css which hasn't finished ->css_online() or already finished
+ * ->css_offline() may show up during traversal.  It's each subsystem's
+ * responsibility to synchronize against on/offlining.
+ *
+ * Note that the walk visibility guarantee example described in pre-order
+ * walk doesn't apply the same to post-order walks.
+ */
+#define css_for_each_descendant_post(pos, css)                          \
+        for ((pos) = css_next_descendant_post(NULL, (css)); (pos);      \
+             (pos) = css_next_descendant_post((pos), (css)))
+
+/**
+ * cgroup_taskset_for_each - iterate cgroup_taskset
+ * @task: the loop cursor
+ * @tset: taskset to iterate
+ */
+#define cgroup_taskset_for_each(task, tset)                             \
+        for ((task) = cgroup_taskset_first((tset)); (task);             \
+             (task) = cgroup_taskset_next((tset)))
+
+/*
+ * Inline functions.
+ */
 
 /**
  * css_get - obtain a reference on the specified css
@@ -185,309 +291,112 @@ static inline void css_put_many(struct cgroup_subsys_state *css, unsigned int n)
                 percpu_ref_put_many(&css->refcnt, n);
 }
 
-/* bits in struct cgroup flags field */
-enum {
-        /* Control Group requires release notifications to userspace */
-        CGRP_NOTIFY_ON_RELEASE,
-        /*
-         * Clone the parent's configuration when creating a new child
-         * cpuset cgroup.  For historical reasons, this option can be
-         * specified at mount time and thus is implemented here.
-         */
-        CGRP_CPUSET_CLONE_CHILDREN,
-};
-
-struct cgroup {
-        /* self css with NULL ->ss, points back to this cgroup */
-        struct cgroup_subsys_state self;
-
-        unsigned long flags;            /* "unsigned long" so bitops work */
-
-        /*
-         * idr allocated in-hierarchy ID.
-         *
-         * ID 0 is not used, the ID of the root cgroup is always 1, and a
-         * new cgroup will be assigned with a smallest available ID.
-         *
-         * Allocating/Removing ID must be protected by cgroup_mutex.
-         */
-        int id;
-
-        /*
-         * If this cgroup contains any tasks, it contributes one to
-         * populated_cnt.  All children with non-zero popuplated_cnt of
-         * their own contribute one.  The count is zero iff there's no task
-         * in this cgroup or its subtree.
-         */
-        int populated_cnt;
-
-        struct kernfs_node *kn;         /* cgroup kernfs entry */
-        struct kernfs_node *populated_kn; /* kn for "cgroup.subtree_populated" */
-
-        /*
-         * The bitmask of subsystems enabled on the child cgroups.
-         * ->subtree_control is the one configured through
-         * "cgroup.subtree_control" while ->child_subsys_mask is the
-         * effective one which may have more subsystems enabled.
-         * Controller knobs are made available iff it's enabled in
-         * ->subtree_control.
-         */
-        unsigned int subtree_control;
-        unsigned int child_subsys_mask;
-
-        /* Private pointers for each registered subsystem */
-        struct cgroup_subsys_state __rcu *subsys[CGROUP_SUBSYS_COUNT];
-
-        struct cgroup_root *root;
-
-        /*
-         * List of cgrp_cset_links pointing at css_sets with tasks in this
-         * cgroup.  Protected by css_set_lock.
-         */
-        struct list_head cset_links;
-
-        /*
-         * On the default hierarchy, a css_set for a cgroup with some
-         * susbsys disabled will point to css's which are associated with
-         * the closest ancestor which has the subsys enabled.  The
-         * following lists all css_sets which point to this cgroup's css
-         * for the given subsystem.
-         */
-        struct list_head e_csets[CGROUP_SUBSYS_COUNT];
-
-        /*
-         * list of pidlists, up to two for each namespace (one for procs, one
-         * for tasks); created on demand.
-         */
-        struct list_head pidlists;
-        struct mutex pidlist_mutex;
-
-        /* 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
-
-/* cgroup_root->flags */
-enum {
-        CGRP_ROOT_SANE_BEHAVIOR = (1 << 0), /* __DEVEL__sane_behavior specified */
-        CGRP_ROOT_NOPREFIX      = (1 << 1), /* mounted subsystems have no named prefix */
-        CGRP_ROOT_XATTR         = (1 << 2), /* supports extended attributes */
-};
-
-/*
- * A cgroup_root represents the root of a cgroup hierarchy, and may be
- * associated with a kernfs_root to form an active hierarchy.  This is
- * internal to cgroup core.  Don't access directly from controllers.
+/**
+ * task_css_set_check - obtain a task's css_set with extra access conditions
+ * @task: the task to obtain css_set for
+ * @__c: extra condition expression to be passed to rcu_dereference_check()
+ *
+ * A task's css_set is RCU protected, initialized and exited while holding
+ * task_lock(), and can only be modified while holding both cgroup_mutex
+ * and task_lock() while the task is alive.  This macro verifies that the
+ * caller is inside proper critical section and returns @task's css_set.
+ *
+ * The caller can also specify additional allowed conditions via @__c, such
+ * as locks used during the cgroup_subsys::attach() methods.
  */
-struct cgroup_root {
-        struct kernfs_root *kf_root;
-
-        /* The bitmask of subsystems attached to this hierarchy */
-        unsigned int subsys_mask;
-
-        /* Unique id for this hierarchy. */
-        int hierarchy_id;
-
-        /* The root cgroup.  Root is destroyed on its release. */
-        struct cgroup cgrp;
-
-        /* Number of cgroups in the hierarchy, used only for /proc/cgroups */
-        atomic_t nr_cgrps;
-
-        /* A list running through the active hierarchies */
-        struct list_head root_list;
-
-        /* Hierarchy-specific flags */
-        unsigned int flags;
-
-        /* IDs for cgroups in this hierarchy */
-        struct idr cgroup_idr;
-
-        /* The path to use for release notifications. */
-        char release_agent_path[PATH_MAX];
-
-        /* The name for this hierarchy - may be empty */
-        char name[MAX_CGROUP_ROOT_NAMELEN];
-};
+#ifdef CONFIG_PROVE_RCU
+extern struct mutex cgroup_mutex;
+extern struct rw_semaphore css_set_rwsem;
+#define task_css_set_check(task, __c)                                   \
+        rcu_dereference_check((task)->cgroups,                          \
+                lockdep_is_held(&cgroup_mutex) ||                       \
+                lockdep_is_held(&css_set_rwsem) ||                      \
+                ((task)->flags & PF_EXITING) || (__c))
+#else
+#define task_css_set_check(task, __c)                                   \
+        rcu_dereference((task)->cgroups)
+#endif
 
-/*
- * A css_set is a structure holding pointers to a set of
- * cgroup_subsys_state objects. This saves space in the task struct
- * object and speeds up fork()/exit(), since a single inc/dec and a
- * list_add()/del() can bump the reference count on the entire cgroup
- * set for a task.
+/**
+ * task_css_check - obtain css for (task, subsys) w/ extra access conds
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ * @__c: extra condition expression to be passed to rcu_dereference_check()
+ *
+ * Return the cgroup_subsys_state for the (@task, @subsys_id) pair.  The
+ * synchronization rules are the same as task_css_set_check().
  */
+#define task_css_check(task, subsys_id, __c)                            \
+        task_css_set_check((task), (__c))->subsys[(subsys_id)]
 
-struct css_set {
-
-        /* Reference count */
-        atomic_t refcount;
-
-        /*
-         * List running through all cgroup groups in the same hash
-         * slot. Protected by css_set_lock
-         */
-        struct hlist_node hlist;
-
-        /*
-         * Lists running through all tasks using this cgroup group.
-         * mg_tasks lists tasks which belong to this cset but are in the
-         * process of being migrated out or in.  Protected by
-         * css_set_rwsem, but, during migration, once tasks are moved to
-         * mg_tasks, it can be read safely while holding cgroup_mutex.
-         */
-        struct list_head tasks;
-        struct list_head mg_tasks;
-
-        /*
-         * List of cgrp_cset_links pointing at cgroups referenced from this
-         * css_set.  Protected by css_set_lock.
-         */
-        struct list_head cgrp_links;
-
-        /* the default cgroup associated with this css_set */
-        struct cgroup *dfl_cgrp;
-
-        /*
-         * Set of subsystem states, one for each subsystem. This array is
-         * immutable after creation apart from the init_css_set during
-         * subsystem registration (at boot time).
-         */
-        struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
-
-        /*
-         * List of csets participating in the on-going migration either as
-         * source or destination.  Protected by cgroup_mutex.
-         */
-        struct list_head mg_preload_node;
-        struct list_head mg_node;
-
-        /*
-         * If this cset is acting as the source of migration the following
-         * two fields are set.  mg_src_cgrp is the source cgroup of the
-         * on-going migration and mg_dst_cset is the destination cset the
-         * target tasks on this cset should be migrated to.  Protected by
-         * cgroup_mutex.
-         */
-        struct cgroup *mg_src_cgrp;
-        struct css_set *mg_dst_cset;
-
-        /*
-         * On the default hierarhcy, ->subsys[ssid] may point to a css
-         * attached to an ancestor instead of the cgroup this css_set is
-         * associated with.  The following node is anchored at
-         * ->subsys[ssid]->cgroup->e_csets[ssid] and provides a way to
-         * iterate through all css's attached to a given cgroup.
-         */
-        struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
-
-        /* For RCU-protected deletion */
-        struct rcu_head rcu_head;
-};
-
-/*
- * struct cftype: handler definitions for cgroup control files
+/**
+ * task_css_set - obtain a task's css_set
+ * @task: the task to obtain css_set for
  *
- * When reading/writing to a file:
- *      - 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
+ * See task_css_set_check().
  */
+static inline struct css_set *task_css_set(struct task_struct *task)
+{
+        return task_css_set_check(task, false);
+}
 
-/* cftype->flags */
-enum {
-        CFTYPE_ONLY_ON_ROOT     = (1 << 0),     /* only create on root cgrp */
-        CFTYPE_NOT_ON_ROOT      = (1 << 1),     /* don't create on root cgrp */
-        CFTYPE_NO_PREFIX        = (1 << 3),     /* (DON'T USE FOR NEW FILES) no subsys prefix */
+/**
+ * task_css - obtain css for (task, subsys)
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ *
+ * See task_css_check().
+ */
+static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
+                                                   int subsys_id)
+{
+        return task_css_check(task, subsys_id, false);
+}
 
-        /* internal flags, do not use outside cgroup core proper */
-        __CFTYPE_ONLY_ON_DFL    = (1 << 16),    /* only on default hierarchy */
-        __CFTYPE_NOT_ON_DFL     = (1 << 17),    /* not on default hierarchy */
-};
+/**
+ * task_get_css - find and get the css for (task, subsys)
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ *
+ * Find the css for the (@task, @subsys_id) combination, increment a
+ * reference on and return it.  This function is guaranteed to return a
+ * valid css.
+ */
+static inline struct cgroup_subsys_state *
+task_get_css(struct task_struct *task, int subsys_id)
+{
+        struct cgroup_subsys_state *css;
+
+        rcu_read_lock();
+        while (true) {
+                css = task_css(task, subsys_id);
+                if (likely(css_tryget_online(css)))
+                        break;
+                cpu_relax();
+        }
+        rcu_read_unlock();
+        return css;
+}
 
-#define MAX_CFTYPE_NAME         64
-
-struct cftype {
-        /*
-         * By convention, the name should begin with the name of the
-         * subsystem, followed by a period.  Zero length string indicates
-         * end of cftype array.
-         */
-        char name[MAX_CFTYPE_NAME];
-        int private;
-        /*
-         * If not 0, file mode is set to this value, otherwise it will
-         * be figured out automatically
-         */
-        umode_t mode;
-
-        /*
-         * The maximum length of string, excluding trailing nul, that can
-         * be passed to write.  If < PAGE_SIZE-1, PAGE_SIZE-1 is assumed.
-         */
-        size_t max_write_len;
-
-        /* CFTYPE_* flags */
-        unsigned int flags;
-
-        /*
-         * Fields used for internal bookkeeping.  Initialized automatically
-         * during registration.
-         */
-        struct cgroup_subsys *ss;       /* NULL for cgroup core files */
-        struct list_head node;          /* anchored at ss->cfts */
-        struct kernfs_ops *kf_ops;
-
-        /*
-         * read_u64() is a shortcut for the common case of returning a
-         * single integer. Use it in place of read()
-         */
-        u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
-        /*
-         * read_s64() is a signed version of read_u64()
-         */
-        s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
-
-        /* generic seq_file read interface */
-        int (*seq_show)(struct seq_file *sf, void *v);
-
-        /* optional ops, implement all or none */
-        void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
-        void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
-        void (*seq_stop)(struct seq_file *sf, void *v);
-
-        /*
-         * write_u64() is a shortcut for the common case of accepting
-         * a single integer (as parsed by simple_strtoull) from
-         * userspace. Use in place of write(); return 0 or error.
-         */
-        int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
-                         u64 val);
-        /*
-         * write_s64() is a signed version of write_u64()
-         */
-        int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
-                         s64 val);
-
-        /*
-         * write() is the generic write callback which maps directly to
-         * kernfs write operation and overrides all other operations.
-         * Maximum write size is determined by ->max_write_len.  Use
-         * of_css/cft() to access the associated css and cft.
-         */
-        ssize_t (*write)(struct kernfs_open_file *of,
-                         char *buf, size_t nbytes, loff_t off);
-
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        struct lock_class_key   lockdep_key;
-#endif
-};
+/**
+ * task_css_is_root - test whether a task belongs to the root css
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ *
+ * Test whether @task belongs to the root css on the specified subsystem.
+ * May be invoked in any context.
+ */
+static inline bool task_css_is_root(struct task_struct *task, int subsys_id)
+{
+        return task_css_check(task, subsys_id, true) ==
+                init_css_set.subsys[subsys_id];
+}
 
-extern struct cgroup_root cgrp_dfl_root;
-extern struct css_set init_css_set;
+static inline struct cgroup *task_cgroup(struct task_struct *task,
+                                         int subsys_id)
+{
+        return task_css(task, subsys_id)->cgroup;
+}
 
 /**
  * cgroup_on_dfl - test whether a cgroup is on the default hierarchy
@@ -604,367 +513,22 @@ static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
         pr_cont_kernfs_path(cgrp->kn);
 }
 
-char *task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
-
-int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
-int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
-int cgroup_rm_cftypes(struct cftype *cfts);
-
-bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
-
-/*
- * Control Group taskset, used to pass around set of tasks to cgroup_subsys
- * methods.
- */
-struct cgroup_taskset;
-struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset);
-struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset);
-
-/**
- * cgroup_taskset_for_each - iterate cgroup_taskset
- * @task: the loop cursor
- * @tset: taskset to iterate
- */
-#define cgroup_taskset_for_each(task, tset)                             \
-        for ((task) = cgroup_taskset_first((tset)); (task);             \
-             (task) = cgroup_taskset_next((tset)))
-
-/*
- * Control Group subsystem type.
- * See Documentation/cgroups/cgroups.txt for details
- */
-
-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);
-        void (*cancel_attach)(struct cgroup_subsys_state *css,
-                              struct cgroup_taskset *tset);
-        void (*attach)(struct cgroup_subsys_state *css,
-                       struct cgroup_taskset *tset);
-        void (*fork)(struct task_struct *task);
-        void (*exit)(struct cgroup_subsys_state *css,
-                     struct cgroup_subsys_state *old_css,
-                     struct task_struct *task);
-        void (*bind)(struct cgroup_subsys_state *root_css);
-
-        int disabled;
-        int early_init;
-
-        /*
-         * If %false, this subsystem is properly hierarchical -
-         * configuration, resource accounting and restriction on a parent
-         * cgroup cover those of its children.  If %true, hierarchy support
-         * is broken in some ways - some subsystems ignore hierarchy
-         * completely while others are only implemented half-way.
-         *
-         * It's now disallowed to create nested cgroups if the subsystem is
-         * broken and cgroup core will emit a warning message on such
-         * cases.  Eventually, all subsystems will be made properly
-         * hierarchical and this will go away.
-         */
-        bool broken_hierarchy;
-        bool warned_broken_hierarchy;
-
-        /* the following two fields are initialized automtically during boot */
-        int id;
-#define MAX_CGROUP_TYPE_NAMELEN 32
-        const char *name;
-
-        /* link to parent, protected by cgroup_lock() */
-        struct cgroup_root *root;
-
-        /* idr for css->id */
-        struct idr css_idr;
-
-        /*
-         * List of cftypes.  Each entry is the first entry of an array
-         * terminated by zero length name.
-         */
-        struct list_head cfts;
-
-        /*
-         * Base cftypes which are automatically registered.  The two can
-         * point to the same array.
-         */
-        struct cftype *dfl_cftypes;     /* for the default hierarchy */
-        struct cftype *legacy_cftypes;  /* for the legacy hierarchies */
-
-        /*
-         * A subsystem may depend on other subsystems.  When such subsystem
-         * is enabled on a cgroup, the depended-upon subsystems are enabled
-         * together if available.  Subsystems enabled due to dependency are
-         * not visible to userland until explicitly enabled.  The following
-         * specifies the mask of subsystems that this one depends on.
-         */
-        unsigned int depends_on;
-};
-
-#define SUBSYS(_x) extern struct cgroup_subsys _x ## _cgrp_subsys;
-#include <linux/cgroup_subsys.h>
-#undef SUBSYS
-
-/**
- * task_css_set_check - obtain a task's css_set with extra access conditions
- * @task: the task to obtain css_set for
- * @__c: extra condition expression to be passed to rcu_dereference_check()
- *
- * A task's css_set is RCU protected, initialized and exited while holding
- * task_lock(), and can only be modified while holding both cgroup_mutex
- * and task_lock() while the task is alive.  This macro verifies that the
- * caller is inside proper critical section and returns @task's css_set.
- *
- * The caller can also specify additional allowed conditions via @__c, such
- * as locks used during the cgroup_subsys::attach() methods.
- */
-#ifdef CONFIG_PROVE_RCU
-extern struct mutex cgroup_mutex;
-extern struct rw_semaphore css_set_rwsem;
-#define task_css_set_check(task, __c)                                   \
-        rcu_dereference_check((task)->cgroups,                          \
-                lockdep_is_held(&cgroup_mutex) ||                       \
-                lockdep_is_held(&css_set_rwsem) ||                      \
-                ((task)->flags & PF_EXITING) || (__c))
-#else
-#define task_css_set_check(task, __c)                                   \
-        rcu_dereference((task)->cgroups)
-#endif
-
-/**
- * task_css_check - obtain css for (task, subsys) w/ extra access conds
- * @task: the target task
- * @subsys_id: the target subsystem ID
- * @__c: extra condition expression to be passed to rcu_dereference_check()
- *
- * Return the cgroup_subsys_state for the (@task, @subsys_id) pair.  The
- * synchronization rules are the same as task_css_set_check().
- */
-#define task_css_check(task, subsys_id, __c)                            \
-        task_css_set_check((task), (__c))->subsys[(subsys_id)]
-
-/**
- * task_css_set - obtain a task's css_set
- * @task: the task to obtain css_set for
- *
- * See task_css_set_check().
- */
-static inline struct css_set *task_css_set(struct task_struct *task)
-{
-        return task_css_set_check(task, false);
-}
-
-/**
- * task_css - obtain css for (task, subsys)
- * @task: the target task
- * @subsys_id: the target subsystem ID
- *
- * See task_css_check().
- */
-static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
-                                                   int subsys_id)
-{
-        return task_css_check(task, subsys_id, false);
-}
-
-/**
- * task_css_is_root - test whether a task belongs to the root css
- * @task: the target task
- * @subsys_id: the target subsystem ID
- *
- * Test whether @task belongs to the root css on the specified subsystem.
- * May be invoked in any context.
- */
-static inline bool task_css_is_root(struct task_struct *task, int subsys_id)
-{
-        return task_css_check(task, subsys_id, true) ==
-                init_css_set.subsys[subsys_id];
-}
-
-static inline struct cgroup *task_cgroup(struct task_struct *task,
-                                         int subsys_id)
-{
-        return task_css(task, subsys_id)->cgroup;
-}
-
-struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
-                                           struct cgroup_subsys_state *parent);
-
-struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
-
-/**
- * css_for_each_child - iterate through children of a css
- * @pos: the css * to use as the loop cursor
- * @parent: css whose children to walk
- *
- * Walk @parent's children.  Must be called under rcu_read_lock().
- *
- * If a subsystem synchronizes ->css_online() and the start of iteration, a
- * css which finished ->css_online() is guaranteed to be visible in the
- * future iterations and will stay visible until the last reference is put.
- * A css which hasn't finished ->css_online() or already finished
- * ->css_offline() may show up during traversal.  It's each subsystem's
- * responsibility to synchronize against on/offlining.
- *
- * It is allowed to temporarily drop RCU read lock during iteration.  The
- * caller is responsible for ensuring that @pos remains accessible until
- * the start of the next iteration by, for example, bumping the css refcnt.
- */
-#define css_for_each_child(pos, parent)                                 \
-        for ((pos) = css_next_child(NULL, (parent)); (pos);             \
-             (pos) = css_next_child((pos), (parent)))
-
-struct cgroup_subsys_state *
-css_next_descendant_pre(struct cgroup_subsys_state *pos,
-                        struct cgroup_subsys_state *css);
-
-struct cgroup_subsys_state *
-css_rightmost_descendant(struct cgroup_subsys_state *pos);
-
-/**
- * css_for_each_descendant_pre - pre-order walk of a css's descendants
- * @pos: the css * to use as the loop cursor
- * @root: css whose descendants to walk
- *
- * Walk @root's descendants.  @root is included in the iteration and the
- * first node to be visited.  Must be called under rcu_read_lock().
- *
- * If a subsystem synchronizes ->css_online() and the start of iteration, a
- * css which finished ->css_online() is guaranteed to be visible in the
- * future iterations and will stay visible until the last reference is put.
- * A css which hasn't finished ->css_online() or already finished
- * ->css_offline() may show up during traversal.  It's each subsystem's
- * responsibility to synchronize against on/offlining.
- *
- * For example, the following guarantees that a descendant can't escape
- * state updates of its ancestors.
- *
- * my_online(@css)
- * {
- *      Lock @css's parent and @css;
- *      Inherit state from the parent;
- *      Unlock both.
- * }
- *
- * my_update_state(@css)
- * {
- *      css_for_each_descendant_pre(@pos, @css) {
- *              Lock @pos;
- *              if (@pos == @css)
- *                      Update @css's state;
- *              else
- *                      Verify @pos is alive and inherit state from its parent;
- *              Unlock @pos;
- *      }
- * }
- *
- * As long as the inheriting step, including checking the parent state, is
- * enclosed inside @pos locking, double-locking the parent isn't necessary
- * while inheriting.  The state update to the parent is guaranteed to be
- * visible by walking order and, as long as inheriting operations to the
- * same @pos are atomic to each other, multiple updates racing each other
- * still result in the correct state.  It's guaranateed that at least one
- * inheritance happens for any css after the latest update to its parent.
- *
- * If checking parent's state requires locking the parent, each inheriting
- * iteration should lock and unlock both @pos->parent and @pos.
- *
- * Alternatively, a subsystem may choose to use a single global lock to
- * synchronize ->css_online() and ->css_offline() against tree-walking
- * operations.
- *
- * It is allowed to temporarily drop RCU read lock during iteration.  The
- * caller is responsible for ensuring that @pos remains accessible until
- * the start of the next iteration by, for example, bumping the css refcnt.
- */
-#define css_for_each_descendant_pre(pos, css)                           \
-        for ((pos) = css_next_descendant_pre(NULL, (css)); (pos);       \
-             (pos) = css_next_descendant_pre((pos), (css)))
-
-struct cgroup_subsys_state *
-css_next_descendant_post(struct cgroup_subsys_state *pos,
-                         struct cgroup_subsys_state *css);
-
-/**
- * css_for_each_descendant_post - post-order walk of a css's descendants
- * @pos: the css * to use as the loop cursor
- * @css: css whose descendants to walk
- *
- * Similar to css_for_each_descendant_pre() but performs post-order
- * traversal instead.  @root is included in the iteration and the last
- * node to be visited.
- *
- * If a subsystem synchronizes ->css_online() and the start of iteration, a
- * css which finished ->css_online() is guaranteed to be visible in the
- * future iterations and will stay visible until the last reference is put.
- * A css which hasn't finished ->css_online() or already finished
- * ->css_offline() may show up during traversal.  It's each subsystem's
- * responsibility to synchronize against on/offlining.
- *
- * Note that the walk visibility guarantee example described in pre-order
- * walk doesn't apply the same to post-order walks.
- */
-#define css_for_each_descendant_post(pos, css)                          \
-        for ((pos) = css_next_descendant_post(NULL, (css)); (pos);      \
-             (pos) = css_next_descendant_post((pos), (css)))
-
-bool css_has_online_children(struct cgroup_subsys_state *css);
-
-/* A css_task_iter should be treated as an opaque object */
-struct css_task_iter {
-        struct cgroup_subsys            *ss;
-
-        struct list_head                *cset_pos;
-        struct list_head                *cset_head;
-
-        struct list_head                *task_pos;
-        struct list_head                *tasks_head;
-        struct list_head                *mg_tasks_head;
-};
-
-void css_task_iter_start(struct cgroup_subsys_state *css,
-                         struct css_task_iter *it);
-struct task_struct *css_task_iter_next(struct css_task_iter *it);
-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);
-
 #else /* !CONFIG_CGROUPS */
 
 struct cgroup_subsys_state;
 
-static inline int cgroup_init_early(void) { return 0; }
-static inline int cgroup_init(void) { return 0; }
+static inline void css_put(struct cgroup_subsys_state *css) {}
+static inline int cgroup_attach_task_all(struct task_struct *from,
+                                         struct task_struct *t) { return 0; }
+static inline int cgroupstats_build(struct cgroupstats *stats,
+                                    struct dentry *dentry) { return -EINVAL; }
+
 static inline void cgroup_fork(struct task_struct *p) {}
 static inline void cgroup_post_fork(struct task_struct *p) {}
 static inline void cgroup_exit(struct task_struct *p) {}
 
-static inline int cgroupstats_build(struct cgroupstats *stats,
-                                        struct dentry *dentry)
-{
-        return -EINVAL;
-}
-
-static inline void css_put(struct cgroup_subsys_state *css) {}
-
-/* No cgroups - nothing to do */
-static inline int cgroup_attach_task_all(struct task_struct *from,
-                                         struct task_struct *t)
-{
-        return 0;
-}
+static inline int cgroup_init_early(void) { return 0; }
+static inline int cgroup_init(void) { return 0; }
 
 #endif /* !CONFIG_CGROUPS */
 
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index df695313f975..78842f46f152 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -31,6 +31,7 @@
 #define CLK_GET_RATE_NOCACHE    BIT(6) /* do not use the cached clk rate */
 #define CLK_SET_RATE_NO_REPARENT BIT(7) /* don't re-parent on rate change */
 #define CLK_GET_ACCURACY_NOCACHE BIT(8) /* do not use the cached clk accuracy */
+#define CLK_RECALC_NEW_RATES    BIT(9) /* recalc rates after notifications */
 
 struct clk_hw;
 struct clk_core;
@@ -209,7 +210,7 @@ struct clk_ops {
 struct clk_init_data {
         const char              *name;
         const struct clk_ops    *ops;
-        const char              **parent_names;
+        const char              * const *parent_names;
         u8                      num_parents;
         unsigned long           flags;
 };
@@ -426,12 +427,14 @@ extern const struct clk_ops clk_mux_ops;
 extern const struct clk_ops clk_mux_ro_ops;
 
 struct clk *clk_register_mux(struct device *dev, const char *name,
-                const char **parent_names, u8 num_parents, unsigned long flags,
+                const char * const *parent_names, u8 num_parents,
+                unsigned long flags,
                 void __iomem *reg, u8 shift, u8 width,
                 u8 clk_mux_flags, spinlock_t *lock);
 
 struct clk *clk_register_mux_table(struct device *dev, const char *name,
-                const char **parent_names, u8 num_parents, unsigned long flags,
+                const char * const *parent_names, u8 num_parents,
+                unsigned long flags,
                 void __iomem *reg, u8 shift, u32 mask,
                 u8 clk_mux_flags, u32 *table, spinlock_t *lock);
 
@@ -457,7 +460,7 @@ struct clk_fixed_factor {
         unsigned int    div;
 };
 
-extern struct clk_ops clk_fixed_factor_ops;
+extern const struct clk_ops clk_fixed_factor_ops;
 struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
                 const char *parent_name, unsigned long flags,
                 unsigned int mult, unsigned int div);
@@ -518,7 +521,7 @@ struct clk_composite {
 };
 
 struct clk *clk_register_composite(struct device *dev, const char *name,
-                const char **parent_names, int num_parents,
+                const char * const *parent_names, int num_parents,
                 struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
                 struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
                 struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
@@ -589,6 +592,7 @@ long __clk_mux_determine_rate_closest(struct clk_hw *hw, unsigned long rate,
                               unsigned long max_rate,
                               unsigned long *best_parent_rate,
                               struct clk_hw **best_parent_p);
+void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent);
 
 static inline void __clk_hw_set_clk(struct clk_hw *dst, struct clk_hw *src)
 {
@@ -624,6 +628,8 @@ struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
                                   void *data);
 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);
 int of_clk_get_parent_count(struct device_node *np);
+int of_clk_parent_fill(struct device_node *np, const char **parents,
+                       unsigned int size);
 const char *of_clk_get_parent_name(struct device_node *np, int index);
 
 void of_clk_init(const struct of_device_id *matches);
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 68c16a6bedb3..0df4a51e1a78 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -306,6 +306,20 @@ void devm_clk_put(struct device *dev, struct clk *clk);
  * @clk: clock source
  * @rate: desired clock rate in Hz
  *
+ * This answers the question "if I were to pass @rate to clk_set_rate(),
+ * what clock rate would I end up with?" without changing the hardware
+ * in any way.  In other words:
+ *
+ *   rate = clk_round_rate(clk, r);
+ *
+ * and:
+ *
+ *   clk_set_rate(clk, r);
+ *   rate = clk_get_rate(clk);
+ *
+ * are equivalent except the former does not modify the clock hardware
+ * in any way.
+ *
  * Returns rounded clock rate in Hz, or negative errno.
  */
 long clk_round_rate(struct clk *clk, unsigned long rate);
@@ -471,19 +485,6 @@ static inline void clk_disable_unprepare(struct clk *clk)
         clk_unprepare(clk);
 }
 
-/**
- * clk_add_alias - add a new clock alias
- * @alias: name for clock alias
- * @alias_dev_name: device name
- * @id: platform specific clock name
- * @dev: device
- *
- * Allows using generic clock names for drivers by adding a new alias.
- * Assumes clkdev, see clkdev.h for more info.
- */
-int clk_add_alias(const char *alias, const char *alias_dev_name, char *id,
-                        struct device *dev);
-
 struct device_node;
 struct of_phandle_args;
 
diff --git a/include/linux/clkdev.h b/include/linux/clkdev.h
index 94bad77eeb4a..08bffcc466de 100644
--- a/include/linux/clkdev.h
+++ b/include/linux/clkdev.h
@@ -22,6 +22,7 @@ struct clk_lookup {
         const char              *dev_id;
         const char              *con_id;
         struct clk              *clk;
+        struct clk_hw           *clk_hw;
 };
 
 #define CLKDEV_INIT(d, n, c)    \
@@ -32,15 +33,19 @@ struct clk_lookup {
         }
 
 struct clk_lookup *clkdev_alloc(struct clk *clk, const char *con_id,
-        const char *dev_fmt, ...);
+        const char *dev_fmt, ...) __printf(3, 4);
 
 void clkdev_add(struct clk_lookup *cl);
 void clkdev_drop(struct clk_lookup *cl);
 
+struct clk_lookup *clkdev_create(struct clk *clk, const char *con_id,
+        const char *dev_fmt, ...) __printf(3, 4);
+
 void clkdev_add_table(struct clk_lookup *, size_t);
-int clk_add_alias(const char *, const char *, char *, struct device *);
+int clk_add_alias(const char *, const char *, const char *, struct device *);
 
-int clk_register_clkdev(struct clk *, const char *, const char *, ...);
+int clk_register_clkdev(struct clk *, const char *, const char *, ...)
+        __printf(3, 4);
 int clk_register_clkdevs(struct clk *, struct clk_lookup *, size_t);
 
 #ifdef CONFIG_COMMON_CLK
diff --git a/include/linux/compat.h b/include/linux/compat.h
index ab25814690bc..a76c9172b2eb 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -424,7 +424,7 @@ asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv,
 
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 
-extern int compat_printk(const char *fmt, ...);
+extern __printf(1, 2) int compat_printk(const char *fmt, ...);
 extern void sigset_from_compat(sigset_t *set, const compat_sigset_t *compat);
 extern void sigset_to_compat(compat_sigset_t *compat, const sigset_t *set);
 
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 371e560d13cf..dfaa7b3e9ae9 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -5,9 +5,9 @@
 /*
  * Common definitions for all gcc versions go here.
  */
-#define GCC_VERSION (__GNUC__ * 10000 \
-                   + __GNUC_MINOR__ * 100 \
-                   + __GNUC_PATCHLEVEL__)
+#define GCC_VERSION (__GNUC__ * 10000           \
+                     + __GNUC_MINOR__ * 100     \
+                     + __GNUC_PATCHLEVEL__)
 
 /* Optimization barrier */
 
@@ -46,55 +46,63 @@
  * the inline assembly constraint from =g to =r, in this particular
  * case either is valid.
  */
-#define RELOC_HIDE(ptr, off)                                    \
-  ({ unsigned long __ptr;                                       \
-    __asm__ ("" : "=r"(__ptr) : "0"(ptr));              \
-    (typeof(ptr)) (__ptr + (off)); })
+#define RELOC_HIDE(ptr, off)                                            \
+({                                                                      \
+        unsigned long __ptr;                                            \
+        __asm__ ("" : "=r"(__ptr) : "0"(ptr));                          \
+        (typeof(ptr)) (__ptr + (off));                                  \
+})
 
 /* Make the optimizer believe the variable can be manipulated arbitrarily. */
-#define OPTIMIZER_HIDE_VAR(var) __asm__ ("" : "=r" (var) : "0" (var))
+#define OPTIMIZER_HIDE_VAR(var)                                         \
+        __asm__ ("" : "=r" (var) : "0" (var))
 
 #ifdef __CHECKER__
-#define __must_be_array(arr) 0
+#define __must_be_array(a)      0
 #else
 /* &a[0] degrades to a pointer: a different type from an array */
-#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
+#define __must_be_array(a)      BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
 #endif
 
 /*
  * Force always-inline if the user requests it so via the .config,
  * or if gcc is too old:
  */
-#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) || \
+#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) ||                \
     !defined(CONFIG_OPTIMIZE_INLINING) || (__GNUC__ < 4)
-# define inline         inline          __attribute__((always_inline)) notrace
-# define __inline__     __inline__      __attribute__((always_inline)) notrace
-# define __inline       __inline        __attribute__((always_inline)) notrace
+#define inline          inline          __attribute__((always_inline)) notrace
+#define __inline__      __inline__      __attribute__((always_inline)) notrace
+#define __inline        __inline        __attribute__((always_inline)) notrace
 #else
 /* A lot of inline functions can cause havoc with function tracing */
-# define inline         inline          notrace
-# define __inline__     __inline__      notrace
-# define __inline       __inline        notrace
+#define inline          inline          notrace
+#define __inline__      __inline__      notrace
+#define __inline        __inline        notrace
 #endif
 
-#define __deprecated                    __attribute__((deprecated))
-#define __packed                        __attribute__((packed))
-#define __weak                          __attribute__((weak))
-#define __alias(symbol)         __attribute__((alias(#symbol)))
+#define __always_inline inline __attribute__((always_inline))
+#define  noinline       __attribute__((noinline))
+
+#define __deprecated    __attribute__((deprecated))
+#define __packed        __attribute__((packed))
+#define __weak          __attribute__((weak))
+#define __alias(symbol) __attribute__((alias(#symbol)))
 
 /*
- * it doesn't make sense on ARM (currently the only user of __naked) to trace
- * naked functions because then mcount is called without stack and frame pointer
- * being set up and there is no chance to restore the lr register to the value
- * before mcount was called.
+ * it doesn't make sense on ARM (currently the only user of __naked)
+ * to trace naked functions because then mcount is called without
+ * stack and frame pointer being set up and there is no chance to
+ * restore the lr register to the value before mcount was called.
+ *
+ * The asm() bodies of naked functions often depend on standard calling
+ * conventions, therefore they must be noinline and noclone.
  *
- * The asm() bodies of naked functions often depend on standard calling conventions,
- * therefore they must be noinline and noclone.  GCC 4.[56] currently fail to enforce
- * this, so we must do so ourselves.  See GCC PR44290.
+ * GCC 4.[56] currently fail to enforce this, so we must do so ourselves.
+ * See GCC PR44290.
  */
-#define __naked                         __attribute__((naked)) noinline __noclone notrace
+#define __naked         __attribute__((naked)) noinline __noclone notrace
 
-#define __noreturn                      __attribute__((noreturn))
+#define __noreturn      __attribute__((noreturn))
 
 /*
  * From the GCC manual:
@@ -106,19 +114,130 @@
  * would be.
  * [...]
  */
-#define __pure                          __attribute__((pure))
-#define __aligned(x)                    __attribute__((aligned(x)))
-#define __printf(a, b)                  __attribute__((format(printf, a, b)))
-#define __scanf(a, b)                   __attribute__((format(scanf, a, b)))
-#define  noinline                       __attribute__((noinline))
-#define __attribute_const__             __attribute__((__const__))
-#define __maybe_unused                  __attribute__((unused))
-#define __always_unused                 __attribute__((unused))
-
-#define __gcc_header(x) #x
-#define _gcc_header(x) __gcc_header(linux/compiler-gcc##x.h)
-#define gcc_header(x) _gcc_header(x)
-#include gcc_header(__GNUC__)
+#define __pure                  __attribute__((pure))
+#define __aligned(x)            __attribute__((aligned(x)))
+#define __printf(a, b)          __attribute__((format(printf, a, b)))
+#define __scanf(a, b)           __attribute__((format(scanf, a, b)))
+#define __attribute_const__     __attribute__((__const__))
+#define __maybe_unused          __attribute__((unused))
+#define __always_unused         __attribute__((unused))
+
+/* gcc version specific checks */
+
+#if GCC_VERSION < 30200
+# error Sorry, your compiler is too old - please upgrade it.
+#endif
+
+#if GCC_VERSION < 30300
+# define __used                 __attribute__((__unused__))
+#else
+# define __used                 __attribute__((__used__))
+#endif
+
+#ifdef CONFIG_GCOV_KERNEL
+# if GCC_VERSION < 30400
+#   error "GCOV profiling support for gcc versions below 3.4 not included"
+# endif /* __GNUC_MINOR__ */
+#endif /* CONFIG_GCOV_KERNEL */
+
+#if GCC_VERSION >= 30400
+#define __must_check            __attribute__((warn_unused_result))
+#endif
+
+#if GCC_VERSION >= 40000
+
+/* GCC 4.1.[01] miscompiles __weak */
+#ifdef __KERNEL__
+# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
+#  error Your version of gcc miscompiles the __weak directive
+# endif
+#endif
+
+#define __used                  __attribute__((__used__))
+#define __compiler_offsetof(a, b)                                       \
+        __builtin_offsetof(a, b)
+
+#if GCC_VERSION >= 40100 && GCC_VERSION < 40600
+# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
+#endif
+
+#if GCC_VERSION >= 40300
+/* 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__ */
+#endif /* GCC_VERSION >= 40300 */
+
+#if GCC_VERSION >= 40500
+/*
+ * 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__))
+
+#endif /* GCC_VERSION >= 40500 */
+
+#if GCC_VERSION >= 40600
+/*
+ * Tell the optimizer that something else uses this function or variable.
+ */
+#define __visible       __attribute__((externally_visible))
+#endif
+
+/*
+ * 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
+#if GCC_VERSION >= 40400
+#define __HAVE_BUILTIN_BSWAP32__
+#define __HAVE_BUILTIN_BSWAP64__
+#endif
+#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600)
+#define __HAVE_BUILTIN_BSWAP16__
+#endif
+#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
+
+#if GCC_VERSION >= 50000
+#define KASAN_ABI_VERSION 4
+#elif GCC_VERSION >= 40902
+#define KASAN_ABI_VERSION 3
+#endif
+
+#endif  /* gcc version >= 40000 specific checks */
 
 #if !defined(__noclone)
 #define __noclone       /* not needed */
@@ -129,5 +248,3 @@
  * code
  */
 #define uninitialized_var(x) x = x
-
-#define __always_inline         inline __attribute__((always_inline))
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
deleted file mode 100644
index 7d89febe4d79..000000000000
--- a/include/linux/compiler-gcc3.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef __LINUX_COMPILER_H
-#error "Please don't include <linux/compiler-gcc3.h> directly, include <linux/compiler.h> instead."
-#endif
-
-#if GCC_VERSION < 30200
-# error Sorry, your compiler is too old - please upgrade it.
-#endif
-
-#if GCC_VERSION >= 30300
-# define __used                 __attribute__((__used__))
-#else
-# define __used                 __attribute__((__unused__))
-#endif
-
-#if GCC_VERSION >= 30400
-#define __must_check            __attribute__((warn_unused_result))
-#endif
-
-#ifdef CONFIG_GCOV_KERNEL
-# if GCC_VERSION < 30400
-#   error "GCOV profiling support for gcc versions below 3.4 not included"
-# endif /* __GNUC_MINOR__ */
-#endif /* CONFIG_GCOV_KERNEL */
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
deleted file mode 100644
index 769e19864632..000000000000
--- a/include/linux/compiler-gcc4.h
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef __LINUX_COMPILER_H
-#error "Please don't include <linux/compiler-gcc4.h> directly, include <linux/compiler.h> instead."
-#endif
-
-/* GCC 4.1.[01] miscompiles __weak */
-#ifdef __KERNEL__
-# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
-#  error Your version of gcc miscompiles the __weak directive
-# endif
-#endif
-
-#define __used                  __attribute__((__used__))
-#define __must_check            __attribute__((warn_unused_result))
-#define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
-
-#if GCC_VERSION >= 40100 && GCC_VERSION < 40600
-# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
-#endif
-
-#if GCC_VERSION >= 40300
-/* 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__ */
-#endif /* GCC_VERSION >= 40300 */
-
-#if GCC_VERSION >= 40500
-/*
- * 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__))
-
-#endif /* GCC_VERSION >= 40500 */
-
-#if GCC_VERSION >= 40600
-/*
- * Tell the optimizer that something else uses this function or variable.
- */
-#define __visible __attribute__((externally_visible))
-#endif
-
-/*
- * 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
-#if GCC_VERSION >= 40400
-#define __HAVE_BUILTIN_BSWAP32__
-#define __HAVE_BUILTIN_BSWAP64__
-#endif
-#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600)
-#define __HAVE_BUILTIN_BSWAP16__
-#endif
-#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
-
-#if GCC_VERSION >= 40902
-#define KASAN_ABI_VERSION 3
-#endif
diff --git a/include/linux/compiler-gcc5.h b/include/linux/compiler-gcc5.h
deleted file mode 100644
index efee493714eb..000000000000
--- a/include/linux/compiler-gcc5.h
+++ /dev/null
@@ -1,67 +0,0 @@
-#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 */
-
-#define KASAN_ABI_VERSION 4
diff --git a/include/linux/compiler-intel.h b/include/linux/compiler-intel.h
index 0c9a2f2c2802..d4c71132d07f 100644
--- a/include/linux/compiler-intel.h
+++ b/include/linux/compiler-intel.h
@@ -13,10 +13,12 @@
 /* Intel ECC compiler doesn't support gcc specific asm stmts.
  * It uses intrinsics to do the equivalent things.
  */
+#undef barrier
 #undef barrier_data
 #undef RELOC_HIDE
 #undef OPTIMIZER_HIDE_VAR
 
+#define barrier() __memory_barrier()
 #define barrier_data(ptr) barrier()
 
 #define RELOC_HIDE(ptr, off)                                    \
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 05be2352fef8..e08a6ae7c0a4 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -17,6 +17,7 @@
 # define __release(x)   __context__(x,-1)
 # define __cond_lock(x,c)       ((c) ? ({ __acquire(x); 1; }) : 0)
 # define __percpu       __attribute__((noderef, address_space(3)))
+# define __pmem         __attribute__((noderef, address_space(5)))
 #ifdef CONFIG_SPARSE_RCU_POINTER
 # define __rcu          __attribute__((noderef, address_space(4)))
 #else
@@ -42,6 +43,7 @@ extern void __chk_io_ptr(const volatile void __iomem *);
 # define __cond_lock(x,c) (c)
 # define __percpu
 # define __rcu
+# define __pmem
 #endif
 
 /* Indirect macros required for expanded argument pasting, eg. __LINE__. */
@@ -473,6 +475,21 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
         (volatile typeof(x) *)&(x); })
 #define ACCESS_ONCE(x) (*__ACCESS_ONCE(x))
 
+/**
+ * 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 = READ_ONCE(p); \
+        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
+        (_________p1); \
+})
+
 /* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */
 #ifdef CONFIG_KPROBES
 # define __kprobes      __attribute__((__section__(".kprobes.text")))
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index 34025df61829..63a36e89d0eb 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -64,14 +64,14 @@ struct config_item {
         struct dentry           *ci_dentry;
 };
 
-extern int config_item_set_name(struct config_item *, const char *, ...);
+extern __printf(2, 3)
+int config_item_set_name(struct config_item *, const char *, ...);
 
 static inline char *config_item_name(struct config_item * item)
 {
         return item->ci_name;
 }
 
-extern void config_item_init(struct config_item *);
 extern void config_item_init_type_name(struct config_item *item,
                                        const char *name,
                                        struct config_item_type *type);
diff --git a/include/linux/console.h b/include/linux/console.h
index 9f50fb413c11..bd194343c346 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -115,6 +115,7 @@ static inline int con_debug_leave(void)
 #define CON_BOOT        (8)
 #define CON_ANYTIME     (16) /* Safe to call when cpu is offline */
 #define CON_BRL         (32) /* Used for a braille device */
+#define CON_EXTENDED    (64) /* Use the extended output format a la /dev/kmsg */
 
 struct console {
         char    name[16];
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index e859c98d1767..e329ee2667e1 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -104,6 +104,7 @@ struct vc_data {
         unsigned int    vc_resize_user;         /* resize request from user */
         unsigned int    vc_bell_pitch;          /* Console bell pitch */
         unsigned int    vc_bell_duration;       /* Console bell duration */
+        unsigned short  vc_cur_blink_ms;        /* Cursor blink duration */
         struct vc_data **vc_display_fg;         /* [!] Ptr to var holding fg console for this display */
         struct uni_pagedir *vc_uni_pagedir;
         struct uni_pagedir **vc_uni_pagedir_loc; /* [!] Location of uni_pagedir variable for this console */
diff --git a/include/linux/cper.h b/include/linux/cper.h
index 76abba4b238e..dcacb1a72e26 100644
--- a/include/linux/cper.h
+++ b/include/linux/cper.h
@@ -340,7 +340,27 @@ struct cper_ia_proc_ctx {
         __u64   mm_reg_addr;
 };
 
-/* Memory Error Section */
+/* Old Memory Error Section UEFI 2.1, 2.2 */
+struct cper_sec_mem_err_old {
+        __u64   validation_bits;
+        __u64   error_status;
+        __u64   physical_addr;
+        __u64   physical_addr_mask;
+        __u16   node;
+        __u16   card;
+        __u16   module;
+        __u16   bank;
+        __u16   device;
+        __u16   row;
+        __u16   column;
+        __u16   bit_pos;
+        __u64   requestor_id;
+        __u64   responder_id;
+        __u64   target_id;
+        __u8    error_type;
+};
+
+/* Memory Error Section UEFI >= 2.3 */
 struct cper_sec_mem_err {
         __u64   validation_bits;
         __u64   error_status;
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index c0fb6b1b4712..23c30bdcca86 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -40,9 +40,10 @@ 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, ...);
+extern __printf(4, 5)
+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);
diff --git a/include/linux/cpu_cooling.h b/include/linux/cpu_cooling.h
index bd955270d5aa..c156f5082758 100644
--- a/include/linux/cpu_cooling.h
+++ b/include/linux/cpu_cooling.h
@@ -28,6 +28,9 @@
 #include <linux/thermal.h>
 #include <linux/cpumask.h>
 
+typedef int (*get_static_t)(cpumask_t *cpumask, int interval,
+                            unsigned long voltage, u32 *power);
+
 #ifdef CONFIG_CPU_THERMAL
 /**
  * cpufreq_cooling_register - function to create cpufreq cooling device.
@@ -36,6 +39,10 @@
 struct thermal_cooling_device *
 cpufreq_cooling_register(const struct cpumask *clip_cpus);
 
+struct thermal_cooling_device *
+cpufreq_power_cooling_register(const struct cpumask *clip_cpus,
+                               u32 capacitance, get_static_t plat_static_func);
+
 /**
  * of_cpufreq_cooling_register - create cpufreq cooling device based on DT.
  * @np: a valid struct device_node to the cooling device device tree node.
@@ -45,6 +52,12 @@ cpufreq_cooling_register(const struct cpumask *clip_cpus);
 struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus);
+
+struct thermal_cooling_device *
+of_cpufreq_power_cooling_register(struct device_node *np,
+                                  const struct cpumask *clip_cpus,
+                                  u32 capacitance,
+                                  get_static_t plat_static_func);
 #else
 static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
@@ -52,6 +65,15 @@ of_cpufreq_cooling_register(struct device_node *np,
 {
         return ERR_PTR(-ENOSYS);
 }
+
+static inline struct thermal_cooling_device *
+of_cpufreq_power_cooling_register(struct device_node *np,
+                                  const struct cpumask *clip_cpus,
+                                  u32 capacitance,
+                                  get_static_t plat_static_func)
+{
+        return NULL;
+}
 #endif
 
 /**
@@ -68,11 +90,28 @@ cpufreq_cooling_register(const struct cpumask *clip_cpus)
         return ERR_PTR(-ENOSYS);
 }
 static inline struct thermal_cooling_device *
+cpufreq_power_cooling_register(const struct cpumask *clip_cpus,
+                               u32 capacitance, get_static_t plat_static_func)
+{
+        return NULL;
+}
+
+static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus)
 {
         return ERR_PTR(-ENOSYS);
 }
+
+static inline struct thermal_cooling_device *
+of_cpufreq_power_cooling_register(struct device_node *np,
+                                  const struct cpumask *clip_cpus,
+                                  u32 capacitance,
+                                  get_static_t plat_static_func)
+{
+        return NULL;
+}
+
 static inline
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
 {
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 2ee4888c1f47..bde1e567b3a9 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -62,10 +62,13 @@ struct cpufreq_policy {
         /* CPUs sharing clock, require sw coordination */
         cpumask_var_t           cpus;   /* Online CPUs only */
         cpumask_var_t           related_cpus; /* Online + Offline CPUs */
+        cpumask_var_t           real_cpus; /* Related and present */
 
         unsigned int            shared_type; /* ACPI: ANY or ALL affected CPUs
                                                 should set cpufreq */
-        unsigned int            cpu;    /* cpu nr of CPU managing this policy */
+        unsigned int            cpu;    /* cpu managing this policy, must be online */
+        unsigned int            kobj_cpu; /* cpu managing sysfs files, can be offline */
+
         struct clk              *clk;
         struct cpufreq_cpuinfo  cpuinfo;/* see above */
 
@@ -80,6 +83,7 @@ struct cpufreq_policy {
         struct cpufreq_governor *governor; /* see below */
         void                    *governor_data;
         bool                    governor_enabled; /* governor start/stop flag */
+        char                    last_governor[CPUFREQ_NAME_LEN]; /* last governor used */
 
         struct work_struct      update; /* if update_policy() needs to be
                                          * called, but you're in IRQ context */
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 9c5e89254796..d075d34279df 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -151,10 +151,6 @@ extern void cpuidle_resume(void);
 extern int cpuidle_enable_device(struct cpuidle_device *dev);
 extern void cpuidle_disable_device(struct cpuidle_device *dev);
 extern int cpuidle_play_dead(void);
-extern int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
-                                      struct cpuidle_device *dev);
-extern int cpuidle_enter_freeze(struct cpuidle_driver *drv,
-                                struct cpuidle_device *dev);
 
 extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
 #else
@@ -190,16 +186,28 @@ static inline int cpuidle_enable_device(struct cpuidle_device *dev)
 {return -ENODEV; }
 static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
 static inline int cpuidle_play_dead(void) {return -ENODEV; }
+static inline struct cpuidle_driver *cpuidle_get_cpu_driver(
+        struct cpuidle_device *dev) {return NULL; }
+#endif
+
+#if defined(CONFIG_CPU_IDLE) && defined(CONFIG_SUSPEND)
+extern int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
+                                      struct cpuidle_device *dev);
+extern int cpuidle_enter_freeze(struct cpuidle_driver *drv,
+                                struct cpuidle_device *dev);
+#else
 static inline int cpuidle_find_deepest_state(struct cpuidle_driver *drv,
                                              struct cpuidle_device *dev)
 {return -ENODEV; }
 static inline int cpuidle_enter_freeze(struct cpuidle_driver *drv,
                                        struct cpuidle_device *dev)
 {return -ENODEV; }
-static inline struct cpuidle_driver *cpuidle_get_cpu_driver(
-        struct cpuidle_device *dev) {return NULL; }
 #endif
 
+/* kernel/sched/idle.c */
+extern void sched_idle_set_state(struct cpuidle_state *idle_state);
+extern void default_idle_call(void);
+
 #ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
 void cpuidle_coupled_parallel_barrier(struct cpuidle_device *dev, atomic_t *a);
 #else
diff --git a/include/linux/crc-itu-t.h b/include/linux/crc-itu-t.h
index 84920f3cc83e..a9953c762eee 100644
--- a/include/linux/crc-itu-t.h
+++ b/include/linux/crc-itu-t.h
@@ -3,7 +3,7 @@
  *
  * Implements the standard CRC ITU-T V.41:
  *   Width 16
- *   Poly  0x0x1021 (x^16 + x^12 + x^15 + 1)
+ *   Poly  0x1021 (x^16 + x^12 + x^15 + 1)
  *   Init  0
  *
  * This source code is licensed under the GNU General Public License,
diff --git a/include/linux/crc-t10dif.h b/include/linux/crc-t10dif.h
index cf53d0773ce3..d81961e9e37d 100644
--- a/include/linux/crc-t10dif.h
+++ b/include/linux/crc-t10dif.h
@@ -9,5 +9,6 @@
 extern __u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer,
                                 size_t len);
 extern __u16 crc_t10dif(unsigned char const *, size_t);
+extern __u16 crc_t10dif_update(__u16 crc, unsigned char const *, size_t);
 
 #endif
diff --git a/include/linux/crush/crush.h b/include/linux/crush/crush.h
index 48a1a7d100f1..48b49305716b 100644
--- a/include/linux/crush/crush.h
+++ b/include/linux/crush/crush.h
@@ -1,7 +1,11 @@
 #ifndef CEPH_CRUSH_CRUSH_H
 #define CEPH_CRUSH_CRUSH_H
 
-#include <linux/types.h>
+#ifdef __KERNEL__
+# include <linux/types.h>
+#else
+# include "crush_compat.h"
+#endif
 
 /*
  * CRUSH is a pseudo-random data distribution algorithm that
@@ -20,7 +24,11 @@
 #define CRUSH_MAGIC 0x00010000ul   /* for detecting algorithm revisions */
 
 #define CRUSH_MAX_DEPTH 10  /* max crush hierarchy depth */
+#define CRUSH_MAX_RULESET (1<<8)  /* max crush ruleset number */
+#define CRUSH_MAX_RULES CRUSH_MAX_RULESET  /* should be the same as max rulesets */
 
+#define CRUSH_MAX_DEVICE_WEIGHT (100u * 0x10000u)
+#define CRUSH_MAX_BUCKET_WEIGHT (65535u * 0x10000u)
 
 #define CRUSH_ITEM_UNDEF  0x7ffffffe  /* undefined result (internal use only) */
 #define CRUSH_ITEM_NONE   0x7fffffff  /* no result */
@@ -108,6 +116,15 @@ enum {
 };
 extern const char *crush_bucket_alg_name(int alg);
 
+/*
+ * although tree was a legacy algorithm, it has been buggy, so
+ * exclude it.
+ */
+#define CRUSH_LEGACY_ALLOWED_BUCKET_ALGS (      \
+                (1 << CRUSH_BUCKET_UNIFORM) |   \
+                (1 << CRUSH_BUCKET_LIST) |      \
+                (1 << CRUSH_BUCKET_STRAW))
+
 struct crush_bucket {
         __s32 id;        /* this'll be negative */
         __u16 type;      /* non-zero; type=0 is reserved for devices */
@@ -174,7 +191,7 @@ struct crush_map {
         /* choose local attempts using a fallback permutation before
          * re-descent */
         __u32 choose_local_fallback_tries;
-        /* choose attempts before giving up */ 
+        /* choose attempts before giving up */
         __u32 choose_total_tries;
         /* attempt chooseleaf inner descent once for firstn mode; on
          * reject retry outer descent.  Note that this does *not*
@@ -187,6 +204,25 @@ struct crush_map {
          * that want to limit reshuffling, a value of 3 or 4 will make the
          * mappings line up a bit better with previous mappings. */
         __u8 chooseleaf_vary_r;
+
+#ifndef __KERNEL__
+        /*
+         * version 0 (original) of straw_calc has various flaws.  version 1
+         * fixes a few of them.
+         */
+        __u8 straw_calc_version;
+
+        /*
+         * allowed bucket algs is a bitmask, here the bit positions
+         * are CRUSH_BUCKET_*.  note that these are *bits* and
+         * CRUSH_BUCKET_* values are not, so we need to or together (1
+         * << CRUSH_BUCKET_WHATEVER).  The 0th bit is not used to
+         * minimize confusion (bucket type values start at 1).
+         */
+        __u32 allowed_bucket_algs;
+
+        __u32 *choose_tries;
+#endif
 };
 
 
diff --git a/include/linux/crush/hash.h b/include/linux/crush/hash.h
index 91e884230d5d..d1d90258242e 100644
--- a/include/linux/crush/hash.h
+++ b/include/linux/crush/hash.h
@@ -1,6 +1,12 @@
 #ifndef CEPH_CRUSH_HASH_H
 #define CEPH_CRUSH_HASH_H
 
+#ifdef __KERNEL__
+# include <linux/types.h>
+#else
+# include "crush_compat.h"
+#endif
+
 #define CRUSH_HASH_RJENKINS1   0
 
 #define CRUSH_HASH_DEFAULT CRUSH_HASH_RJENKINS1
diff --git a/include/linux/crush/mapper.h b/include/linux/crush/mapper.h
index eab367446eea..5dfd5b1125d2 100644
--- a/include/linux/crush/mapper.h
+++ b/include/linux/crush/mapper.h
@@ -8,7 +8,7 @@
  * LGPL2
  */
 
-#include <linux/crush/crush.h>
+#include "crush.h"
 
 extern int crush_find_rule(const struct crush_map *map, int ruleset, int type, int size);
 extern int crush_do_rule(const struct crush_map *map,
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index df334cbacc6d..d67ae119cf4e 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -160,6 +160,7 @@ struct dentry_operations {
         char *(*d_dname)(struct dentry *, char *, int);
         struct vfsmount *(*d_automount)(struct path *);
         int (*d_manage)(struct dentry *, bool);
+        struct inode *(*d_select_inode)(struct dentry *, unsigned);
 } ____cacheline_aligned;
 
 /*
@@ -225,6 +226,7 @@ struct dentry_operations {
 
 #define DCACHE_MAY_FREE                 0x00800000
 #define DCACHE_FALLTHRU                 0x01000000 /* Fall through to lower layer */
+#define DCACHE_OP_SELECT_INODE          0x02000000 /* Unioned entry: dcache op selects inode */
 
 extern seqlock_t rename_lock;
 
@@ -325,7 +327,8 @@ static inline unsigned d_count(const struct dentry *dentry)
 /*
  * helper function for dentry_operations.d_dname() members
  */
-extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
+extern __printf(4, 5)
+char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
 extern char *simple_dname(struct dentry *, char *, int);
 
 extern char *__d_path(const struct path *, const struct path *, char *, int);
@@ -505,6 +508,11 @@ static inline bool d_really_is_positive(const struct dentry *dentry)
         return dentry->d_inode != NULL;
 }
 
+static inline int simple_positive(struct dentry *dentry)
+{
+        return d_really_is_positive(dentry) && !d_unhashed(dentry);
+}
+
 extern void d_set_fallthru(struct dentry *dentry);
 
 static inline bool d_is_fallthru(const struct dentry *dentry)
diff --git a/include/linux/device.h b/include/linux/device.h
index 6558af90c8fe..a2b4ea70a946 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -196,12 +196,41 @@ extern struct kset *bus_get_kset(struct bus_type *bus);
 extern struct klist *bus_get_device_klist(struct bus_type *bus);
 
 /**
+ * enum probe_type - device driver probe type to try
+ *      Device drivers may opt in for special handling of their
+ *      respective probe routines. This tells the core what to
+ *      expect and prefer.
+ *
+ * @PROBE_DEFAULT_STRATEGY: Used by drivers that work equally well
+ *      whether probed synchronously or asynchronously.
+ * @PROBE_PREFER_ASYNCHRONOUS: Drivers for "slow" devices which
+ *      probing order is not essential for booting the system may
+ *      opt into executing their probes asynchronously.
+ * @PROBE_FORCE_SYNCHRONOUS: Use this to annotate drivers that need
+ *      their probe routines to run synchronously with driver and
+ *      device registration (with the exception of -EPROBE_DEFER
+ *      handling - re-probing always ends up being done asynchronously).
+ *
+ * Note that the end goal is to switch the kernel to use asynchronous
+ * probing by default, so annotating drivers with
+ * %PROBE_PREFER_ASYNCHRONOUS is a temporary measure that allows us
+ * to speed up boot process while we are validating the rest of the
+ * drivers.
+ */
+enum probe_type {
+        PROBE_DEFAULT_STRATEGY,
+        PROBE_PREFER_ASYNCHRONOUS,
+        PROBE_FORCE_SYNCHRONOUS,
+};
+
+/**
  * struct device_driver - The basic device driver structure
  * @name:       Name of the device driver.
  * @bus:        The bus which the device of this driver belongs to.
  * @owner:      The module owner.
  * @mod_name:   Used for built-in modules.
  * @suppress_bind_attrs: Disables bind/unbind via sysfs.
+ * @probe_type: Type of the probe (synchronous or asynchronous) to use.
  * @of_match_table: The open firmware table.
  * @acpi_match_table: The ACPI match table.
  * @probe:      Called to query the existence of a specific device,
@@ -235,6 +264,7 @@ struct device_driver {
         const char              *mod_name;      /* used for built-in modules */
 
         bool suppress_bind_attrs;       /* disables bind/unbind via sysfs */
+        enum probe_type probe_type;
 
         const struct of_device_id       *of_match_table;
         const struct acpi_device_id     *acpi_match_table;
@@ -607,8 +637,9 @@ extern int devres_release_group(struct device *dev, void *id);
 
 /* managed devm_k.alloc/kfree for device drivers */
 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 __printf(3, 0)
+char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
+                      va_list ap);
 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)
@@ -975,17 +1006,16 @@ extern int __must_check device_bind_driver(struct device *dev);
 extern void device_release_driver(struct device *dev);
 extern int  __must_check device_attach(struct device *dev);
 extern int __must_check driver_attach(struct device_driver *drv);
+extern void device_initial_probe(struct device *dev);
 extern int __must_check device_reprobe(struct device *dev);
 
 /*
  * Easy functions for dynamically creating devices on the fly
  */
-extern struct device *device_create_vargs(struct class *cls,
-                                          struct device *parent,
-                                          dev_t devt,
-                                          void *drvdata,
-                                          const char *fmt,
-                                          va_list vargs);
+extern __printf(5, 0)
+struct device *device_create_vargs(struct class *cls, struct device *parent,
+                                   dev_t devt, void *drvdata,
+                                   const char *fmt, va_list vargs);
 extern __printf(5, 6)
 struct device *device_create(struct class *cls, struct device *parent,
                              dev_t devt, void *drvdata,
@@ -1269,4 +1299,26 @@ static void __exit __driver##_exit(void) \
 } \
 module_exit(__driver##_exit);
 
+/**
+ * builtin_driver() - Helper macro for drivers that don't do anything
+ * special in init and have no exit. This eliminates some boilerplate.
+ * Each driver may only use this macro once, and calling it replaces
+ * device_initcall (or in some cases, the legacy __initcall).  This is
+ * meant to be a direct parallel of module_driver() above but without
+ * the __exit stuff that is not used for builtin cases.
+ *
+ * @__driver: driver name
+ * @__register: register function for this driver type
+ * @...: Additional arguments to be passed to __register
+ *
+ * Use this macro to construct bus specific macros for registering
+ * drivers, and do not use it on its own.
+ */
+#define builtin_driver(__driver, __register, ...) \
+static int __init __driver##_init(void) \
+{ \
+        return __register(&(__driver) , ##__VA_ARGS__); \
+} \
+device_initcall(__driver##_init);
+
 #endif /* _DEVICE_H_ */
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index 2f0b431b73e0..f98bd7068d55 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -115,6 +115,8 @@ struct dma_buf_ops {
  * @attachments: list of dma_buf_attachment that denotes all devices attached.
  * @ops: dma_buf_ops associated with this buffer object.
  * @exp_name: name of the exporter; useful for debugging.
+ * @owner: pointer to exporter module; used for refcounting when exporter is a
+ *         kernel module.
  * @list_node: node for dma_buf accounting and debugging.
  * @priv: exporter specific private data for this buffer object.
  * @resv: reservation object linked to this dma-buf
@@ -129,6 +131,7 @@ struct dma_buf {
         unsigned vmapping_counter;
         void *vmap_ptr;
         const char *exp_name;
+        struct module *owner;
         struct list_head list_node;
         void *priv;
         struct reservation_object *resv;
@@ -164,7 +167,8 @@ struct dma_buf_attachment {
 
 /**
  * struct dma_buf_export_info - holds information needed to export a dma_buf
- * @exp_name:   name of the exporting module - useful for debugging.
+ * @exp_name:   name of the exporter - useful for debugging.
+ * @owner:      pointer to exporter module - used for refcounting kernel module
  * @ops:        Attach allocator-defined dma buf ops to the new buffer
  * @size:       Size of the buffer
  * @flags:      mode flags for the file
@@ -176,6 +180,7 @@ struct dma_buf_attachment {
  */
 struct dma_buf_export_info {
         const char *exp_name;
+        struct module *owner;
         const struct dma_buf_ops *ops;
         size_t size;
         int flags;
@@ -187,7 +192,8 @@ struct dma_buf_export_info {
  * helper macro for exporters; zeros and fills in most common values
  */
 #define DEFINE_DMA_BUF_EXPORT_INFO(a)   \
-        struct dma_buf_export_info a = { .exp_name = KBUILD_MODNAME }
+        struct dma_buf_export_info a = { .exp_name = KBUILD_MODNAME, \
+                                         .owner = THIS_MODULE }
 
 /**
  * get_dma_buf - convenience wrapper for get_file.
diff --git a/include/linux/dma/pxa-dma.h b/include/linux/dma/pxa-dma.h
new file mode 100644
index 000000000000..3edc99294bf6
--- /dev/null
+++ b/include/linux/dma/pxa-dma.h
@@ -0,0 +1,27 @@
+#ifndef _PXA_DMA_H_
+#define _PXA_DMA_H_
+
+enum pxad_chan_prio {
+        PXAD_PRIO_HIGHEST = 0,
+        PXAD_PRIO_NORMAL,
+        PXAD_PRIO_LOW,
+        PXAD_PRIO_LOWEST,
+};
+
+struct pxad_param {
+        unsigned int drcmr;
+        enum pxad_chan_prio prio;
+};
+
+struct dma_chan;
+
+#ifdef CONFIG_PXA_DMA
+bool pxad_filter_fn(struct dma_chan *chan, void *param);
+#else
+static inline bool pxad_filter_fn(struct dma_chan *chan, void *param)
+{
+        return false;
+}
+#endif
+
+#endif /* _PXA_DMA_H_ */
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index ad419757241f..e2f5eb419976 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -65,6 +65,7 @@ enum dma_transaction_type {
         DMA_PQ,
         DMA_XOR_VAL,
         DMA_PQ_VAL,
+        DMA_MEMSET,
         DMA_INTERRUPT,
         DMA_SG,
         DMA_PRIVATE,
@@ -122,10 +123,18 @@ enum dma_transfer_direction {
  *       chunk and before first src/dst address for next chunk.
  *       Ignored for dst(assumed 0), if dst_inc is true and dst_sgl is false.
  *       Ignored for src(assumed 0), if src_inc is true and src_sgl is false.
+ * @dst_icg: Number of bytes to jump after last dst address of this
+ *       chunk and before the first dst address for next chunk.
+ *       Ignored if dst_inc is true and dst_sgl is false.
+ * @src_icg: Number of bytes to jump after last src address of this
+ *       chunk and before the first src address for next chunk.
+ *       Ignored if src_inc is true and src_sgl is false.
  */
 struct data_chunk {
         size_t size;
         size_t icg;
+        size_t dst_icg;
+        size_t src_icg;
 };
 
 /**
@@ -222,6 +231,16 @@ struct dma_chan_percpu {
 };
 
 /**
+ * struct dma_router - DMA router structure
+ * @dev: pointer to the DMA router device
+ * @route_free: function to be called when the route can be disconnected
+ */
+struct dma_router {
+        struct device *dev;
+        void (*route_free)(struct device *dev, void *route_data);
+};
+
+/**
  * struct dma_chan - devices supply DMA channels, clients use them
  * @device: ptr to the dma device who supplies this channel, always !%NULL
  * @cookie: last cookie value returned to client
@@ -232,6 +251,8 @@ struct dma_chan_percpu {
  * @local: per-cpu pointer to a struct dma_chan_percpu
  * @client_count: how many clients are using this channel
  * @table_count: number of appearances in the mem-to-mem allocation table
+ * @router: pointer to the DMA router structure
+ * @route_data: channel specific data for the router
  * @private: private data for certain client-channel associations
  */
 struct dma_chan {
@@ -247,6 +268,11 @@ struct dma_chan {
         struct dma_chan_percpu __percpu *local;
         int client_count;
         int table_count;
+
+        /* DMA router */
+        struct dma_router *router;
+        void *route_data;
+
         void *private;
 };
 
@@ -570,6 +596,7 @@ struct dma_tx_state {
  * @copy_align: alignment shift for memcpy operations
  * @xor_align: alignment shift for xor operations
  * @pq_align: alignment shift for pq operations
+ * @fill_align: alignment shift for memset operations
  * @dev_id: unique device ID
  * @dev: struct device reference for dma mapping api
  * @src_addr_widths: bit mask of src addr widths the device supports
@@ -588,6 +615,7 @@ struct dma_tx_state {
  * @device_prep_dma_xor_val: prepares a xor validation operation
  * @device_prep_dma_pq: prepares a pq operation
  * @device_prep_dma_pq_val: prepares a pqzero_sum operation
+ * @device_prep_dma_memset: prepares a memset operation
  * @device_prep_dma_interrupt: prepares an end of chain interrupt operation
  * @device_prep_slave_sg: prepares a slave dma operation
  * @device_prep_dma_cyclic: prepare a cyclic dma operation suitable for audio.
@@ -620,6 +648,7 @@ struct dma_device {
         u8 copy_align;
         u8 xor_align;
         u8 pq_align;
+        u8 fill_align;
         #define DMA_HAS_PQ_CONTINUE (1 << 15)
 
         int dev_id;
@@ -650,6 +679,9 @@ struct dma_device {
                 struct dma_chan *chan, dma_addr_t *pq, dma_addr_t *src,
                 unsigned int src_cnt, const unsigned char *scf, size_t len,
                 enum sum_check_flags *pqres, unsigned long flags);
+        struct dma_async_tx_descriptor *(*device_prep_dma_memset)(
+                struct dma_chan *chan, dma_addr_t dest, int value, size_t len,
+                unsigned long flags);
         struct dma_async_tx_descriptor *(*device_prep_dma_interrupt)(
                 struct dma_chan *chan, unsigned long flags);
         struct dma_async_tx_descriptor *(*device_prep_dma_sg)(
@@ -745,6 +777,17 @@ 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_memset(
+                struct dma_chan *chan, dma_addr_t dest, int value, size_t len,
+                unsigned long flags)
+{
+        if (!chan || !chan->device)
+                return NULL;
+
+        return chan->device->device_prep_dma_memset(chan, dest, value,
+                                                    len, flags);
+}
+
 static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_sg(
                 struct dma_chan *chan,
                 struct scatterlist *dst_sg, unsigned int dst_nents,
@@ -820,6 +863,12 @@ static inline bool is_dma_pq_aligned(struct dma_device *dev, size_t off1,
         return dmaengine_check_align(dev->pq_align, off1, off2, len);
 }
 
+static inline bool is_dma_fill_aligned(struct dma_device *dev, size_t off1,
+                                       size_t off2, size_t len)
+{
+        return dmaengine_check_align(dev->fill_align, off1, off2, len);
+}
+
 static inline void
 dma_set_maxpq(struct dma_device *dma, int maxpq, int has_pq_continue)
 {
@@ -874,6 +923,33 @@ static inline int dma_maxpq(struct dma_device *dma, enum dma_ctrl_flags flags)
         BUG();
 }
 
+static inline size_t dmaengine_get_icg(bool inc, bool sgl, size_t icg,
+                                      size_t dir_icg)
+{
+        if (inc) {
+                if (dir_icg)
+                        return dir_icg;
+                else if (sgl)
+                        return icg;
+        }
+
+        return 0;
+}
+
+static inline size_t dmaengine_get_dst_icg(struct dma_interleaved_template *xt,
+                                           struct data_chunk *chunk)
+{
+        return dmaengine_get_icg(xt->dst_inc, xt->dst_sgl,
+                                 chunk->icg, chunk->dst_icg);
+}
+
+static inline size_t dmaengine_get_src_icg(struct dma_interleaved_template *xt,
+                                           struct data_chunk *chunk)
+{
+        return dmaengine_get_icg(xt->src_inc, xt->src_sgl,
+                                 chunk->icg, chunk->src_icg);
+}
+
 /* --- public DMA engine API --- */
 
 #ifdef CONFIG_DMA_ENGINE
diff --git a/include/linux/dmapool.h b/include/linux/dmapool.h
index 52456aa566a0..e1043f79122f 100644
--- a/include/linux/dmapool.h
+++ b/include/linux/dmapool.h
@@ -11,8 +11,8 @@
 #ifndef LINUX_DMAPOOL_H
 #define LINUX_DMAPOOL_H
 
+#include <linux/scatterlist.h>
 #include <asm/io.h>
-#include <asm/scatterlist.h>
 
 struct device;
 
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index f820f0a336c9..5055ac34142d 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -2,6 +2,7 @@
 #define __DMI_H__
 
 #include <linux/list.h>
+#include <linux/kobject.h>
 #include <linux/mod_devicetable.h>
 
 /* enum dmi_field is in mod_devicetable.h */
@@ -74,7 +75,7 @@ struct dmi_header {
         u8 type;
         u8 length;
         u16 handle;
-};
+} __packed;
 
 struct dmi_device {
         struct list_head list;
@@ -93,6 +94,7 @@ struct dmi_dev_onboard {
         int devfn;
 };
 
+extern struct kobject *dmi_kobj;
 extern int dmi_check_system(const struct dmi_system_id *list);
 const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list);
 extern const char * dmi_get_system_info(int field);
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 2092965afca3..85ef051ac6fb 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -85,7 +85,8 @@ typedef	struct {
 #define EFI_MEMORY_MAPPED_IO            11
 #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
 #define EFI_PAL_CODE                    13
-#define EFI_MAX_MEMORY_TYPE             14
+#define EFI_PERSISTENT_MEMORY           14
+#define EFI_MAX_MEMORY_TYPE             15
 
 /* Attribute values: */
 #define EFI_MEMORY_UC           ((u64)0x0000000000000001ULL)    /* uncached */
@@ -96,6 +97,8 @@ typedef	struct {
 #define EFI_MEMORY_WP           ((u64)0x0000000000001000ULL)    /* write-protect */
 #define EFI_MEMORY_RP           ((u64)0x0000000000002000ULL)    /* read-protect */
 #define EFI_MEMORY_XP           ((u64)0x0000000000004000ULL)    /* execute-protect */
+#define EFI_MEMORY_MORE_RELIABLE \
+                                ((u64)0x0000000000010000ULL)    /* higher reliability */
 #define EFI_MEMORY_RUNTIME      ((u64)0x8000000000000000ULL)    /* range requires runtime mapping */
 #define EFI_MEMORY_DESCRIPTOR_VERSION   1
 
@@ -868,6 +871,7 @@ extern void efi_enter_virtual_mode (void);	/* switch EFI to virtual mode, if pos
 extern void efi_late_init(void);
 extern void efi_free_boot_services(void);
 extern efi_status_t efi_query_variable_store(u32 attributes, unsigned long size);
+extern void efi_find_mirror(void);
 #else
 static inline void efi_late_init(void) {}
 static inline void efi_free_boot_services(void) {}
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 45a91474487d..638b324f0291 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -39,6 +39,7 @@ typedef void (elevator_deactivate_req_fn) (struct request_queue *, struct reques
 typedef int (elevator_init_fn) (struct request_queue *,
                                 struct elevator_type *e);
 typedef void (elevator_exit_fn) (struct elevator_queue *);
+typedef void (elevator_registered_fn) (struct request_queue *);
 
 struct elevator_ops
 {
@@ -68,6 +69,7 @@ struct elevator_ops
 
         elevator_init_fn *elevator_init_fn;
         elevator_exit_fn *elevator_exit_fn;
+        elevator_registered_fn *elevator_registered_fn;
 };
 
 #define ELV_NAME_MAX    (16)
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 606563ef8a72..9012f8775208 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -110,7 +110,29 @@ static inline bool is_zero_ether_addr(const u8 *addr)
  */
 static inline bool is_multicast_ether_addr(const u8 *addr)
 {
-        return 0x01 & addr[0];
+#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
+        u32 a = *(const u32 *)addr;
+#else
+        u16 a = *(const u16 *)addr;
+#endif
+#ifdef __BIG_ENDIAN
+        return 0x01 & (a >> ((sizeof(a) * 8) - 8));
+#else
+        return 0x01 & a;
+#endif
+}
+
+static inline bool is_multicast_ether_addr_64bits(const u8 addr[6+2])
+{
+#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
+#ifdef __BIG_ENDIAN
+        return 0x01 & ((*(const u64 *)addr) >> 56);
+#else
+        return 0x01 & (*(const u64 *)addr);
+#endif
+#else
+        return is_multicast_ether_addr(addr);
+#endif
 }
 
 /**
@@ -169,6 +191,24 @@ static inline bool is_valid_ether_addr(const u8 *addr)
 }
 
 /**
+ * eth_proto_is_802_3 - Determine if a given Ethertype/length is a protocol
+ * @proto: Ethertype/length value to be tested
+ *
+ * Check that the value from the Ethertype/length field is a valid Ethertype.
+ *
+ * Return true if the valid is an 802.3 supported Ethertype.
+ */
+static inline bool eth_proto_is_802_3(__be16 proto)
+{
+#ifndef __BIG_ENDIAN
+        /* if CPU is little endian mask off bits representing LSB */
+        proto &= htons(0xFF00);
+#endif
+        /* cast both to u16 and compare since LSB can be ignored */
+        return (__force u16)proto >= (__force u16)htons(ETH_P_802_3_MIN);
+}
+
+/**
  * eth_random_addr - Generate software assigned random Ethernet address
  * @addr: Pointer to a six-byte array containing the Ethernet address
  *
diff --git a/include/linux/extcon.h b/include/linux/extcon.h
index 36f49c405dfb..b16d929fa75f 100644
--- a/include/linux/extcon.h
+++ b/include/linux/extcon.h
@@ -1,6 +1,9 @@
 /*
  *  External connector (extcon) class driver
  *
+ * Copyright (C) 2015 Samsung Electronics
+ * Author: Chanwoo Choi <cw00.choi@samsung.com>
+ *
  * Copyright (C) 2012 Samsung Electronics
  * Author: Donggeun Kim <dg77.kim@samsung.com>
  * Author: MyungJoo Ham <myungjoo.ham@samsung.com>
@@ -27,50 +30,35 @@
 #include <linux/notifier.h>
 #include <linux/sysfs.h>
 
-#define SUPPORTED_CABLE_MAX     32
-#define CABLE_NAME_MAX          30
-
 /*
- * The standard cable name is to help support general notifier
- * and notifiee device drivers to share the common names.
- * Please use standard cable names unless your notifier device has
- * a very unique and abnormal cable or
- * the cable type is supposed to be used with only one unique
- * pair of notifier/notifiee devices.
- *
- * Please add any other "standard" cables used with extcon dev.
- *
- * You may add a dot and number to specify version or specification
- * of the specific cable if it is required. (e.g., "Fast-charger.18"
- * and "Fast-charger.10" for 1.8A and 1.0A chargers)
- * However, the notifiee and notifier should be able to handle such
- * string and if the notifiee can negotiate the protocol or identify,
- * you don't need such convention. This convention is helpful when
- * notifier can distinguish but notifiee cannot.
+ * Define the unique id of supported external connectors
  */
-enum extcon_cable_name {
-        EXTCON_USB = 0,
-        EXTCON_USB_HOST,
-        EXTCON_TA,                      /* Travel Adaptor */
-        EXTCON_FAST_CHARGER,
-        EXTCON_SLOW_CHARGER,
-        EXTCON_CHARGE_DOWNSTREAM,       /* Charging an external device */
-        EXTCON_HDMI,
-        EXTCON_MHL,
-        EXTCON_DVI,
-        EXTCON_VGA,
-        EXTCON_DOCK,
-        EXTCON_LINE_IN,
-        EXTCON_LINE_OUT,
-        EXTCON_MIC_IN,
-        EXTCON_HEADPHONE_OUT,
-        EXTCON_SPDIF_IN,
-        EXTCON_SPDIF_OUT,
-        EXTCON_VIDEO_IN,
-        EXTCON_VIDEO_OUT,
-        EXTCON_MECHANICAL,
-};
-extern const char extcon_cable_name[][CABLE_NAME_MAX + 1];
+#define EXTCON_NONE                     0
+
+#define EXTCON_USB                      1       /* USB connector */
+#define EXTCON_USB_HOST                 2
+
+#define EXTCON_TA                       3       /* Charger connector */
+#define EXTCON_FAST_CHARGER             4
+#define EXTCON_SLOW_CHARGER             5
+#define EXTCON_CHARGE_DOWNSTREAM        6
+
+#define EXTCON_LINE_IN                  7       /* Audio/Video connector */
+#define EXTCON_LINE_OUT                 8
+#define EXTCON_MICROPHONE               9
+#define EXTCON_HEADPHONE                10
+#define EXTCON_HDMI                     11
+#define EXTCON_MHL                      12
+#define EXTCON_DVI                      13
+#define EXTCON_VGA                      14
+#define EXTCON_SPDIF_IN                 15
+#define EXTCON_SPDIF_OUT                16
+#define EXTCON_VIDEO_IN                 17
+#define EXTCON_VIDEO_OUT                18
+
+#define EXTCON_DOCK                     19      /* Misc connector */
+#define EXTCON_JIG                      20
+#define EXTCON_MECHANICAL               21
 
 struct extcon_cable;
 
@@ -78,7 +66,7 @@ struct extcon_cable;
  * struct extcon_dev - An extcon device represents one external connector.
  * @name:               The name of this extcon device. Parent device name is
  *                      used if NULL.
- * @supported_cable:    Array of supported cable names ending with NULL.
+ * @supported_cable:    Array of supported cable names ending with EXTCON_NONE.
  *                      If supported_cable is NULL, cable name related APIs
  *                      are disabled.
  * @mutually_exclusive: Array of mutually exclusive set of cables that cannot
@@ -89,16 +77,14 @@ struct extcon_cable;
  *                      be attached simulataneously. {0x7, 0} is equivalent to
  *                      {0x3, 0x6, 0x5, 0}. If it is {0xFFFFFFFF, 0}, there
  *                      can be no simultaneous connections.
- * @print_name:         An optional callback to override the method to print the
- *                      name of the extcon device.
  * @print_state:        An optional callback to override the method to print the
  *                      status of the extcon device.
  * @dev:                Device of this extcon.
  * @state:              Attach/detach state of this extcon. Do not provide at
  *                      register-time.
  * @nh:                 Notifier for the state change events from this extcon
- * @entry:              To support list of extcon devices so that users can search
- *                      for extcon devices based on the extcon name.
+ * @entry:              To support list of extcon devices so that users can
+ *                      search for extcon devices based on the extcon name.
  * @lock:
  * @max_supported:      Internal value to store the number of cables.
  * @extcon_dev_type:    Device_type struct to provide attribute_groups
@@ -113,16 +99,15 @@ struct extcon_cable;
 struct extcon_dev {
         /* Optional user initializing data */
         const char *name;
-        const char **supported_cable;
+        const unsigned int *supported_cable;
         const u32 *mutually_exclusive;
 
         /* Optional callbacks to override class functions */
-        ssize_t (*print_name)(struct extcon_dev *edev, char *buf);
         ssize_t (*print_state)(struct extcon_dev *edev, char *buf);
 
         /* Internal data. Please do not set. */
         struct device dev;
-        struct raw_notifier_head nh;
+        struct raw_notifier_head *nh;
         struct list_head entry;
         int max_supported;
         spinlock_t lock;        /* could be called by irq handler */
@@ -161,8 +146,6 @@ struct extcon_cable {
 /**
  * struct extcon_specific_cable_nb - An internal data for
  *                                   extcon_register_interest().
- * @internal_nb:        A notifier block bridging extcon notifier
- *                      and cable notifier.
  * @user_nb:            user provided notifier block for events from
  *                      a specific cable.
  * @cable_index:        the target cable.
@@ -170,7 +153,6 @@ struct extcon_cable {
  * @previous_value:     the saved previous event value.
  */
 struct extcon_specific_cable_nb {
-        struct notifier_block internal_nb;
         struct notifier_block *user_nb;
         int cable_index;
         struct extcon_dev *edev;
@@ -194,10 +176,10 @@ extern struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name);
 /*
  * Following APIs control the memory of extcon device.
  */
-extern struct extcon_dev *extcon_dev_allocate(const char **cables);
+extern struct extcon_dev *extcon_dev_allocate(const unsigned int *cable);
 extern void extcon_dev_free(struct extcon_dev *edev);
 extern struct extcon_dev *devm_extcon_dev_allocate(struct device *dev,
-                                                   const char **cables);
+                                                   const unsigned int *cable);
 extern void devm_extcon_dev_free(struct device *dev, struct extcon_dev *edev);
 
 /*
@@ -216,13 +198,10 @@ extern int extcon_update_state(struct extcon_dev *edev, u32 mask, u32 state);
 
 /*
  * get/set_cable_state access each bit of the 32b encoded state value.
- * They are used to access the status of each cable based on the cable_name
- * or cable_index, which is retrieved by extcon_find_cable_index
+ * They are used to access the status of each cable based on the cable_name.
  */
-extern int extcon_find_cable_index(struct extcon_dev *sdev,
-                                   const char *cable_name);
-extern int extcon_get_cable_state_(struct extcon_dev *edev, int cable_index);
-extern int extcon_set_cable_state_(struct extcon_dev *edev, int cable_index,
+extern int extcon_get_cable_state_(struct extcon_dev *edev, unsigned int id);
+extern int extcon_set_cable_state_(struct extcon_dev *edev, unsigned int id,
                                    bool cable_state);
 
 extern int extcon_get_cable_state(struct extcon_dev *edev,
@@ -249,16 +228,21 @@ extern int extcon_unregister_interest(struct extcon_specific_cable_nb *nb);
  * we do not recommend to use this for normal 'notifiee' device drivers who
  * want to be notified by a specific external port of the notifier.
  */
-extern int extcon_register_notifier(struct extcon_dev *edev,
+extern int extcon_register_notifier(struct extcon_dev *edev, unsigned int id,
+                                    struct notifier_block *nb);
+extern int extcon_unregister_notifier(struct extcon_dev *edev, unsigned int id,
                                     struct notifier_block *nb);
-extern int extcon_unregister_notifier(struct extcon_dev *edev,
-                                      struct notifier_block *nb);
 
 /*
  * Following API get the extcon device from devicetree.
  * This function use phandle of devicetree to get extcon device directly.
  */
-extern struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev, int index);
+extern struct extcon_dev *extcon_get_edev_by_phandle(struct device *dev,
+                                                     int index);
+
+/* Following API to get information of extcon device */
+extern const char *extcon_get_edev_name(struct extcon_dev *edev);
+
 #else /* CONFIG_EXTCON */
 static inline int extcon_dev_register(struct extcon_dev *edev)
 {
@@ -276,7 +260,7 @@ static inline int devm_extcon_dev_register(struct device *dev,
 static inline void devm_extcon_dev_unregister(struct device *dev,
                                               struct extcon_dev *edev) { }
 
-static inline struct extcon_dev *extcon_dev_allocate(const char **cables)
+static inline struct extcon_dev *extcon_dev_allocate(const unsigned int *cable)
 {
         return ERR_PTR(-ENOSYS);
 }
@@ -284,7 +268,7 @@ static inline struct extcon_dev *extcon_dev_allocate(const char **cables)
 static inline void extcon_dev_free(struct extcon_dev *edev) { }
 
 static inline struct extcon_dev *devm_extcon_dev_allocate(struct device *dev,
-                                                          const char **cables)
+                                                const unsigned int *cable)
 {
         return ERR_PTR(-ENOSYS);
 }
@@ -307,20 +291,14 @@ static inline int extcon_update_state(struct extcon_dev *edev, u32 mask,
         return 0;
 }
 
-static inline int extcon_find_cable_index(struct extcon_dev *edev,
-                                          const char *cable_name)
-{
-        return 0;
-}
-
 static inline int extcon_get_cable_state_(struct extcon_dev *edev,
-                                          int cable_index)
+                                          unsigned int id)
 {
         return 0;
 }
 
 static inline int extcon_set_cable_state_(struct extcon_dev *edev,
-                                          int cable_index, bool cable_state)
+                                          unsigned int id, bool cable_state)
 {
         return 0;
 }
@@ -343,13 +321,15 @@ static inline struct extcon_dev *extcon_get_extcon_dev(const char *extcon_name)
 }
 
 static inline int extcon_register_notifier(struct extcon_dev *edev,
-                                           struct notifier_block *nb)
+                                        unsigned int id,
+                                        struct notifier_block *nb)
 {
         return 0;
 }
 
 static inline int extcon_unregister_notifier(struct extcon_dev *edev,
-                                             struct notifier_block *nb)
+                                        unsigned int id,
+                                        struct notifier_block *nb)
 {
         return 0;
 }
diff --git a/include/linux/extcon/extcon-adc-jack.h b/include/linux/extcon/extcon-adc-jack.h
index 9ca958c4e94c..53c60806bcfb 100644
--- a/include/linux/extcon/extcon-adc-jack.h
+++ b/include/linux/extcon/extcon-adc-jack.h
@@ -44,7 +44,7 @@ struct adc_jack_cond {
  * @consumer_channel:   Unique name to identify the channel on the consumer
  *                      side. This typically describes the channels used within
  *                      the consumer. E.g. 'battery_voltage'
- * @cable_names:        array of cable names ending with null.
+ * @cable_names:        array of extcon id for supported cables.
  * @adc_contitions:     array of struct adc_jack_cond conditions ending
  *                      with .state = 0 entry. This describes how to decode
  *                      adc values into extcon state.
@@ -58,8 +58,7 @@ struct adc_jack_pdata {
         const char *name;
         const char *consumer_channel;
 
-        /* The last entry should be NULL */
-        const char **cable_names;
+        const enum extcon *cable_names;
 
         /* The last entry's state should be 0 */
         struct adc_jack_cond *adc_conditions;
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 591f8c3ef410..920408a21ffd 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -50,6 +50,8 @@
 #define MAX_ACTIVE_NODE_LOGS    8
 #define MAX_ACTIVE_DATA_LOGS    8
 
+#define VERSION_LEN     256
+
 /*
  * For superblock
  */
@@ -86,6 +88,12 @@ struct f2fs_super_block {
         __le32 extension_count;         /* # of extensions below */
         __u8 extension_list[F2FS_MAX_EXTENSION][8];     /* extension array */
         __le32 cp_payload;
+        __u8 version[VERSION_LEN];      /* the kernel version */
+        __u8 init_version[VERSION_LEN]; /* the initial kernel version */
+        __le32 feature;                 /* defined features */
+        __u8 encryption_level;          /* versioning level for encryption */
+        __u8 encrypt_pw_salt[16];       /* Salt used for string2key algorithm */
+        __u8 reserved[871];             /* valid reserved region */
 } __packed;
 
 /*
diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
index 230f87bdf5ad..fbb88740634a 100644
--- a/include/linux/fdtable.h
+++ b/include/linux/fdtable.h
@@ -47,6 +47,9 @@ struct files_struct {
    * read mostly part
    */
         atomic_t count;
+        bool resize_in_progress;
+        wait_queue_head_t resize_wait;
+
         struct fdtable __rcu *fdt;
         struct fdtable fdtab;
   /*
diff --git a/include/linux/filter.h b/include/linux/filter.h
index fa11b3a367be..17724f6ea983 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -207,6 +207,16 @@ struct bpf_prog_aux;
                 .off   = OFF,                                   \
                 .imm   = 0 })
 
+/* Atomic memory add, *(uint *)(dst_reg + off16) += src_reg */
+
+#define BPF_STX_XADD(SIZE, DST, SRC, OFF)                       \
+        ((struct bpf_insn) {                                    \
+                .code  = BPF_STX | BPF_SIZE(SIZE) | BPF_XADD,   \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = OFF,                                   \
+                .imm   = 0 })
+
 /* Memory store, *(uint *) (dst_reg + off16) = imm32 */
 
 #define BPF_ST_MEM(SIZE, DST, OFF, IMM)                         \
@@ -267,6 +277,14 @@ struct bpf_prog_aux;
                 .off   = 0,                                     \
                 .imm   = 0 })
 
+/* Internal classic blocks for direct assignment */
+
+#define __BPF_STMT(CODE, K)                                     \
+        ((struct sock_filter) BPF_STMT(CODE, K))
+
+#define __BPF_JUMP(CODE, K, JT, JF)                             \
+        ((struct sock_filter) BPF_JUMP(CODE, K, JT, JF))
+
 #define bytes_to_bpf_size(bytes)                                \
 ({                                                              \
         int bpf_size = -EINVAL;                                 \
@@ -360,12 +378,9 @@ static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
 
 int sk_filter(struct sock *sk, struct sk_buff *skb);
 
-void bpf_prog_select_runtime(struct bpf_prog *fp);
+int bpf_prog_select_runtime(struct bpf_prog *fp);
 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);
@@ -377,14 +392,17 @@ static inline void bpf_prog_unlock_free(struct bpf_prog *fp)
         __bpf_prog_free(fp);
 }
 
+typedef int (*bpf_aux_classic_check_t)(struct sock_filter *filter,
+                                       unsigned int flen);
+
 int bpf_prog_create(struct bpf_prog **pfp, struct sock_fprog_kern *fprog);
+int bpf_prog_create_from_user(struct bpf_prog **pfp, struct sock_fprog *fprog,
+                              bpf_aux_classic_check_t trans);
 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);
 int sk_get_filter(struct sock *sk, struct sock_filter __user *filter,
                   unsigned int len);
 
diff --git a/include/linux/frontswap.h b/include/linux/frontswap.h
index 8293262401de..e65ef959546c 100644
--- a/include/linux/frontswap.h
+++ b/include/linux/frontswap.h
@@ -6,16 +6,16 @@
 #include <linux/bitops.h>
 
 struct frontswap_ops {
-        void (*init)(unsigned);
-        int (*store)(unsigned, pgoff_t, struct page *);
-        int (*load)(unsigned, pgoff_t, struct page *);
-        void (*invalidate_page)(unsigned, pgoff_t);
-        void (*invalidate_area)(unsigned);
+        void (*init)(unsigned); /* this swap type was just swapon'ed */
+        int (*store)(unsigned, pgoff_t, struct page *); /* store a page */
+        int (*load)(unsigned, pgoff_t, struct page *); /* load a page */
+        void (*invalidate_page)(unsigned, pgoff_t); /* page no longer needed */
+        void (*invalidate_area)(unsigned); /* swap type just swapoff'ed */
+        struct frontswap_ops *next; /* private pointer to next ops */
 };
 
 extern bool frontswap_enabled;
-extern struct frontswap_ops *
-        frontswap_register_ops(struct frontswap_ops *ops);
+extern void frontswap_register_ops(struct frontswap_ops *ops);
 extern void frontswap_shrink(unsigned long);
 extern unsigned long frontswap_curr_pages(void);
 extern void frontswap_writethrough(bool);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b577e801b4af..84b783f277f7 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -35,6 +35,7 @@
 #include <uapi/linux/fs.h>
 
 struct backing_dev_info;
+struct bdi_writeback;
 struct export_operations;
 struct hd_geometry;
 struct iovec;
@@ -54,7 +55,8 @@ struct vm_fault;
 
 extern void __init inode_init(void);
 extern void __init inode_init_early(void);
-extern void __init files_init(unsigned long);
+extern void __init files_init(void);
+extern void __init files_maxfiles_init(void);
 
 extern struct files_stat_struct files_stat;
 extern unsigned long get_max_files(void);
@@ -69,6 +71,7 @@ typedef int (get_block_t)(struct inode *inode, sector_t iblock,
                         struct buffer_head *bh_result, int create);
 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
                         ssize_t bytes, void *private);
+typedef void (dax_iodone_t)(struct buffer_head *bh_map, int uptodate);
 
 #define MAY_EXEC                0x00000001
 #define MAY_WRITE               0x00000002
@@ -634,6 +637,14 @@ struct inode {
 
         struct hlist_node       i_hash;
         struct list_head        i_wb_list;      /* backing dev IO list */
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct bdi_writeback    *i_wb;          /* the associated cgroup wb */
+
+        /* foreign inode detection, see wbc_detach_inode() */
+        int                     i_wb_frn_winner;
+        u16                     i_wb_frn_avg_time;
+        u16                     i_wb_frn_history;
+#endif
         struct list_head        i_lru;          /* inode LRU list */
         struct list_head        i_sb_list;
         union {
@@ -1036,12 +1047,12 @@ extern void locks_remove_file(struct file *);
 extern void locks_release_private(struct file_lock *);
 extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
-extern int posix_lock_file_wait(struct file *, struct file_lock *);
+extern int posix_lock_inode_wait(struct inode *, struct file_lock *);
 extern int posix_unblock_lock(struct file_lock *);
 extern int vfs_test_lock(struct file *, struct file_lock *);
 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
 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 flock_lock_inode_wait(struct inode *inode, 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 **, void **priv);
@@ -1127,7 +1138,8 @@ static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
         return -ENOLCK;
 }
 
-static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
+static inline int posix_lock_inode_wait(struct inode *inode,
+                                        struct file_lock *fl)
 {
         return -ENOLCK;
 }
@@ -1153,8 +1165,8 @@ static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
         return 0;
 }
 
-static inline int flock_lock_file_wait(struct file *filp,
-                                       struct file_lock *request)
+static inline int flock_lock_inode_wait(struct inode *inode,
+                                        struct file_lock *request)
 {
         return -ENOLCK;
 }
@@ -1192,6 +1204,20 @@ static inline void show_fd_locks(struct seq_file *f,
                         struct file *filp, struct files_struct *files) {}
 #endif /* !CONFIG_FILE_LOCKING */
 
+static inline struct inode *file_inode(const struct file *f)
+{
+        return f->f_inode;
+}
+
+static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
+{
+        return posix_lock_inode_wait(file_inode(filp), fl);
+}
+
+static inline int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
+{
+        return flock_lock_inode_wait(file_inode(filp), fl);
+}
 
 struct fasync_struct {
         spinlock_t              fa_lock;
@@ -1232,6 +1258,8 @@ struct mm_struct;
 #define UMOUNT_NOFOLLOW 0x00000008      /* Don't follow symlink on umount */
 #define UMOUNT_UNUSED   0x80000000      /* Flag guaranteed to be unused */
 
+/* sb->s_iflags */
+#define SB_I_CGROUPWB   0x00000001      /* cgroup-aware writeback enabled */
 
 /* Possible states of 'frozen' field */
 enum {
@@ -1270,6 +1298,7 @@ struct super_block {
         const struct quotactl_ops       *s_qcop;
         const struct export_operations *s_export_op;
         unsigned long           s_flags;
+        unsigned long           s_iflags;       /* internal SB_I_* flags */
         unsigned long           s_magic;
         struct dentry           *s_root;
         struct rw_semaphore     s_umount;
@@ -1641,7 +1670,6 @@ struct inode_operations {
         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,
@@ -1806,6 +1834,11 @@ struct super_operations {
  *
  * I_DIO_WAKEUP         Never set.  Only used as a key for wait_on_bit().
  *
+ * I_WB_SWITCH          Cgroup bdi_writeback switching in progress.  Used to
+ *                      synchronize competing switching instances and to tell
+ *                      wb stat updates to grab mapping->tree_lock.  See
+ *                      inode_switch_wb_work_fn() for details.
+ *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  */
 #define I_DIRTY_SYNC            (1 << 0)
@@ -1825,6 +1858,7 @@ struct super_operations {
 #define I_DIRTY_TIME            (1 << 11)
 #define __I_DIRTY_TIME_EXPIRED  12
 #define I_DIRTY_TIME_EXPIRED    (1 << __I_DIRTY_TIME_EXPIRED)
+#define I_WB_SWITCH             (1 << 13)
 
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 #define I_DIRTY_ALL (I_DIRTY | I_DIRTY_TIME)
@@ -1898,6 +1932,7 @@ struct file_system_type {
 #define FS_HAS_SUBTYPE          4
 #define FS_USERNS_MOUNT         8       /* Can be mounted by userns root */
 #define FS_USERNS_DEV_MOUNT     16 /* A userns mount does not imply MNT_NODEV */
+#define FS_USERNS_VISIBLE       32      /* FS must already be visible */
 #define FS_RENAME_DOES_D_MOVE   32768   /* FS will handle d_move() during rename() internally. */
         struct dentry *(*mount) (struct file_system_type *, int,
                        const char *, void *);
@@ -1985,7 +2020,6 @@ extern int vfs_ustat(dev_t, struct kstatfs *);
 extern int freeze_super(struct super_block *super);
 extern int thaw_super(struct super_block *super);
 extern bool our_mnt(struct vfsmount *mnt);
-extern bool fs_fully_visible(struct file_system_type *);
 
 extern int current_umask(void);
 
@@ -1993,11 +2027,6 @@ extern void ihold(struct inode * inode);
 extern void iput(struct inode *);
 extern int generic_update_time(struct inode *, struct timespec *, int);
 
-static inline struct inode *file_inode(const struct file *f)
-{
-        return f->f_inode;
-}
-
 /* /sys/fs */
 extern struct kobject *fs_kobj;
 
@@ -2194,7 +2223,6 @@ 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);
 
@@ -2218,7 +2246,7 @@ extern int ioctl_preallocate(struct file *filp, void __user *argp);
 
 /* fs/dcache.c */
 extern void __init vfs_caches_init_early(void);
-extern void __init vfs_caches_init(unsigned long);
+extern void __init vfs_caches_init(void);
 
 extern struct kmem_cache *names_cachep;
 
@@ -2241,7 +2269,13 @@ extern struct super_block *freeze_bdev(struct block_device *);
 extern void emergency_thaw_all(void);
 extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
 extern int fsync_bdev(struct block_device *);
-extern int sb_is_blkdev_sb(struct super_block *sb);
+
+extern struct super_block *blockdev_superblock;
+
+static inline bool sb_is_blkdev_sb(struct super_block *sb)
+{
+        return sb == blockdev_superblock;
+}
 #else
 static inline void bd_forget(struct inode *inode) {}
 static inline int sync_blockdev(struct block_device *bdev) { return 0; }
@@ -2280,6 +2314,9 @@ extern struct block_device *blkdev_get_by_path(const char *path, fmode_t mode,
 extern struct block_device *blkdev_get_by_dev(dev_t dev, fmode_t mode,
                                               void *holder);
 extern void blkdev_put(struct block_device *bdev, fmode_t mode);
+extern int __blkdev_reread_part(struct block_device *bdev);
+extern int blkdev_reread_part(struct block_device *bdev);
+
 #ifdef CONFIG_SYSFS
 extern int bd_link_disk_holder(struct block_device *bdev, struct gendisk *disk);
 extern void bd_unlink_disk_holder(struct block_device *bdev,
@@ -2502,6 +2539,8 @@ extern struct file * open_exec(const char *);
 extern int is_subdir(struct dentry *, struct dentry *);
 extern int path_is_under(struct path *, struct path *);
 
+extern char *file_path(struct file *, char *, int);
+
 #include <linux/err.h>
 
 /* needed for stackable file system support */
@@ -2553,7 +2592,12 @@ extern struct inode *new_inode_pseudo(struct super_block *sb);
 extern struct inode *new_inode(struct super_block *sb);
 extern void free_inode_nonrcu(struct inode *inode);
 extern int should_remove_suid(struct dentry *);
-extern int file_remove_suid(struct file *);
+extern int file_remove_privs(struct file *);
+extern int dentry_needs_remove_privs(struct dentry *dentry);
+static inline int file_needs_remove_privs(struct file *file)
+{
+        return dentry_needs_remove_privs(file->f_path.dentry);
+}
 
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 static inline void insert_inode_hash(struct inode *inode)
@@ -2628,9 +2672,13 @@ ssize_t dax_do_io(struct kiocb *, struct inode *, struct iov_iter *, loff_t,
 int dax_clear_blocks(struct inode *, sector_t block, long size);
 int dax_zero_page_range(struct inode *, loff_t from, unsigned len, get_block_t);
 int dax_truncate_page(struct inode *, loff_t from, get_block_t);
-int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t);
+int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t,
+                dax_iodone_t);
+int __dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t,
+                dax_iodone_t);
 int dax_pfn_mkwrite(struct vm_area_struct *, struct vm_fault *);
-#define dax_mkwrite(vma, vmf, gb)       dax_fault(vma, vmf, gb)
+#define dax_mkwrite(vma, vmf, gb, iod)          dax_fault(vma, vmf, gb, iod)
+#define __dax_mkwrite(vma, vmf, gb, iod)        __dax_fault(vma, vmf, gb, iod)
 
 #ifdef CONFIG_BLOCK
 typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
@@ -2784,6 +2832,8 @@ extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned in
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
 extern const struct file_operations simple_dir_operations;
 extern const struct inode_operations simple_dir_inode_operations;
+extern void make_empty_dir_inode(struct inode *inode);
+extern bool is_empty_dir_inode(struct inode *inode);
 struct tree_descr { char *name; const struct file_operations *ops; int mode; };
 struct dentry *d_alloc_name(struct dentry *, const char *);
 extern int simple_fill_super(struct super_block *, unsigned long, struct tree_descr *);
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 771484993ca7..604e1526cd00 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -74,6 +74,7 @@ extern wait_queue_head_t fscache_cache_cleared_wq;
  */
 typedef void (*fscache_operation_release_t)(struct fscache_operation *op);
 typedef void (*fscache_operation_processor_t)(struct fscache_operation *op);
+typedef void (*fscache_operation_cancel_t)(struct fscache_operation *op);
 
 enum fscache_operation_state {
         FSCACHE_OP_ST_BLANK,            /* Op is not yet submitted */
@@ -109,6 +110,9 @@ struct fscache_operation {
          *   the op in a non-pool thread */
         fscache_operation_processor_t processor;
 
+        /* Operation cancellation cleanup (optional) */
+        fscache_operation_cancel_t cancel;
+
         /* operation releaser */
         fscache_operation_release_t release;
 };
@@ -119,33 +123,17 @@ extern void fscache_op_work_func(struct work_struct *work);
 extern void fscache_enqueue_operation(struct fscache_operation *);
 extern void fscache_op_complete(struct fscache_operation *, bool);
 extern void fscache_put_operation(struct fscache_operation *);
-
-/**
- * fscache_operation_init - Do basic initialisation of an operation
- * @op: The operation to initialise
- * @release: The release function to assign
- *
- * Do basic initialisation of an operation.  The caller must still set flags,
- * object and processor if needed.
- */
-static inline void fscache_operation_init(struct fscache_operation *op,
-                                        fscache_operation_processor_t processor,
-                                        fscache_operation_release_t release)
-{
-        INIT_WORK(&op->work, fscache_op_work_func);
-        atomic_set(&op->usage, 1);
-        op->state = FSCACHE_OP_ST_INITIALISED;
-        op->debug_id = atomic_inc_return(&fscache_op_debug_id);
-        op->processor = processor;
-        op->release = release;
-        INIT_LIST_HEAD(&op->pend_link);
-}
+extern void fscache_operation_init(struct fscache_operation *,
+                                   fscache_operation_processor_t,
+                                   fscache_operation_cancel_t,
+                                   fscache_operation_release_t);
 
 /*
  * data read operation
  */
 struct fscache_retrieval {
         struct fscache_operation op;
+        struct fscache_cookie   *cookie;        /* The netfs cookie */
         struct address_space    *mapping;       /* netfs pages */
         fscache_rw_complete_t   end_io_func;    /* function to call on I/O completion */
         void                    *context;       /* netfs read context (pinned) */
@@ -371,6 +359,7 @@ struct fscache_object {
 #define FSCACHE_OBJECT_IS_LOOKED_UP     4       /* T if object has been looked up */
 #define FSCACHE_OBJECT_IS_AVAILABLE     5       /* T if object has become active */
 #define FSCACHE_OBJECT_RETIRED          6       /* T if object was retired on relinquishment */
+#define FSCACHE_OBJECT_KILLED_BY_CACHE  7       /* T if object was killed by the cache */
 
         struct list_head        cache_link;     /* link in cache->object_list */
         struct hlist_node       cookie_link;    /* link in cookie->backing_objects */
@@ -410,17 +399,16 @@ static inline bool fscache_object_is_available(struct fscache_object *object)
         return test_bit(FSCACHE_OBJECT_IS_AVAILABLE, &object->flags);
 }
 
-static inline bool fscache_object_is_active(struct fscache_object *object)
+static inline bool fscache_cache_is_broken(struct fscache_object *object)
 {
-        return fscache_object_is_available(object) &&
-                fscache_object_is_live(object) &&
-                !test_bit(FSCACHE_IOERROR, &object->cache->flags);
+        return test_bit(FSCACHE_IOERROR, &object->cache->flags);
 }
 
-static inline bool fscache_object_is_dead(struct fscache_object *object)
+static inline bool fscache_object_is_active(struct fscache_object *object)
 {
-        return fscache_object_is_dying(object) &&
-                test_bit(FSCACHE_IOERROR, &object->cache->flags);
+        return fscache_object_is_available(object) &&
+                fscache_object_is_live(object) &&
+                !fscache_cache_is_broken(object);
 }
 
 /**
@@ -551,4 +539,15 @@ extern enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
                                                const void *data,
                                                uint16_t datalen);
 
+extern void fscache_object_retrying_stale(struct fscache_object *object);
+
+enum fscache_why_object_killed {
+        FSCACHE_OBJECT_IS_STALE,
+        FSCACHE_OBJECT_NO_SPACE,
+        FSCACHE_OBJECT_WAS_RETIRED,
+        FSCACHE_OBJECT_WAS_CULLED,
+};
+extern void fscache_object_mark_killed(struct fscache_object *object,
+                                       enum fscache_why_object_killed why);
+
 #endif /* _LINUX_FSCACHE_CACHE_H */
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index a82296af413f..2a2f56b292c1 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -24,6 +24,7 @@
 #define FSL_USB_VER_1_6         1
 #define FSL_USB_VER_2_2         2
 #define FSL_USB_VER_2_4         3
+#define FSL_USB_VER_2_5         4
 
 #include <linux/types.h>
 
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index 0f313f93c586..65a517dd32f7 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -84,8 +84,6 @@ struct fsnotify_fname;
  * Each group much define these ops.  The fsnotify infrastructure will call
  * these operations for each relevant group.
  *
- * should_send_event - given a group, inode, and mask this function determines
- *              if the group is interested in this event.
  * handle_event - main call for a group to handle an fs event
  * free_group_priv - called when a group refcnt hits 0 to clean up the private union
  * freeing_mark - called when a mark is being destroyed for some reason.  The group
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 1da602982cf9..6cd8c0ee4b6f 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -116,6 +116,7 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
  *            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.
+ * PID     - Is affected by set_ftrace_pid (allows filtering on those pids)
  */
 enum {
         FTRACE_OPS_FL_ENABLED                   = 1 << 0,
@@ -132,6 +133,7 @@ enum {
         FTRACE_OPS_FL_MODIFYING                 = 1 << 11,
         FTRACE_OPS_FL_ALLOC_TRAMP               = 1 << 12,
         FTRACE_OPS_FL_IPMODIFY                  = 1 << 13,
+        FTRACE_OPS_FL_PID                       = 1 << 14,
 };
 
 #ifdef CONFIG_DYNAMIC_FTRACE
@@ -159,6 +161,7 @@ struct ftrace_ops {
         struct ftrace_ops               *next;
         unsigned long                   flags;
         void                            *private;
+        ftrace_func_t                   saved_func;
         int __percpu                    *disabled;
 #ifdef CONFIG_DYNAMIC_FTRACE
         int                             nr_trampolines;
diff --git a/include/linux/genalloc.h b/include/linux/genalloc.h
index 1ccaab44abcc..5383bb1394a1 100644
--- a/include/linux/genalloc.h
+++ b/include/linux/genalloc.h
@@ -119,16 +119,16 @@ extern unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
 
 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);
+extern struct gen_pool *gen_pool_get(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,
+extern struct gen_pool *of_gen_pool_get(struct device_node *np,
         const char *propname, int index);
 #else
-static inline struct gen_pool *of_get_named_gen_pool(struct device_node *np,
+static inline struct gen_pool *of_gen_pool_get(struct device_node *np,
         const char *propname, int index)
 {
         return NULL;
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 15928f0647e4..ad35f300b9a4 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -368,6 +368,11 @@ extern void free_pages(unsigned long addr, unsigned int order);
 extern void free_hot_cold_page(struct page *page, bool cold);
 extern void free_hot_cold_page_list(struct list_head *list, bool cold);
 
+struct page_frag_cache;
+extern void *__alloc_page_frag(struct page_frag_cache *nc,
+                               unsigned int fragsz, gfp_t gfp_mask);
+extern void __free_page_frag(void *addr);
+
 extern void __free_kmem_pages(struct page *page, unsigned int order);
 extern void free_kmem_pages(unsigned long addr, unsigned int order);
 
@@ -379,6 +384,14 @@ void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
 void drain_all_pages(struct zone *zone);
 void drain_local_pages(struct zone *zone);
 
+#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
+void page_alloc_init_late(void);
+#else
+static inline void page_alloc_init_late(void)
+{
+}
+#endif
+
 /*
  * gfp_allowed_mask is set to GFP_BOOT_MASK during early boot to restrict what
  * GFP flags are used before interrupts are enabled. Once interrupts are
diff --git a/include/linux/goldfish.h b/include/linux/goldfish.h
index 569236e6b2bc..93e080b39cf6 100644
--- a/include/linux/goldfish.h
+++ b/include/linux/goldfish.h
@@ -3,13 +3,24 @@
 
 /* Helpers for Goldfish virtual platform */
 
-static inline void gf_write64(unsigned long data,
-                void __iomem *portl, void __iomem *porth)
+static inline void gf_write_ptr(const void *ptr, void __iomem *portl,
+                                void __iomem *porth)
 {
-        writel((u32)data, portl);
+        writel((u32)(unsigned long)ptr, portl);
 #ifdef CONFIG_64BIT
-        writel(data>>32, porth);
+        writel((unsigned long)ptr >> 32, porth);
 #endif
 }
 
+static inline void gf_write_dma_addr(const dma_addr_t addr,
+                                     void __iomem *portl,
+                                     void __iomem *porth)
+{
+        writel((u32)addr, portl);
+#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
+        writel(addr >> 32, porth);
+#endif
+}
+
+
 #endif /* __LINUX_GOLDFISH_H */
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index fd098169fe87..adac255aee86 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -407,6 +407,21 @@ static inline int desc_to_gpio(const struct gpio_desc *desc)
         return -EINVAL;
 }
 
+/* Child properties interface */
+struct fwnode_handle;
+
+static inline struct gpio_desc *fwnode_get_named_gpiod(
+        struct fwnode_handle *fwnode, const char *propname)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
+static inline struct gpio_desc *devm_get_gpiod_from_child(
+        struct device *dev, const char *con_id, struct fwnode_handle *child)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
 #endif /* CONFIG_GPIOLIB */
 
 /*
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index cc7ec129b329..c8393cd4d44f 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -45,7 +45,7 @@ struct seq_file;
  * @base: identifies the first GPIO number handled by this chip;
  *      or, if negative during registration, requests dynamic ID allocation.
  *      DEPRECATION: providing anything non-negative and nailing the base
- *      base offset of GPIO chips is deprecated. Please pass -1 as base to
+ *      offset of GPIO chips is deprecated. Please pass -1 as base to
  *      let gpiolib select the chip base in all possible cases. We want to
  *      get rid of the static GPIO number space in the long run.
  * @ngpio: the number of GPIOs handled by this controller; the last GPIO
diff --git a/include/linux/gsmmux.h b/include/linux/gsmmux.h
deleted file mode 100644
index c25e9477f7c3..000000000000
--- a/include/linux/gsmmux.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef _LINUX_GSMMUX_H
-#define _LINUX_GSMMUX_H
-
-struct gsm_config
-{
-        unsigned int adaption;
-        unsigned int encapsulation;
-        unsigned int initiator;
-        unsigned int t1;
-        unsigned int t2;
-        unsigned int t3;
-        unsigned int n2;
-        unsigned int mru;
-        unsigned int mtu;
-        unsigned int k;
-        unsigned int i;
-        unsigned int unused[8];         /* Padding for expansion without
-                                           breaking stuff */
-};
-
-#define GSMIOC_GETCONF          _IOR('G', 0, struct gsm_config)
-#define GSMIOC_SETCONF          _IOW('G', 1, struct gsm_config)
-
-struct gsm_netconfig {
-        unsigned int adaption;  /* Adaption to use in network mode */
-        unsigned short protocol;/* Protocol to use - only ETH_P_IP supported */
-        unsigned short unused2;
-        char if_name[IFNAMSIZ]; /* interface name format string */
-        __u8 unused[28];        /* For future use */
-};
-
-#define GSMIOC_ENABLE_NET      _IOW('G', 2, struct gsm_netconfig)
-#define GSMIOC_DISABLE_NET     _IO('G', 3)
-
-
-#endif
diff --git a/include/linux/hid-sensor-hub.h b/include/linux/hid-sensor-hub.h
index 0042bf330b99..c02b5ce6c5cd 100644
--- a/include/linux/hid-sensor-hub.h
+++ b/include/linux/hid-sensor-hub.h
@@ -230,6 +230,7 @@ struct hid_sensor_common {
         struct platform_device *pdev;
         unsigned usage_id;
         atomic_t data_ready;
+        atomic_t user_requested_state;
         struct iio_trigger *trigger;
         struct hid_sensor_hub_attribute_info poll;
         struct hid_sensor_hub_attribute_info report_state;
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 205026175c42..d891f949466a 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -460,15 +460,14 @@ static inline spinlock_t *huge_pte_lockptr(struct hstate *h,
         return &mm->page_table_lock;
 }
 
-static inline bool hugepages_supported(void)
-{
-        /*
-         * Some platform decide whether they support huge pages at boot
-         * time. On these, such as powerpc, HPAGE_SHIFT is set to 0 when
-         * there is no such support
-         */
-        return HPAGE_SHIFT != 0;
-}
+#ifndef hugepages_supported
+/*
+ * Some platform decide whether they support huge pages at boot
+ * time. Some of them, such as powerpc, set HPAGE_SHIFT to 0
+ * when there is no such support
+ */
+#define hugepages_supported() (HPAGE_SHIFT != 0)
+#endif
 
 #else   /* CONFIG_HUGETLB_PAGE */
 struct hstate {};
diff --git a/include/linux/hwspinlock.h b/include/linux/hwspinlock.h
index 3343298e40e8..859d673d98c8 100644
--- a/include/linux/hwspinlock.h
+++ b/include/linux/hwspinlock.h
@@ -26,6 +26,7 @@
 #define HWLOCK_IRQ      0x02    /* Disable interrupts, don't save state */
 
 struct device;
+struct device_node;
 struct hwspinlock;
 struct hwspinlock_device;
 struct hwspinlock_ops;
@@ -66,6 +67,7 @@ int hwspin_lock_unregister(struct hwspinlock_device *bank);
 struct hwspinlock *hwspin_lock_request(void);
 struct hwspinlock *hwspin_lock_request_specific(unsigned int id);
 int hwspin_lock_free(struct hwspinlock *hwlock);
+int of_hwspin_lock_get_id(struct device_node *np, int index);
 int hwspin_lock_get_id(struct hwspinlock *hwlock);
 int __hwspin_lock_timeout(struct hwspinlock *, unsigned int, int,
                                                         unsigned long *);
@@ -120,6 +122,11 @@ void __hwspin_unlock(struct hwspinlock *hwlock, int mode, unsigned long *flags)
 {
 }
 
+static inline int of_hwspin_lock_get_id(struct device_node *np, int index)
+{
+        return 0;
+}
+
 static inline int hwspin_lock_get_id(struct hwspinlock *hwlock)
 {
         return 0;
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 902c37aef67e..30d3a1f79450 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -160,16 +160,18 @@ hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi,
  * 1 . 1  (Windows 7)
  * 2 . 4  (Windows 8)
  * 3 . 0  (Windows 8 R2)
+ * 4 . 0  (Windows 10)
  */
 
 #define VERSION_WS2008  ((0 << 16) | (13))
 #define VERSION_WIN7    ((1 << 16) | (1))
 #define VERSION_WIN8    ((2 << 16) | (4))
 #define VERSION_WIN8_1    ((3 << 16) | (0))
+#define VERSION_WIN10   ((4 << 16) | (0))
 
 #define VERSION_INVAL -1
 
-#define VERSION_CURRENT VERSION_WIN8_1
+#define VERSION_CURRENT VERSION_WIN10
 
 /* Make maximum size of pipe payload of 16K */
 #define MAX_PIPE_DATA_PAYLOAD           (sizeof(u8) * 16384)
@@ -389,10 +391,7 @@ enum vmbus_channel_message_type {
         CHANNELMSG_INITIATE_CONTACT             = 14,
         CHANNELMSG_VERSION_RESPONSE             = 15,
         CHANNELMSG_UNLOAD                       = 16,
-#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
-        CHANNELMSG_VIEWRANGE_ADD                = 17,
-        CHANNELMSG_VIEWRANGE_REMOVE             = 18,
-#endif
+        CHANNELMSG_UNLOAD_RESPONSE              = 17,
         CHANNELMSG_COUNT
 };
 
@@ -549,21 +548,6 @@ struct vmbus_channel_gpadl_torndown {
         u32 gpadl;
 } __packed;
 
-#ifdef VMBUS_FEATURE_PARENT_OR_PEER_MEMORY_MAPPED_INTO_A_CHILD
-struct vmbus_channel_view_range_add {
-        struct vmbus_channel_message_header header;
-        PHYSICAL_ADDRESS viewrange_base;
-        u64 viewrange_length;
-        u32 child_relid;
-} __packed;
-
-struct vmbus_channel_view_range_remove {
-        struct vmbus_channel_message_header header;
-        PHYSICAL_ADDRESS viewrange_base;
-        u32 child_relid;
-} __packed;
-#endif
-
 struct vmbus_channel_relid_released {
         struct vmbus_channel_message_header header;
         u32 child_relid;
@@ -713,6 +697,11 @@ struct vmbus_channel {
         /* The corresponding CPUID in the guest */
         u32 target_cpu;
         /*
+         * State to manage the CPU affiliation of channels.
+         */
+        struct cpumask alloced_cpus_in_node;
+        int numa_node;
+        /*
          * Support for sub-channels. For high performance devices,
          * it will be useful to have multiple sub-channels to support
          * a scalable communication infrastructure with the host.
@@ -745,6 +734,15 @@ struct vmbus_channel {
          */
         struct list_head sc_list;
         /*
+         * Current number of sub-channels.
+         */
+        int num_sc;
+        /*
+         * Number of a sub-channel (position within sc_list) which is supposed
+         * to be used as the next outgoing channel.
+         */
+        int next_oc;
+        /*
          * The primary channel this sub-channel belongs to.
          * This will be NULL for the primary channel.
          */
@@ -758,9 +756,6 @@ struct vmbus_channel {
          * link up channels based on their CPU affinity.
          */
         struct list_head percpu_list;
-
-        int num_sc;
-        int next_oc;
 };
 
 static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
@@ -1236,13 +1231,6 @@ extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *,
                                         struct icmsg_negotiate *, u8 *, int,
                                         int);
 
-int hv_kvp_init(struct hv_util_service *);
-void hv_kvp_deinit(void);
-void hv_kvp_onchannelcallback(void *);
-
-int hv_vss_init(struct hv_util_service *);
-void hv_vss_deinit(void);
-void hv_vss_onchannelcallback(void *);
 void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid);
 
 extern struct resource hyperv_mmio;
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index 0bc03f100d04..9ad7828d9d34 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -675,6 +675,7 @@ struct twl4030_power_data {
         struct twl4030_resconfig *board_config;
 #define TWL4030_RESCONFIG_UNDEF ((u8)-1)
         bool use_poweroff;      /* Board is wired for TWL poweroff */
+        bool ac_charger_quirk;  /* Disable AC charger on board */
 };
 
 extern int twl4030_remove_script(u8 flags);
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 93b5ca754b5b..a633898f36ac 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -39,6 +39,19 @@
 
 struct device;
 
+/* IDE-specific values for req->cmd_type */
+enum ata_cmd_type_bits {
+        REQ_TYPE_ATA_TASKFILE = REQ_TYPE_DRV_PRIV + 1,
+        REQ_TYPE_ATA_PC,
+        REQ_TYPE_ATA_SENSE,     /* sense request */
+        REQ_TYPE_ATA_PM_SUSPEND,/* suspend request */
+        REQ_TYPE_ATA_PM_RESUME, /* resume request */
+};
+
+#define ata_pm_request(rq)      \
+        ((rq)->cmd_type == REQ_TYPE_ATA_PM_SUSPEND || \
+         (rq)->cmd_type == REQ_TYPE_ATA_PM_RESUME)
+
 /* Error codes returned in rq->errors to the higher part of the driver. */
 enum {
         IDE_DRV_ERROR_GENERAL   = 101,
@@ -1314,6 +1327,19 @@ struct ide_port_info {
         u8                      udma_mask;
 };
 
+/*
+ * State information carried for REQ_TYPE_ATA_PM_SUSPEND and REQ_TYPE_ATA_PM_RESUME
+ * requests.
+ */
+struct ide_pm_state {
+        /* PM state machine step value, currently driver specific */
+        int     pm_step;
+        /* requested PM state value (S1, S2, S3, S4, ...) */
+        u32     pm_state;
+        void*   data;           /* for driver use */
+};
+
+
 int ide_pci_init_one(struct pci_dev *, const struct ide_port_info *, void *);
 int ide_pci_init_two(struct pci_dev *, struct pci_dev *,
                      const struct ide_port_info *, void *);
@@ -1551,4 +1577,5 @@ static inline void ide_set_drivedata(ide_drive_t *drive, void *data)
 #define ide_host_for_each_port(i, port, host) \
         for ((i) = 0; ((port) = (host)->ports[i]) || (i) < MAX_HOST_PORTS; (i)++)
 
+
 #endif /* _IDE_H */
diff --git a/include/linux/ieee802154.h b/include/linux/ieee802154.h
index 8872ca103d06..1dc1f4ed4001 100644
--- a/include/linux/ieee802154.h
+++ b/include/linux/ieee802154.h
@@ -225,15 +225,13 @@ static inline bool ieee802154_is_valid_psdu_len(const u8 len)
  * 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)
+static inline bool ieee802154_is_valid_extended_unicast_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.
+        /* Bail out if the address is all zero, or if the group
+         * address bit is set.
          */
         return ((addr != cpu_to_le64(0x0000000000000000ULL)) &&
-                (addr != cpu_to_le64(0xffffffffffffffffULL)));
+                !(addr & cpu_to_le64(0x0100000000000000ULL)));
 }
 
 /**
@@ -244,9 +242,9 @@ 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;
+        /* clear the group bit, and set the locally administered bit */
+        ((u8 *)addr)[IEEE802154_EXTENDED_ADDR_LEN - 1] &= ~0x01;
+        ((u8 *)addr)[IEEE802154_EXTENDED_ADDR_LEN - 1] |= 0x02;
 }
 
 #endif /* LINUX_IEEE802154_H */
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index da4929927f69..ae5d0d22955d 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -5,6 +5,15 @@
 
 
 /* We don't want this structure exposed to user space */
+struct ifla_vf_stats {
+        __u64 rx_packets;
+        __u64 tx_packets;
+        __u64 rx_bytes;
+        __u64 tx_bytes;
+        __u64 broadcast;
+        __u64 multicast;
+};
+
 struct ifla_vf_info {
         __u32 vf;
         __u8 mac[32];
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
index 6f6929ea8a0c..a4ccc3122f93 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -29,7 +29,7 @@ struct macvtap_queue;
  * Maximum times a macvtap device can be opened. This can be used to
  * configure the number of receive queue, e.g. for multiqueue virtio.
  */
-#define MAX_MACVTAP_QUEUES      16
+#define MAX_MACVTAP_QUEUES      256
 
 #define MACVLAN_MC_FILTER_BITS  8
 #define MACVLAN_MC_FILTER_SZ    (1 << MACVLAN_MC_FILTER_BITS)
diff --git a/include/linux/if_pppox.h b/include/linux/if_pppox.h
index 66a7d7600f43..b49cf923becc 100644
--- a/include/linux/if_pppox.h
+++ b/include/linux/if_pppox.h
@@ -74,7 +74,7 @@ static inline struct sock *sk_pppox(struct pppox_sock *po)
 struct module;
 
 struct pppox_proto {
-        int             (*create)(struct net *net, struct socket *sock);
+        int             (*create)(struct net *net, struct socket *sock, int kern);
         int             (*ioctl)(struct socket *sock, unsigned int cmd,
                                  unsigned long arg);
         struct module   *owner;
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 920e4457ce6e..67ce5bd3b56a 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -416,7 +416,7 @@ static inline void __vlan_hwaccel_put_tag(struct sk_buff *skb,
 /**
  * __vlan_get_tag - get the VLAN ID that is part of the payload
  * @skb: skbuff to query
- * @vlan_tci: buffer to store vlaue
+ * @vlan_tci: buffer to store value
  *
  * Returns error if the skb is not of VLAN type
  */
@@ -435,7 +435,7 @@ static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 /**
  * __vlan_hwaccel_get_tag - get the VLAN ID that is in @skb->cb[]
  * @skb: skbuff to query
- * @vlan_tci: buffer to store vlaue
+ * @vlan_tci: buffer to store value
  *
  * Returns error if @skb->vlan_tci is not set correctly
  */
@@ -456,7 +456,7 @@ static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
 /**
  * vlan_get_tag - get the VLAN ID from the skb
  * @skb: skbuff to query
- * @vlan_tci: buffer to store vlaue
+ * @vlan_tci: buffer to store value
  *
  * Returns error if the skb is not VLAN tagged
  */
@@ -539,7 +539,7 @@ static inline void vlan_set_encap_proto(struct sk_buff *skb,
          */
 
         proto = vhdr->h_vlan_encapsulated_proto;
-        if (ntohs(proto) >= ETH_P_802_3_MIN) {
+        if (eth_proto_is_802_3(proto)) {
                 skb->protocol = proto;
                 return;
         }
@@ -628,4 +628,24 @@ static inline netdev_features_t vlan_features_check(const struct sk_buff *skb,
         return features;
 }
 
+/**
+ * compare_vlan_header - Compare two vlan headers
+ * @h1: Pointer to vlan header
+ * @h2: Pointer to vlan header
+ *
+ * Compare two vlan headers, returns 0 if equal.
+ *
+ * Please note that alignment of h1 & h2 are only guaranteed to be 16 bits.
+ */
+static inline unsigned long compare_vlan_header(const struct vlan_hdr *h1,
+                                                const struct vlan_hdr *h2)
+{
+#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
+        return *(u32 *)h1 ^ *(u32 *)h2;
+#else
+        return ((__force u32)h1->h_vlan_TCI ^ (__force u32)h2->h_vlan_TCI) |
+               ((__force u32)h1->h_vlan_encapsulated_proto ^
+                (__force u32)h2->h_vlan_encapsulated_proto);
+#endif
+}
 #endif /* !(_LINUX_IF_VLAN_H_) */
diff --git a/include/linux/igmp.h b/include/linux/igmp.h
index 2c677afeea47..193ad488d3e2 100644
--- a/include/linux/igmp.h
+++ b/include/linux/igmp.h
@@ -130,5 +130,6 @@ extern void ip_mc_unmap(struct in_device *);
 extern void ip_mc_remap(struct in_device *);
 extern void ip_mc_dec_group(struct in_device *in_dev, __be32 addr);
 extern void ip_mc_inc_group(struct in_device *in_dev, __be32 addr);
+int ip_mc_check_igmp(struct sk_buff *skb, struct sk_buff **skb_trimmed);
 
 #endif
diff --git a/include/linux/iio/buffer.h b/include/linux/iio/buffer.h
index eb8622b78ec9..1600c55828e0 100644
--- a/include/linux/iio/buffer.h
+++ b/include/linux/iio/buffer.h
@@ -29,6 +29,7 @@ struct iio_buffer;
  * @set_length:         set number of datums in buffer
  * @release:            called when the last reference to the buffer is dropped,
  *                      should free all resources allocated by the buffer.
+ * @modes:              Supported operating modes by this buffer type
  *
  * The purpose of this structure is to make the buffer element
  * modular as event for a given driver, different usecases may require
@@ -51,6 +52,8 @@ struct iio_buffer_access_funcs {
         int (*set_length)(struct iio_buffer *buffer, int length);
 
         void (*release)(struct iio_buffer *buffer);
+
+        unsigned int modes;
 };
 
 /**
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index d86b753e9b30..f79148261d16 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -32,6 +32,7 @@ enum iio_chan_info_enum {
         IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW,
         IIO_CHAN_INFO_AVERAGE_RAW,
         IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY,
+        IIO_CHAN_INFO_HIGH_PASS_FILTER_3DB_FREQUENCY,
         IIO_CHAN_INFO_SAMP_FREQ,
         IIO_CHAN_INFO_FREQUENCY,
         IIO_CHAN_INFO_PHASE,
@@ -43,6 +44,8 @@ enum iio_chan_info_enum {
         IIO_CHAN_INFO_CALIBWEIGHT,
         IIO_CHAN_INFO_DEBOUNCE_COUNT,
         IIO_CHAN_INFO_DEBOUNCE_TIME,
+        IIO_CHAN_INFO_CALIBEMISSIVITY,
+        IIO_CHAN_INFO_OVERSAMPLING_RATIO,
 };
 
 enum iio_shared_by {
diff --git a/include/linux/iio/types.h b/include/linux/iio/types.h
index 942b6de68e2f..32b579525004 100644
--- a/include/linux/iio/types.h
+++ b/include/linux/iio/types.h
@@ -17,6 +17,8 @@ enum iio_event_info {
         IIO_EV_INFO_VALUE,
         IIO_EV_INFO_HYSTERESIS,
         IIO_EV_INFO_PERIOD,
+        IIO_EV_INFO_HIGH_PASS_FILTER_3DB,
+        IIO_EV_INFO_LOW_PASS_FILTER_3DB,
 };
 
 #define IIO_VAL_INT 1
diff --git a/include/linux/inet_diag.h b/include/linux/inet_diag.h
index ac48b10c9395..0e707f0c1a3e 100644
--- a/include/linux/inet_diag.h
+++ b/include/linux/inet_diag.h
@@ -24,6 +24,7 @@ struct inet_diag_handler {
                                           struct inet_diag_msg *r,
                                           void *info);
         __u16           idiag_type;
+        __u16           idiag_info_size;
 };
 
 struct inet_connection_sock;
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 0a21fbefdfbe..a4328cea376a 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -120,6 +120,9 @@ static inline void ipv4_devconf_setall(struct in_device *in_dev)
          || (!IN_DEV_FORWARD(in_dev) && \
           IN_DEV_ORCONF((in_dev), ACCEPT_REDIRECTS)))
 
+#define IN_DEV_IGNORE_ROUTES_WITH_LINKDOWN(in_dev) \
+        IN_DEV_CONF_GET((in_dev), IGNORE_ROUTES_WITH_LINKDOWN)
+
 #define IN_DEV_ARPFILTER(in_dev)        IN_DEV_ORCONF((in_dev), ARPFILTER)
 #define IN_DEV_ARP_ACCEPT(in_dev)       IN_DEV_ORCONF((in_dev), ARP_ACCEPT)
 #define IN_DEV_ARP_ANNOUNCE(in_dev)     IN_DEV_MAXCONF((in_dev), ARP_ANNOUNCE)
diff --git a/include/linux/init.h b/include/linux/init.h
index 21b6d768edd7..b449f378f995 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -91,14 +91,6 @@
 
 #define __exit          __section(.exit.text) __exitused __cold notrace
 
-/* temporary, until all users are removed */
-#define __cpuinit
-#define __cpuinitdata
-#define __cpuinitconst
-#define __cpuexit
-#define __cpuexitdata
-#define __cpuexitconst
-
 /* Used for MEMORY_HOTPLUG */
 #define __meminit        __section(.meminit.text) __cold notrace
 #define __meminitdata    __section(.meminit.data)
@@ -116,9 +108,6 @@
 #define __INITRODATA    .section        ".init.rodata","a",%progbits
 #define __FINITDATA     .previous
 
-/* temporary, until all users are removed */
-#define __CPUINIT
-
 #define __MEMINIT        .section       ".meminit.text", "ax"
 #define __MEMINITDATA    .section       ".meminit.data", "aw"
 #define __MEMINITRODATA  .section       ".meminit.rodata", "a"
@@ -293,68 +282,8 @@ void __init parse_early_param(void);
 void __init parse_early_options(char *cmdline);
 #endif /* __ASSEMBLY__ */
 
-/**
- * module_init() - driver initialization entry point
- * @x: function to be run at kernel boot time or module insertion
- * 
- * module_init() will either be called during do_initcalls() (if
- * builtin) or at module insertion time (if a module).  There can only
- * be one per module.
- */
-#define module_init(x)  __initcall(x);
-
-/**
- * module_exit() - driver exit entry point
- * @x: function to be run when driver is removed
- * 
- * module_exit() will wrap the driver clean-up code
- * with cleanup_module() when used with rmmod when
- * the driver is a module.  If the driver is statically
- * compiled into the kernel, module_exit() has no effect.
- * There can only be one per module.
- */
-#define module_exit(x)  __exitcall(x);
-
 #else /* MODULE */
 
-/*
- * In most cases loadable modules do not need custom
- * initcall levels. There are still some valid cases where
- * a driver may be needed early if built in, and does not
- * matter when built as a loadable module. Like bus
- * snooping debug drivers.
- */
-#define early_initcall(fn)              module_init(fn)
-#define core_initcall(fn)               module_init(fn)
-#define core_initcall_sync(fn)          module_init(fn)
-#define postcore_initcall(fn)           module_init(fn)
-#define postcore_initcall_sync(fn)      module_init(fn)
-#define arch_initcall(fn)               module_init(fn)
-#define subsys_initcall(fn)             module_init(fn)
-#define subsys_initcall_sync(fn)        module_init(fn)
-#define fs_initcall(fn)                 module_init(fn)
-#define fs_initcall_sync(fn)            module_init(fn)
-#define rootfs_initcall(fn)             module_init(fn)
-#define device_initcall(fn)             module_init(fn)
-#define device_initcall_sync(fn)        module_init(fn)
-#define late_initcall(fn)               module_init(fn)
-#define late_initcall_sync(fn)          module_init(fn)
-
-#define console_initcall(fn)            module_init(fn)
-#define security_initcall(fn)           module_init(fn)
-
-/* Each module must use one module_init(). */
-#define module_init(initfn)                                     \
-        static inline initcall_t __inittest(void)               \
-        { return initfn; }                                      \
-        int init_module(void) __attribute__((alias(#initfn)));
-
-/* This is only required if you want to be unloadable. */
-#define module_exit(exitfn)                                     \
-        static inline exitcall_t __exittest(void)               \
-        { return exitfn; }                                      \
-        void cleanup_module(void) __attribute__((alias(#exitfn)));
-
 #define __setup_param(str, unique_id, fn)       /* nothing */
 #define __setup(str, func)                      /* nothing */
 #endif
@@ -362,24 +291,6 @@ void __init parse_early_options(char *cmdline);
 /* Data marked not to be saved by software suspend */
 #define __nosavedata __section(.data..nosave)
 
-/* This means "can be init if no module support, otherwise module load
-   may call it." */
-#ifdef CONFIG_MODULES
-#define __init_or_module
-#define __initdata_or_module
-#define __initconst_or_module
-#define __INIT_OR_MODULE        .text
-#define __INITDATA_OR_MODULE    .data
-#define __INITRODATA_OR_MODULE  .section ".rodata","a",%progbits
-#else
-#define __init_or_module __init
-#define __initdata_or_module __initdata
-#define __initconst_or_module __initconst
-#define __INIT_OR_MODULE __INIT
-#define __INITDATA_OR_MODULE __INITDATA
-#define __INITRODATA_OR_MODULE __INITRODATA
-#endif /*CONFIG_MODULES*/
-
 #ifdef MODULE
 #define __exit_p(x) x
 #else
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index bb9b075f0eb0..e8493fee8160 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -25,13 +25,6 @@
 extern struct files_struct init_files;
 extern struct fs_struct init_fs;
 
-#ifdef CONFIG_CGROUPS
-#define INIT_GROUP_RWSEM(sig)                                           \
-        .group_rwsem = __RWSEM_INITIALIZER(sig.group_rwsem),
-#else
-#define INIT_GROUP_RWSEM(sig)
-#endif
-
 #ifdef CONFIG_CPUSETS
 #define INIT_CPUSET_SEQ(tsk)                                                    \
         .mems_allowed_seq = SEQCNT_ZERO(tsk.mems_allowed_seq),
@@ -55,7 +48,6 @@ extern struct fs_struct init_fs;
         },                                                              \
         .cred_guard_mutex =                                             \
                  __MUTEX_INITIALIZER(sig.cred_guard_mutex),             \
-        INIT_GROUP_RWSEM(sig)                                           \
 }
 
 extern struct nsproxy init_nsproxy;
diff --git a/include/linux/input/touchscreen.h b/include/linux/input/touchscreen.h
index 08a5ef6e8f25..eecc9ea6cd58 100644
--- a/include/linux/input/touchscreen.h
+++ b/include/linux/input/touchscreen.h
@@ -12,9 +12,10 @@
 #include <linux/input.h>
 
 #ifdef CONFIG_OF
-void touchscreen_parse_of_params(struct input_dev *dev);
+void touchscreen_parse_of_params(struct input_dev *dev, bool multitouch);
 #else
-static inline void touchscreen_parse_of_params(struct input_dev *dev)
+static inline void touchscreen_parse_of_params(struct input_dev *dev,
+                                               bool multitouch)
 {
 }
 #endif
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index 3665cb331ca1..d9a366d24e3b 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -297,6 +297,7 @@ struct q_inval {
 /* 1MB - maximum possible interrupt remapping table size */
 #define INTR_REMAP_PAGE_ORDER   8
 #define INTR_REMAP_TABLE_REG_SIZE       0xf
+#define INTR_REMAP_TABLE_REG_SIZE_MASK  0xf
 
 #define INTR_REMAP_TABLE_ENTRIES        65536
 
@@ -323,6 +324,9 @@ enum {
         MAX_SR_DMAR_REGS
 };
 
+#define VTD_FLAG_TRANS_PRE_ENABLED      (1 << 0)
+#define VTD_FLAG_IRQ_REMAP_PRE_ENABLED  (1 << 1)
+
 struct intel_iommu {
         void __iomem    *reg; /* Pointer to hardware regs, virtual addr */
         u64             reg_phys; /* physical address of hw register set */
@@ -356,6 +360,7 @@ struct intel_iommu {
 #endif
         struct device   *iommu_dev; /* IOMMU-sysfs device */
         int             node;
+        u32             flags;      /* Software defined flags */
 };
 
 static inline void __iommu_flush_cache(
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 0546b8710ce3..f9c1b6d0f2e4 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -114,6 +114,20 @@ enum iommu_attr {
         DOMAIN_ATTR_MAX,
 };
 
+/**
+ * struct iommu_dm_region - descriptor for a direct mapped memory region
+ * @list: Linked list pointers
+ * @start: System physical start address of the region
+ * @length: Length of the region in bytes
+ * @prot: IOMMU Protection flags (READ/WRITE/...)
+ */
+struct iommu_dm_region {
+        struct list_head        list;
+        phys_addr_t             start;
+        size_t                  length;
+        int                     prot;
+};
+
 #ifdef CONFIG_IOMMU_API
 
 /**
@@ -159,6 +173,10 @@ struct iommu_ops {
         int (*domain_set_attr)(struct iommu_domain *domain,
                                enum iommu_attr attr, void *data);
 
+        /* Request/Free a list of direct mapping requirements for a device */
+        void (*get_dm_regions)(struct device *dev, struct list_head *list);
+        void (*put_dm_regions)(struct device *dev, struct list_head *list);
+
         /* Window handling functions */
         int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
                                     phys_addr_t paddr, u64 size, int prot);
@@ -193,6 +211,7 @@ extern int iommu_attach_device(struct iommu_domain *domain,
                                struct device *dev);
 extern void iommu_detach_device(struct iommu_domain *domain,
                                 struct device *dev);
+extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
 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,
@@ -204,6 +223,10 @@ extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t io
 extern void iommu_set_fault_handler(struct iommu_domain *domain,
                         iommu_fault_handler_t handler, void *token);
 
+extern void iommu_get_dm_regions(struct device *dev, struct list_head *list);
+extern void iommu_put_dm_regions(struct device *dev, struct list_head *list);
+extern int iommu_request_dm_for_dev(struct device *dev);
+
 extern int iommu_attach_group(struct iommu_domain *domain,
                               struct iommu_group *group);
 extern void iommu_detach_group(struct iommu_domain *domain,
@@ -227,6 +250,7 @@ extern int iommu_group_unregister_notifier(struct iommu_group *group,
                                            struct notifier_block *nb);
 extern int iommu_group_id(struct iommu_group *group);
 extern struct iommu_group *iommu_group_get_for_dev(struct device *dev);
+extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
 
 extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
                                  void *data);
@@ -234,7 +258,7 @@ extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
                                  void *data);
 struct device *iommu_device_create(struct device *parent, void *drvdata,
                                    const struct attribute_group **groups,
-                                   const char *fmt, ...);
+                                   const char *fmt, ...) __printf(4, 5);
 void iommu_device_destroy(struct device *dev);
 int iommu_device_link(struct device *dev, struct device *link);
 void iommu_device_unlink(struct device *dev, struct device *link);
@@ -332,6 +356,11 @@ static inline void iommu_detach_device(struct iommu_domain *domain,
 {
 }
 
+static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
+{
+        return NULL;
+}
+
 static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
                             phys_addr_t paddr, int gfp_order, int prot)
 {
@@ -373,6 +402,21 @@ static inline void iommu_set_fault_handler(struct iommu_domain *domain,
 {
 }
 
+static inline void iommu_get_dm_regions(struct device *dev,
+                                        struct list_head *list)
+{
+}
+
+static inline void iommu_put_dm_regions(struct device *dev,
+                                        struct list_head *list)
+{
+}
+
+static inline int iommu_request_dm_for_dev(struct device *dev)
+{
+        return -ENODEV;
+}
+
 static inline int iommu_attach_group(struct iommu_domain *domain,
                                      struct iommu_group *group)
 {
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 812149160d3b..92188b0225bb 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -407,7 +407,6 @@ enum {
         IRQCHIP_EOI_THREADED            = (1 <<  6),
 };
 
-/* This include will go away once we isolated irq_desc usage to core code */
 #include <linux/irqdesc.h>
 
 /*
diff --git a/include/linux/irqchip.h b/include/linux/irqchip.h
index 14d79131f53d..638887376e58 100644
--- a/include/linux/irqchip.h
+++ b/include/linux/irqchip.h
@@ -11,6 +11,20 @@
 #ifndef _LINUX_IRQCHIP_H
 #define _LINUX_IRQCHIP_H
 
+#include <linux/of.h>
+
+/*
+ * This macro must be used by the different irqchip drivers to declare
+ * the association between their DT compatible string and their
+ * initialization function.
+ *
+ * @name: name that must be unique accross all IRQCHIP_DECLARE of the
+ * same file.
+ * @compstr: compatible string of the irqchip driver
+ * @fn: initialization function
+ */
+#define IRQCHIP_DECLARE(name, compat, fn) OF_DECLARE_2(irqchip, name, compat, fn)
+
 #ifdef CONFIG_IRQCHIP
 void irqchip_init(void);
 #else
diff --git a/include/linux/irqchip/ingenic.h b/include/linux/irqchip/ingenic.h
new file mode 100644
index 000000000000..0ee319a4029d
--- /dev/null
+++ b/include/linux/irqchip/ingenic.h
@@ -0,0 +1,23 @@
+/*
+ *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under  the terms of the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the License, or (at your
+ *  option) any later version.
+ *
+ *  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.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef __LINUX_IRQCHIP_INGENIC_H__
+#define __LINUX_IRQCHIP_INGENIC_H__
+
+#include <linux/irq.h>
+
+extern void ingenic_intc_irq_suspend(struct irq_data *data);
+extern void ingenic_intc_irq_resume(struct irq_data *data);
+
+#endif
diff --git a/include/linux/irqchip/irq-sa11x0.h b/include/linux/irqchip/irq-sa11x0.h
new file mode 100644
index 000000000000..15db6829c1e4
--- /dev/null
+++ b/include/linux/irqchip/irq-sa11x0.h
@@ -0,0 +1,17 @@
+/*
+ * Generic IRQ handling for the SA11x0.
+ *
+ * Copyright (C) 2015 Dmitry Eremin-Solenikov
+ * Copyright (C) 1999-2001 Nicolas Pitre
+ *
+ * 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 __INCLUDE_LINUX_IRQCHIP_IRQ_SA11x0_H
+#define __INCLUDE_LINUX_IRQCHIP_IRQ_SA11x0_H
+
+void __init sa11x0_init_irq_nodt(int irq_start, resource_size_t io_start);
+
+#endif
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index c52d1480f272..fcea4e48e21f 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -3,9 +3,6 @@
 
 /*
  * Core internal functions to deal with irq descriptors
- *
- * This include will move to kernel/irq once we cleaned up the tree.
- * For now it's included from <linux/irq.h>
  */
 
 struct irq_affinity_notify;
@@ -90,7 +87,12 @@ struct irq_desc {
         const char              *name;
 } ____cacheline_internodealigned_in_smp;
 
-#ifndef CONFIG_SPARSE_IRQ
+#ifdef CONFIG_SPARSE_IRQ
+extern void irq_lock_sparse(void);
+extern void irq_unlock_sparse(void);
+#else
+static inline void irq_lock_sparse(void) { }
+static inline void irq_unlock_sparse(void) { }
 extern struct irq_desc irq_desc[NR_IRQS];
 #endif
 
@@ -103,6 +105,11 @@ static inline struct irq_desc *irq_data_to_desc(struct irq_data *data)
 #endif
 }
 
+static inline unsigned int irq_desc_get_irq(struct irq_desc *desc)
+{
+        return desc->irq_data.irq;
+}
+
 static inline struct irq_data *irq_desc_get_irq_data(struct irq_desc *desc)
 {
         return &desc->irq_data;
@@ -188,6 +195,47 @@ __irq_set_chip_handler_name_locked(unsigned int irq, struct irq_chip *chip,
         desc->name = name;
 }
 
+/**
+ * irq_set_handler_locked - Set irq handler from a locked region
+ * @data:       Pointer to the irq_data structure which identifies the irq
+ * @handler:    Flow control handler function for this interrupt
+ *
+ * Sets the handler in the irq descriptor associated to @data.
+ *
+ * Must be called with irq_desc locked and valid parameters. Typical
+ * call site is the irq_set_type() callback.
+ */
+static inline void irq_set_handler_locked(struct irq_data *data,
+                                          irq_flow_handler_t handler)
+{
+        struct irq_desc *desc = irq_data_to_desc(data);
+
+        desc->handle_irq = handler;
+}
+
+/**
+ * irq_set_chip_handler_name_locked - Set chip, handler and name from a locked region
+ * @data:       Pointer to the irq_data structure for which the chip is set
+ * @chip:       Pointer to the new irq chip
+ * @handler:    Flow control handler function for this interrupt
+ * @name:       Name of the interrupt
+ *
+ * Replace the irq chip at the proper hierarchy level in @data and
+ * sets the handler and name in the associated irq descriptor.
+ *
+ * Must be called with irq_desc locked and valid parameters.
+ */
+static inline void
+irq_set_chip_handler_name_locked(struct irq_data *data, struct irq_chip *chip,
+                                 irq_flow_handler_t handler, const char *name)
+{
+        struct irq_desc *desc = irq_data_to_desc(data);
+
+        desc->handle_irq = handler;
+        desc->name = name;
+        data->chip = chip;
+}
+
 static inline int irq_balancing_disabled(unsigned int irq)
 {
         struct irq_desc *desc;
diff --git a/include/linux/irqnr.h b/include/linux/irqnr.h
index fdd5cc16c9c4..9669bf9d4f48 100644
--- a/include/linux/irqnr.h
+++ b/include/linux/irqnr.h
@@ -23,12 +23,6 @@ unsigned int irq_get_next_irq(unsigned int offset);
                         ;                                               \
                 else
 
-#ifdef CONFIG_SMP
-#define irq_node(irq)   (irq_get_irq_data(irq)->node)
-#else
-#define irq_node(irq)   0
-#endif
-
 # define for_each_active_irq(irq)                       \
         for (irq = irq_get_next_irq(0); irq < nr_irqs;  \
              irq = irq_get_next_irq(irq + 1))
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 20e7f78041c8..edb640ae9a94 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1035,7 +1035,7 @@ struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal);
 int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
                               unsigned long *block);
-void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
+int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
 void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
 
 /* Commit management */
@@ -1157,7 +1157,7 @@ extern int	   jbd2_journal_recover    (journal_t *journal);
 extern int         jbd2_journal_wipe       (journal_t *, int);
 extern int         jbd2_journal_skip_recovery   (journal_t *);
 extern void        jbd2_journal_update_sb_errno(journal_t *);
-extern void        jbd2_journal_update_sb_log_tail      (journal_t *, tid_t,
+extern int         jbd2_journal_update_sb_log_tail      (journal_t *, tid_t,
                                 unsigned long, int);
 extern void        __jbd2_journal_abort_hard    (journal_t *);
 extern void        jbd2_journal_abort      (journal_t *, int);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 060dd7b61c6d..5582410727cb 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -411,7 +411,8 @@ extern __printf(3, 0)
 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
 extern __printf(2, 3)
 char *kasprintf(gfp_t gfp, const char *fmt, ...);
-extern char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
+extern __printf(2, 0)
+char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
 
 extern __scanf(2, 3)
 int sscanf(const char *, const char *, ...);
@@ -439,6 +440,9 @@ extern int panic_on_unrecovered_nmi;
 extern int panic_on_io_nmi;
 extern int panic_on_warn;
 extern int sysctl_panic_on_stackoverflow;
+
+extern bool crash_kexec_post_notifiers;
+
 /*
  * Only to be used by arch init code. If the user over-wrote the default
  * CONFIG_PANIC_TIMEOUT, honor it.
@@ -533,12 +537,6 @@ bool mac_pton(const char *s, u8 *mac);
  *
  * Most likely, you want to use tracing_on/tracing_off.
  */
-#ifdef CONFIG_RING_BUFFER
-/* trace_off_permanent stops recording with no way to bring it back */
-void tracing_off_permanent(void);
-#else
-static inline void tracing_off_permanent(void) { }
-#endif
 
 enum ftrace_dump_mode {
         DUMP_NONE,
@@ -682,10 +680,10 @@ do {									\
                 __ftrace_vprintk(_THIS_IP_, fmt, vargs);                \
 } while (0)
 
-extern int
+extern __printf(2, 0) int
 __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
 
-extern int
+extern __printf(2, 0) int
 __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 
 extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
@@ -705,7 +703,7 @@ int trace_printk(const char *fmt, ...)
 {
         return 0;
 }
-static inline int
+static __printf(1, 0) inline int
 ftrace_vprintk(const char *fmt, va_list ap)
 {
         return 0;
@@ -819,13 +817,15 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
 #endif
 
 /* Permissions on a sysfs file: you didn't miss the 0 prefix did you? */
-#define VERIFY_OCTAL_PERMISSIONS(perms)                                 \
-        (BUILD_BUG_ON_ZERO((perms) < 0) +                               \
-         BUILD_BUG_ON_ZERO((perms) > 0777) +                            \
-         /* User perms >= group perms >= other perms */                 \
-         BUILD_BUG_ON_ZERO(((perms) >> 6) < (((perms) >> 3) & 7)) +     \
-         BUILD_BUG_ON_ZERO((((perms) >> 3) & 7) < ((perms) & 7)) +      \
-         /* Other writable?  Generally considered a bad idea. */        \
-         BUILD_BUG_ON_ZERO((perms) & 2) +                               \
+#define VERIFY_OCTAL_PERMISSIONS(perms)                                         \
+        (BUILD_BUG_ON_ZERO((perms) < 0) +                                       \
+         BUILD_BUG_ON_ZERO((perms) > 0777) +                                    \
+         /* USER_READABLE >= GROUP_READABLE >= OTHER_READABLE */                \
+         BUILD_BUG_ON_ZERO((((perms) >> 6) & 4) < (((perms) >> 3) & 4)) +       \
+         BUILD_BUG_ON_ZERO((((perms) >> 3) & 4) < ((perms) & 4)) +              \
+         /* USER_WRITABLE >= GROUP_WRITABLE */                                  \
+         BUILD_BUG_ON_ZERO((((perms) >> 6) & 2) < (((perms) >> 3) & 2)) +       \
+         /* OTHER_WRITABLE?  Generally considered a bad idea. */                \
+         BUILD_BUG_ON_ZERO((perms) & 2) +                                       \
          (perms))
 #endif
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index 71ecdab1671b..123be25ea15a 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -45,6 +45,7 @@ enum kernfs_node_flag {
         KERNFS_LOCKDEP          = 0x0100,
         KERNFS_SUICIDAL         = 0x0400,
         KERNFS_SUICIDED         = 0x0800,
+        KERNFS_EMPTY_DIR        = 0x1000,
 };
 
 /* @flags for kernfs_create_root() */
@@ -277,6 +278,7 @@ void kernfs_put(struct kernfs_node *kn);
 
 struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
 struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
+struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
 
 struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
                                        unsigned int flags, void *priv);
@@ -285,6 +287,8 @@ void kernfs_destroy_root(struct kernfs_root *root);
 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
                                          const char *name, umode_t mode,
                                          void *priv, const void *ns);
+struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
+                                            const char *name);
 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
                                          const char *name,
                                          umode_t mode, loff_t size,
@@ -352,6 +356,10 @@ static inline struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry)
 static inline struct kernfs_root *kernfs_root_from_sb(struct super_block *sb)
 { return NULL; }
 
+static inline struct inode *
+kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn)
+{ return NULL; }
+
 static inline struct kernfs_root *
 kernfs_create_root(struct kernfs_syscall_ops *scops, unsigned int flags,
                    void *priv)
diff --git a/include/linux/kmemleak.h b/include/linux/kmemleak.h
index e705467ddb47..d0a1f99e24e3 100644
--- a/include/linux/kmemleak.h
+++ b/include/linux/kmemleak.h
@@ -28,7 +28,8 @@
 extern void kmemleak_init(void) __ref;
 extern void kmemleak_alloc(const void *ptr, size_t size, int min_count,
                            gfp_t gfp) __ref;
-extern void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size) __ref;
+extern void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size,
+                                  gfp_t gfp) __ref;
 extern void kmemleak_free(const void *ptr) __ref;
 extern void kmemleak_free_part(const void *ptr, size_t size) __ref;
 extern void kmemleak_free_percpu(const void __percpu *ptr) __ref;
@@ -71,7 +72,8 @@ static inline void kmemleak_alloc_recursive(const void *ptr, size_t size,
                                             gfp_t gfp)
 {
 }
-static inline void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size)
+static inline void kmemleak_alloc_percpu(const void __percpu *ptr, size_t size,
+                                         gfp_t gfp)
 {
 }
 static inline void kmemleak_free(const void *ptr)
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 2d61b909f414..637f67002c5a 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -80,8 +80,9 @@ struct kobject {
 
 extern __printf(2, 3)
 int kobject_set_name(struct kobject *kobj, const char *name, ...);
-extern int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
-                                  va_list vargs);
+extern __printf(2, 0)
+int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
+                           va_list vargs);
 
 static inline const char *kobject_name(const struct kobject *kobj)
 {
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index ad45054309a0..05e99b8ef465 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -44,6 +44,10 @@
 /* Two fragments for cross MMIO pages. */
 #define KVM_MAX_MMIO_FRAGMENTS  2
 
+#ifndef KVM_ADDRESS_SPACE_NUM
+#define KVM_ADDRESS_SPACE_NUM   1
+#endif
+
 /*
  * For the normal pfn, the highest 12 bits should be zero,
  * so we can mask bit 62 ~ bit 52  to indicate the error pfn,
@@ -134,6 +138,7 @@ static inline bool is_error_page(struct page *page)
 #define KVM_REQ_ENABLE_IBS        23
 #define KVM_REQ_DISABLE_IBS       24
 #define KVM_REQ_APIC_PAGE_RELOAD  25
+#define KVM_REQ_SMI               26
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID             0
 #define KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID        1
@@ -230,6 +235,7 @@ struct kvm_vcpu {
 
         int fpu_active;
         int guest_fpu_loaded, guest_xcr0_loaded;
+        unsigned char fpu_counter;
         wait_queue_head_t wq;
         struct pid *pid;
         int sigset_active;
@@ -329,6 +335,13 @@ struct kvm_kernel_irq_routing_entry {
 #define KVM_MEM_SLOTS_NUM (KVM_USER_MEM_SLOTS + KVM_PRIVATE_MEM_SLOTS)
 #endif
 
+#ifndef __KVM_VCPU_MULTIPLE_ADDRESS_SPACE
+static inline int kvm_arch_vcpu_memslots_id(struct kvm_vcpu *vcpu)
+{
+        return 0;
+}
+#endif
+
 /*
  * Note:
  * memslots are not sorted by id anymore, please use id_to_memslot()
@@ -347,7 +360,7 @@ struct kvm {
         spinlock_t mmu_lock;
         struct mutex slots_lock;
         struct mm_struct *mm; /* userspace tied to this vm */
-        struct kvm_memslots *memslots;
+        struct kvm_memslots *memslots[KVM_ADDRESS_SPACE_NUM];
         struct srcu_struct srcu;
         struct srcu_struct irq_srcu;
 #ifdef CONFIG_KVM_APIC_ARCHITECTURE
@@ -462,13 +475,25 @@ void kvm_exit(void);
 void kvm_get_kvm(struct kvm *kvm);
 void kvm_put_kvm(struct kvm *kvm);
 
-static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
+static inline struct kvm_memslots *__kvm_memslots(struct kvm *kvm, int as_id)
 {
-        return rcu_dereference_check(kvm->memslots,
+        return rcu_dereference_check(kvm->memslots[as_id],
                         srcu_read_lock_held(&kvm->srcu)
                         || lockdep_is_held(&kvm->slots_lock));
 }
 
+static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
+{
+        return __kvm_memslots(kvm, 0);
+}
+
+static inline struct kvm_memslots *kvm_vcpu_memslots(struct kvm_vcpu *vcpu)
+{
+        int as_id = kvm_arch_vcpu_memslots_id(vcpu);
+
+        return __kvm_memslots(vcpu->kvm, as_id);
+}
+
 static inline struct kvm_memory_slot *
 id_to_memslot(struct kvm_memslots *slots, int id)
 {
@@ -500,21 +525,22 @@ enum kvm_mr_change {
 };
 
 int kvm_set_memory_region(struct kvm *kvm,
-                          struct kvm_userspace_memory_region *mem);
+                          const struct kvm_userspace_memory_region *mem);
 int __kvm_set_memory_region(struct kvm *kvm,
-                            struct kvm_userspace_memory_region *mem);
+                            const struct kvm_userspace_memory_region *mem);
 void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
                            struct kvm_memory_slot *dont);
 int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
                             unsigned long npages);
-void kvm_arch_memslots_updated(struct kvm *kvm);
+void kvm_arch_memslots_updated(struct kvm *kvm, struct kvm_memslots *slots);
 int kvm_arch_prepare_memory_region(struct kvm *kvm,
                                 struct kvm_memory_slot *memslot,
-                                struct kvm_userspace_memory_region *mem,
+                                const struct kvm_userspace_memory_region *mem,
                                 enum kvm_mr_change change);
 void kvm_arch_commit_memory_region(struct kvm *kvm,
-                                struct kvm_userspace_memory_region *mem,
+                                const struct kvm_userspace_memory_region *mem,
                                 const struct kvm_memory_slot *old,
+                                const struct kvm_memory_slot *new,
                                 enum kvm_mr_change change);
 bool kvm_largepages_enabled(void);
 void kvm_disable_largepages(void);
@@ -524,8 +550,8 @@ void kvm_arch_flush_shadow_all(struct kvm *kvm);
 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
                                    struct kvm_memory_slot *slot);
 
-int gfn_to_page_many_atomic(struct kvm *kvm, gfn_t gfn, struct page **pages,
-                            int nr_pages);
+int gfn_to_page_many_atomic(struct kvm_memory_slot *slot, gfn_t gfn,
+                            struct page **pages, int nr_pages);
 
 struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
 unsigned long gfn_to_hva(struct kvm *kvm, gfn_t gfn);
@@ -538,13 +564,13 @@ void kvm_release_page_dirty(struct page *page);
 void kvm_set_page_accessed(struct page *page);
 
 pfn_t gfn_to_pfn_atomic(struct kvm *kvm, gfn_t gfn);
-pfn_t gfn_to_pfn_async(struct kvm *kvm, gfn_t gfn, bool *async,
-                       bool write_fault, bool *writable);
 pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
 pfn_t gfn_to_pfn_prot(struct kvm *kvm, gfn_t gfn, bool write_fault,
                       bool *writable);
 pfn_t gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn);
 pfn_t gfn_to_pfn_memslot_atomic(struct kvm_memory_slot *slot, gfn_t gfn);
+pfn_t __gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn, bool atomic,
+                           bool *async, bool write_fault, bool *writable);
 
 void kvm_release_pfn_clean(pfn_t pfn);
 void kvm_set_pfn_dirty(pfn_t pfn);
@@ -573,6 +599,25 @@ int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
 unsigned long kvm_host_page_size(struct kvm *kvm, gfn_t gfn);
 void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
 
+struct kvm_memslots *kvm_vcpu_memslots(struct kvm_vcpu *vcpu);
+struct kvm_memory_slot *kvm_vcpu_gfn_to_memslot(struct kvm_vcpu *vcpu, gfn_t gfn);
+pfn_t kvm_vcpu_gfn_to_pfn_atomic(struct kvm_vcpu *vcpu, gfn_t gfn);
+pfn_t kvm_vcpu_gfn_to_pfn(struct kvm_vcpu *vcpu, gfn_t gfn);
+struct page *kvm_vcpu_gfn_to_page(struct kvm_vcpu *vcpu, gfn_t gfn);
+unsigned long kvm_vcpu_gfn_to_hva(struct kvm_vcpu *vcpu, gfn_t gfn);
+unsigned long kvm_vcpu_gfn_to_hva_prot(struct kvm_vcpu *vcpu, gfn_t gfn, bool *writable);
+int kvm_vcpu_read_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, void *data, int offset,
+                             int len);
+int kvm_vcpu_read_guest_atomic(struct kvm_vcpu *vcpu, gpa_t gpa, void *data,
+                               unsigned long len);
+int kvm_vcpu_read_guest(struct kvm_vcpu *vcpu, gpa_t gpa, void *data,
+                        unsigned long len);
+int kvm_vcpu_write_guest_page(struct kvm_vcpu *vcpu, gfn_t gfn, const void *data,
+                              int offset, int len);
+int kvm_vcpu_write_guest(struct kvm_vcpu *vcpu, gpa_t gpa, const void *data,
+                         unsigned long len);
+void kvm_vcpu_mark_page_dirty(struct kvm_vcpu *vcpu, gfn_t gfn);
+
 void kvm_vcpu_block(struct kvm_vcpu *vcpu);
 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
 int kvm_vcpu_yield_to(struct kvm_vcpu *target);
@@ -689,6 +734,24 @@ static inline bool kvm_arch_has_noncoherent_dma(struct kvm *kvm)
         return false;
 }
 #endif
+#ifdef __KVM_HAVE_ARCH_ASSIGNED_DEVICE
+void kvm_arch_start_assignment(struct kvm *kvm);
+void kvm_arch_end_assignment(struct kvm *kvm);
+bool kvm_arch_has_assigned_device(struct kvm *kvm);
+#else
+static inline void kvm_arch_start_assignment(struct kvm *kvm)
+{
+}
+
+static inline void kvm_arch_end_assignment(struct kvm *kvm)
+{
+}
+
+static inline bool kvm_arch_has_assigned_device(struct kvm *kvm)
+{
+        return false;
+}
+#endif
 
 static inline wait_queue_head_t *kvm_arch_vcpu_wq(struct kvm_vcpu *vcpu)
 {
@@ -762,16 +825,10 @@ static inline void kvm_iommu_unmap_pages(struct kvm *kvm,
 }
 #endif
 
-static inline void kvm_guest_enter(void)
+/* must be called with irqs disabled */
+static inline void __kvm_guest_enter(void)
 {
-        unsigned long flags;
-
-        BUG_ON(preemptible());
-
-        local_irq_save(flags);
         guest_enter();
-        local_irq_restore(flags);
-
         /* KVM does not hold any references to rcu protected data when it
          * switches CPU into a guest mode. In fact switching to a guest mode
          * is very similar to exiting to userspace from rcu point of view. In
@@ -783,12 +840,27 @@ static inline void kvm_guest_enter(void)
                 rcu_virt_note_context_switch(smp_processor_id());
 }
 
+/* must be called with irqs disabled */
+static inline void __kvm_guest_exit(void)
+{
+        guest_exit();
+}
+
+static inline void kvm_guest_enter(void)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        __kvm_guest_enter();
+        local_irq_restore(flags);
+}
+
 static inline void kvm_guest_exit(void)
 {
         unsigned long flags;
 
         local_irq_save(flags);
-        guest_exit();
+        __kvm_guest_exit();
         local_irq_restore(flags);
 }
 
diff --git a/include/linux/kvm_types.h b/include/linux/kvm_types.h
index 931da7e917cf..1b47a185c2f0 100644
--- a/include/linux/kvm_types.h
+++ b/include/linux/kvm_types.h
@@ -28,6 +28,7 @@ struct kvm_run;
 struct kvm_userspace_memory_region;
 struct kvm_vcpu;
 struct kvm_vcpu_init;
+struct kvm_memslots;
 
 enum kvm_mr_change;
 
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 9a2b000094cf..b122eeafb5dc 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -12,6 +12,7 @@
 #ifndef __LINUX_LEDS_H_INCLUDED
 #define __LINUX_LEDS_H_INCLUDED
 
+#include <linux/device.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/rwsem.h>
@@ -222,6 +223,11 @@ struct led_trigger {
         struct list_head  next_trig;
 };
 
+ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count);
+ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
+                        char *buf);
+
 /* Registration functions for complex triggers */
 extern int led_trigger_register(struct led_trigger *trigger);
 extern void led_trigger_unregister(struct led_trigger *trigger);
@@ -238,6 +244,16 @@ extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
                                       unsigned long *delay_on,
                                       unsigned long *delay_off,
                                       int invert);
+extern void led_trigger_set_default(struct led_classdev *led_cdev);
+extern void led_trigger_set(struct led_classdev *led_cdev,
+                        struct led_trigger *trigger);
+extern void led_trigger_remove(struct led_classdev *led_cdev);
+
+static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
+{
+        return led_cdev->trigger_data;
+}
+
 /**
  * led_trigger_rename_static - rename a trigger
  * @name: the new trigger name
@@ -267,6 +283,15 @@ static inline void led_trigger_register_simple(const char *name,
 static inline void led_trigger_unregister_simple(struct led_trigger *trigger) {}
 static inline void led_trigger_event(struct led_trigger *trigger,
                                 enum led_brightness event) {}
+static inline void led_trigger_set_default(struct led_classdev *led_cdev) {}
+static inline void led_trigger_set(struct led_classdev *led_cdev,
+                                struct led_trigger *trigger) {}
+static inline void led_trigger_remove(struct led_classdev *led_cdev) {}
+static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
+{
+        return NULL;
+}
+
 #endif /* CONFIG_LEDS_TRIGGERS */
 
 /* Trigger specific functions */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 28aeae46f355..c9cfbcdb8d14 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -134,7 +134,6 @@ enum {
         ATA_ALL_DEVICES         = (1 << ATA_MAX_DEVICES) - 1,
 
         ATA_SHT_EMULATED        = 1,
-        ATA_SHT_CMD_PER_LUN     = 1,
         ATA_SHT_THIS_ID         = -1,
         ATA_SHT_USE_CLUSTERING  = 1,
 
@@ -431,6 +430,9 @@ enum {
         ATA_HORKAGE_NOLPM       = (1 << 20),    /* don't use LPM */
         ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21),  /* some WDs have broken LPM */
         ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
+        ATA_HORKAGE_NO_NCQ_LOG  = (1 << 23),    /* don't use NCQ for log read */
+        ATA_HORKAGE_NOTRIM      = (1 << 24),    /* don't use TRIM */
+        ATA_HORKAGE_MAX_SEC_1024 = (1 << 25),   /* Limit max sects to 1024 */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
@@ -1364,7 +1366,6 @@ extern struct device_attribute *ata_common_sdev_attrs[];
         .can_queue              = ATA_DEF_QUEUE,                \
         .tag_alloc_policy       = BLK_TAG_ALLOC_RR,             \
         .this_id                = ATA_SHT_THIS_ID,              \
-        .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,          \
         .emulated               = ATA_SHT_EMULATED,             \
         .use_clustering         = ATA_SHT_USE_CLUSTERING,       \
         .proc_name              = drv_name,                     \
diff --git a/include/linux/libfdt_env.h b/include/linux/libfdt_env.h
index 01508c7b8c81..2a663c6bb428 100644
--- a/include/linux/libfdt_env.h
+++ b/include/linux/libfdt_env.h
@@ -5,6 +5,10 @@
 
 #include <asm/byteorder.h>
 
+typedef __be16 fdt16_t;
+typedef __be32 fdt32_t;
+typedef __be64 fdt64_t;
+
 #define fdt32_to_cpu(x) be32_to_cpu(x)
 #define cpu_to_fdt32(x) cpu_to_be32(x)
 #define fdt64_to_cpu(x) be64_to_cpu(x)
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
new file mode 100644
index 000000000000..75e3af01ee32
--- /dev/null
+++ b/include/linux/libnvdimm.h
@@ -0,0 +1,151 @@
+/*
+ * libnvdimm - Non-volatile-memory Devices Subsystem
+ *
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * 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 __LIBNVDIMM_H__
+#define __LIBNVDIMM_H__
+#include <linux/kernel.h>
+#include <linux/sizes.h>
+#include <linux/types.h>
+
+enum {
+        /* when a dimm supports both PMEM and BLK access a label is required */
+        NDD_ALIASING = 1 << 0,
+        /* unarmed memory devices may not persist writes */
+        NDD_UNARMED = 1 << 1,
+
+        /* need to set a limit somewhere, but yes, this is likely overkill */
+        ND_IOCTL_MAX_BUFLEN = SZ_4M,
+        ND_CMD_MAX_ELEM = 4,
+        ND_CMD_MAX_ENVELOPE = 16,
+        ND_CMD_ARS_STATUS_MAX = SZ_4K,
+        ND_MAX_MAPPINGS = 32,
+
+        /* mark newly adjusted resources as requiring a label update */
+        DPA_RESOURCE_ADJUSTED = 1 << 0,
+};
+
+extern struct attribute_group nvdimm_bus_attribute_group;
+extern struct attribute_group nvdimm_attribute_group;
+extern struct attribute_group nd_device_attribute_group;
+extern struct attribute_group nd_numa_attribute_group;
+extern struct attribute_group nd_region_attribute_group;
+extern struct attribute_group nd_mapping_attribute_group;
+
+struct nvdimm;
+struct nvdimm_bus_descriptor;
+typedef int (*ndctl_fn)(struct nvdimm_bus_descriptor *nd_desc,
+                struct nvdimm *nvdimm, unsigned int cmd, void *buf,
+                unsigned int buf_len);
+
+struct nd_namespace_label;
+struct nvdimm_drvdata;
+struct nd_mapping {
+        struct nvdimm *nvdimm;
+        struct nd_namespace_label **labels;
+        u64 start;
+        u64 size;
+        /*
+         * @ndd is for private use at region enable / disable time for
+         * get_ndd() + put_ndd(), all other nd_mapping to ndd
+         * conversions use to_ndd() which respects enabled state of the
+         * nvdimm.
+         */
+        struct nvdimm_drvdata *ndd;
+};
+
+struct nvdimm_bus_descriptor {
+        const struct attribute_group **attr_groups;
+        unsigned long dsm_mask;
+        char *provider_name;
+        ndctl_fn ndctl;
+};
+
+struct nd_cmd_desc {
+        int in_num;
+        int out_num;
+        u32 in_sizes[ND_CMD_MAX_ELEM];
+        int out_sizes[ND_CMD_MAX_ELEM];
+};
+
+struct nd_interleave_set {
+        u64 cookie;
+};
+
+struct nd_region_desc {
+        struct resource *res;
+        struct nd_mapping *nd_mapping;
+        u16 num_mappings;
+        const struct attribute_group **attr_groups;
+        struct nd_interleave_set *nd_set;
+        void *provider_data;
+        int num_lanes;
+        int numa_node;
+};
+
+struct nvdimm_bus;
+struct module;
+struct device;
+struct nd_blk_region;
+struct nd_blk_region_desc {
+        int (*enable)(struct nvdimm_bus *nvdimm_bus, struct device *dev);
+        void (*disable)(struct nvdimm_bus *nvdimm_bus, struct device *dev);
+        int (*do_io)(struct nd_blk_region *ndbr, resource_size_t dpa,
+                        void *iobuf, u64 len, int rw);
+        struct nd_region_desc ndr_desc;
+};
+
+static inline struct nd_blk_region_desc *to_blk_region_desc(
+                struct nd_region_desc *ndr_desc)
+{
+        return container_of(ndr_desc, struct nd_blk_region_desc, ndr_desc);
+
+}
+
+struct nvdimm_bus *__nvdimm_bus_register(struct device *parent,
+                struct nvdimm_bus_descriptor *nfit_desc, struct module *module);
+#define nvdimm_bus_register(parent, desc) \
+        __nvdimm_bus_register(parent, desc, THIS_MODULE)
+void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus);
+struct nvdimm_bus *to_nvdimm_bus(struct device *dev);
+struct nvdimm *to_nvdimm(struct device *dev);
+struct nd_region *to_nd_region(struct device *dev);
+struct nd_blk_region *to_nd_blk_region(struct device *dev);
+struct nvdimm_bus_descriptor *to_nd_desc(struct nvdimm_bus *nvdimm_bus);
+const char *nvdimm_name(struct nvdimm *nvdimm);
+void *nvdimm_provider_data(struct nvdimm *nvdimm);
+struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
+                const struct attribute_group **groups, unsigned long flags,
+                unsigned long *dsm_mask);
+const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
+const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
+u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
+                const struct nd_cmd_desc *desc, int idx, void *buf);
+u32 nd_cmd_out_size(struct nvdimm *nvdimm, int cmd,
+                const struct nd_cmd_desc *desc, int idx, const u32 *in_field,
+                const u32 *out_field);
+int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count);
+struct nd_region *nvdimm_pmem_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+struct nd_region *nvdimm_blk_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+struct nd_region *nvdimm_volatile_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+void *nd_region_provider_data(struct nd_region *nd_region);
+void *nd_blk_region_provider_data(struct nd_blk_region *ndbr);
+void nd_blk_region_set_provider_data(struct nd_blk_region *ndbr, void *data);
+struct nvdimm *nd_blk_region_to_dimm(struct nd_blk_region *ndbr);
+unsigned int nd_region_acquire_lane(struct nd_region *nd_region);
+void nd_region_release_lane(struct nd_region *nd_region, unsigned int lane);
+u64 nd_fletcher64(void *addr, size_t len, bool le);
+#endif /* __LIBNVDIMM_H__ */
diff --git a/include/linux/livepatch.h b/include/linux/livepatch.h
index ee6dbb39a809..31db7a05dd36 100644
--- a/include/linux/livepatch.h
+++ b/include/linux/livepatch.h
@@ -99,7 +99,7 @@ struct klp_object {
         struct klp_func *funcs;
 
         /* internal */
-        struct kobject *kobj;
+        struct kobject kobj;
         struct module *mod;
         enum klp_state state;
 };
@@ -123,6 +123,12 @@ struct klp_patch {
         enum klp_state state;
 };
 
+#define klp_for_each_object(patch, obj) \
+        for (obj = patch->objs; obj->funcs; obj++)
+
+#define klp_for_each_func(obj, func) \
+        for (func = obj->funcs; func->old_name; func++)
+
 int klp_register_patch(struct klp_patch *);
 int klp_unregister_patch(struct klp_patch *);
 int klp_enable_patch(struct klp_patch *);
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 2722111591a3..70400dc7660f 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -255,6 +255,7 @@ struct held_lock {
         unsigned int check:1;       /* see lock_acquire() comment */
         unsigned int hardirqs_off:1;
         unsigned int references:12;                                     /* 32 bits */
+        unsigned int pin_count;
 };
 
 /*
@@ -354,6 +355,9 @@ extern void lockdep_set_current_reclaim_state(gfp_t gfp_mask);
 extern void lockdep_clear_current_reclaim_state(void);
 extern void lockdep_trace_alloc(gfp_t mask);
 
+extern void lock_pin_lock(struct lockdep_map *lock);
+extern void lock_unpin_lock(struct lockdep_map *lock);
+
 # define INIT_LOCKDEP                           .lockdep_recursion = 0, .lockdep_reclaim_gfp = 0,
 
 #define lockdep_depth(tsk)      (debug_locks ? (tsk)->lockdep_depth : 0)
@@ -368,6 +372,9 @@ extern void lockdep_trace_alloc(gfp_t mask);
 
 #define lockdep_recursing(tsk)  ((tsk)->lockdep_recursion)
 
+#define lockdep_pin_lock(l)             lock_pin_lock(&(l)->dep_map)
+#define lockdep_unpin_lock(l)   lock_unpin_lock(&(l)->dep_map)
+
 #else /* !CONFIG_LOCKDEP */
 
 static inline void lockdep_off(void)
@@ -420,6 +427,9 @@ struct lock_class_key { };
 
 #define lockdep_recursing(tsk)                  (0)
 
+#define lockdep_pin_lock(l)                             do { (void)(l); } while (0)
+#define lockdep_unpin_lock(l)                   do { (void)(l); } while (0)
+
 #endif /* !LOCKDEP */
 
 #ifdef CONFIG_LOCK_STAT
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
new file mode 100644
index 000000000000..9429f054c323
--- /dev/null
+++ b/include/linux/lsm_hooks.h
@@ -0,0 +1,1888 @@
+/*
+ * Linux Security Module interfaces
+ *
+ * Copyright (C) 2001 WireX Communications, Inc <chris@wirex.com>
+ * Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (C) 2001 Networks Associates Technology, Inc <ssmalley@nai.com>
+ * Copyright (C) 2001 James Morris <jmorris@intercode.com.au>
+ * Copyright (C) 2001 Silicon Graphics, Inc. (Trust Technology Group)
+ * Copyright (C) 2015 Intel Corporation.
+ * Copyright (C) 2015 Casey Schaufler <casey@schaufler-ca.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.
+ *
+ *      Due to this file being licensed under the GPL there is controversy over
+ *      whether this permits you to write a module that #includes this file
+ *      without placing your module under the GPL.  Please consult a lawyer for
+ *      advice before doing this.
+ *
+ */
+
+#ifndef __LINUX_LSM_HOOKS_H
+#define __LINUX_LSM_HOOKS_H
+
+#include <linux/security.h>
+#include <linux/init.h>
+#include <linux/rculist.h>
+
+/**
+ * Security hooks for program execution operations.
+ *
+ * @bprm_set_creds:
+ *      Save security information in the bprm->security field, typically based
+ *      on information about the bprm->file, for later use by the apply_creds
+ *      hook.  This hook may also optionally check permissions (e.g. for
+ *      transitions between security domains).
+ *      This hook may be called multiple times during a single execve, e.g. for
+ *      interpreters.  The hook can tell whether it has already been called by
+ *      checking to see if @bprm->security is non-NULL.  If so, then the hook
+ *      may decide either to retain the security information saved earlier or
+ *      to replace it.
+ *      @bprm contains the linux_binprm structure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @bprm_check_security:
+ *      This hook mediates the point when a search for a binary handler will
+ *      begin.  It allows a check the @bprm->security value which is set in the
+ *      preceding set_creds call.  The primary difference from set_creds is
+ *      that the argv list and envp list are reliably available in @bprm.  This
+ *      hook may be called multiple times during a single execve; and in each
+ *      pass set_creds is called first.
+ *      @bprm contains the linux_binprm structure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @bprm_committing_creds:
+ *      Prepare to install the new security attributes of a process being
+ *      transformed by an execve operation, based on the old credentials
+ *      pointed to by @current->cred and the information set in @bprm->cred by
+ *      the bprm_set_creds hook.  @bprm points to the linux_binprm structure.
+ *      This hook is a good place to perform state changes on the process such
+ *      as closing open file descriptors to which access will no longer be
+ *      granted when the attributes are changed.  This is called immediately
+ *      before commit_creds().
+ * @bprm_committed_creds:
+ *      Tidy up after the installation of the new security attributes of a
+ *      process being transformed by an execve operation.  The new credentials
+ *      have, by this point, been set to @current->cred.  @bprm points to the
+ *      linux_binprm structure.  This hook is a good place to perform state
+ *      changes on the process such as clearing out non-inheritable signal
+ *      state.  This is called immediately after commit_creds().
+ * @bprm_secureexec:
+ *      Return a boolean value (0 or 1) indicating whether a "secure exec"
+ *      is required.  The flag is passed in the auxiliary table
+ *      on the initial stack to the ELF interpreter to indicate whether libc
+ *      should enable secure mode.
+ *      @bprm contains the linux_binprm structure.
+ *
+ * Security hooks for filesystem operations.
+ *
+ * @sb_alloc_security:
+ *      Allocate and attach a security structure to the sb->s_security field.
+ *      The s_security field is initialized to NULL when the structure is
+ *      allocated.
+ *      @sb contains the super_block structure to be modified.
+ *      Return 0 if operation was successful.
+ * @sb_free_security:
+ *      Deallocate and clear the sb->s_security field.
+ *      @sb contains the super_block structure to be modified.
+ * @sb_statfs:
+ *      Check permission before obtaining filesystem statistics for the @mnt
+ *      mountpoint.
+ *      @dentry is a handle on the superblock for the filesystem.
+ *      Return 0 if permission is granted.
+ * @sb_mount:
+ *      Check permission before an object specified by @dev_name is mounted on
+ *      the mount point named by @nd.  For an ordinary mount, @dev_name
+ *      identifies a device if the file system type requires a device.  For a
+ *      remount (@flags & MS_REMOUNT), @dev_name is irrelevant.  For a
+ *      loopback/bind mount (@flags & MS_BIND), @dev_name identifies the
+ *      pathname of the object being mounted.
+ *      @dev_name contains the name for object being mounted.
+ *      @path contains the path for mount point object.
+ *      @type contains the filesystem type.
+ *      @flags contains the mount flags.
+ *      @data contains the filesystem-specific data.
+ *      Return 0 if permission is granted.
+ * @sb_copy_data:
+ *      Allow mount option data to be copied prior to parsing by the filesystem,
+ *      so that the security module can extract security-specific mount
+ *      options cleanly (a filesystem may modify the data e.g. with strsep()).
+ *      This also allows the original mount data to be stripped of security-
+ *      specific options to avoid having to make filesystems aware of them.
+ *      @type the type of filesystem being mounted.
+ *      @orig the original mount data copied from userspace.
+ *      @copy copied data which will be passed to the security module.
+ *      Returns 0 if the copy was successful.
+ * @sb_remount:
+ *      Extracts security system specific mount options and verifies no changes
+ *      are being made to those options.
+ *      @sb superblock being remounted
+ *      @data contains the filesystem-specific data.
+ *      Return 0 if permission is granted.
+ * @sb_umount:
+ *      Check permission before the @mnt file system is unmounted.
+ *      @mnt contains the mounted file system.
+ *      @flags contains the unmount flags, e.g. MNT_FORCE.
+ *      Return 0 if permission is granted.
+ * @sb_pivotroot:
+ *      Check permission before pivoting the root filesystem.
+ *      @old_path contains the path for the new location of the
+ *      current root (put_old).
+ *      @new_path contains the path for the new root (new_root).
+ *      Return 0 if permission is granted.
+ * @sb_set_mnt_opts:
+ *      Set the security relevant mount options used for a superblock
+ *      @sb the superblock to set security mount options for
+ *      @opts binary data structure containing all lsm mount data
+ * @sb_clone_mnt_opts:
+ *      Copy all security options from a given superblock to another
+ *      @oldsb old superblock which contain information to clone
+ *      @newsb new superblock which needs filled in
+ * @sb_parse_opts_str:
+ *      Parse a string of security data filling in the opts structure
+ *      @options string containing all mount options known by the LSM
+ *      @opts binary data structure usable by the LSM
+ * @dentry_init_security:
+ *      Compute a context for a dentry as the inode is not yet available
+ *      since NFSv4 has no label backed by an EA anyway.
+ *      @dentry dentry to use in calculating the context.
+ *      @mode mode used to determine resource type.
+ *      @name name of the last path component used to create file
+ *      @ctx pointer to place the pointer to the resulting context in.
+ *      @ctxlen point to place the length of the resulting context.
+ *
+ *
+ * Security hooks for inode operations.
+ *
+ * @inode_alloc_security:
+ *      Allocate and attach a security structure to @inode->i_security.  The
+ *      i_security field is initialized to NULL when the inode structure is
+ *      allocated.
+ *      @inode contains the inode structure.
+ *      Return 0 if operation was successful.
+ * @inode_free_security:
+ *      @inode contains the inode structure.
+ *      Deallocate the inode security structure and set @inode->i_security to
+ *      NULL.
+ * @inode_init_security:
+ *      Obtain the security attribute name suffix and value to set on a newly
+ *      created inode and set up the incore security field for the new inode.
+ *      This hook is called by the fs code as part of the inode creation
+ *      transaction and provides for atomic labeling of the inode, unlike
+ *      the post_create/mkdir/... hooks called by the VFS.  The hook function
+ *      is expected to allocate the name and value via kmalloc, with the caller
+ *      being responsible for calling kfree after using them.
+ *      If the security module does not use security attributes or does
+ *      not wish to put a security attribute on this particular inode,
+ *      then it should return -EOPNOTSUPP to skip this processing.
+ *      @inode contains the inode structure of the newly created inode.
+ *      @dir contains the inode structure of the parent directory.
+ *      @qstr contains the last path component of the new object
+ *      @name will be set to the allocated name suffix (e.g. selinux).
+ *      @value will be set to the allocated attribute value.
+ *      @len will be set to the length of the value.
+ *      Returns 0 if @name and @value have been successfully set,
+ *              -EOPNOTSUPP if no security attribute is needed, or
+ *              -ENOMEM on memory allocation failure.
+ * @inode_create:
+ *      Check permission to create a regular file.
+ *      @dir contains inode structure of the parent of the new file.
+ *      @dentry contains the dentry structure for the file to be created.
+ *      @mode contains the file mode of the file to be created.
+ *      Return 0 if permission is granted.
+ * @inode_link:
+ *      Check permission before creating a new hard link to a file.
+ *      @old_dentry contains the dentry structure for an existing
+ *      link to the file.
+ *      @dir contains the inode structure of the parent directory
+ *      of the new link.
+ *      @new_dentry contains the dentry structure for the new link.
+ *      Return 0 if permission is granted.
+ * @path_link:
+ *      Check permission before creating a new hard link to a file.
+ *      @old_dentry contains the dentry structure for an existing link
+ *      to the file.
+ *      @new_dir contains the path structure of the parent directory of
+ *      the new link.
+ *      @new_dentry contains the dentry structure for the new link.
+ *      Return 0 if permission is granted.
+ * @inode_unlink:
+ *      Check the permission to remove a hard link to a file.
+ *      @dir contains the inode structure of parent directory of the file.
+ *      @dentry contains the dentry structure for file to be unlinked.
+ *      Return 0 if permission is granted.
+ * @path_unlink:
+ *      Check the permission to remove a hard link to a file.
+ *      @dir contains the path structure of parent directory of the file.
+ *      @dentry contains the dentry structure for file to be unlinked.
+ *      Return 0 if permission is granted.
+ * @inode_symlink:
+ *      Check the permission to create a symbolic link to a file.
+ *      @dir contains the inode structure of parent directory of
+ *      the symbolic link.
+ *      @dentry contains the dentry structure of the symbolic link.
+ *      @old_name contains the pathname of file.
+ *      Return 0 if permission is granted.
+ * @path_symlink:
+ *      Check the permission to create a symbolic link to a file.
+ *      @dir contains the path structure of parent directory of
+ *      the symbolic link.
+ *      @dentry contains the dentry structure of the symbolic link.
+ *      @old_name contains the pathname of file.
+ *      Return 0 if permission is granted.
+ * @inode_mkdir:
+ *      Check permissions to create a new directory in the existing directory
+ *      associated with inode structure @dir.
+ *      @dir contains the inode structure of parent of the directory
+ *      to be created.
+ *      @dentry contains the dentry structure of new directory.
+ *      @mode contains the mode of new directory.
+ *      Return 0 if permission is granted.
+ * @path_mkdir:
+ *      Check permissions to create a new directory in the existing directory
+ *      associated with path structure @path.
+ *      @dir contains the path structure of parent of the directory
+ *      to be created.
+ *      @dentry contains the dentry structure of new directory.
+ *      @mode contains the mode of new directory.
+ *      Return 0 if permission is granted.
+ * @inode_rmdir:
+ *      Check the permission to remove a directory.
+ *      @dir contains the inode structure of parent of the directory
+ *      to be removed.
+ *      @dentry contains the dentry structure of directory to be removed.
+ *      Return 0 if permission is granted.
+ * @path_rmdir:
+ *      Check the permission to remove a directory.
+ *      @dir contains the path structure of parent of the directory to be
+ *      removed.
+ *      @dentry contains the dentry structure of directory to be removed.
+ *      Return 0 if permission is granted.
+ * @inode_mknod:
+ *      Check permissions when creating a special file (or a socket or a fifo
+ *      file created via the mknod system call).  Note that if mknod operation
+ *      is being done for a regular file, then the create hook will be called
+ *      and not this hook.
+ *      @dir contains the inode structure of parent of the new file.
+ *      @dentry contains the dentry structure of the new file.
+ *      @mode contains the mode of the new file.
+ *      @dev contains the device number.
+ *      Return 0 if permission is granted.
+ * @path_mknod:
+ *      Check permissions when creating a file. Note that this hook is called
+ *      even if mknod operation is being done for a regular file.
+ *      @dir contains the path structure of parent of the new file.
+ *      @dentry contains the dentry structure of the new file.
+ *      @mode contains the mode of the new file.
+ *      @dev contains the undecoded device number. Use new_decode_dev() to get
+ *      the decoded device number.
+ *      Return 0 if permission is granted.
+ * @inode_rename:
+ *      Check for permission to rename a file or directory.
+ *      @old_dir contains the inode structure for parent of the old link.
+ *      @old_dentry contains the dentry structure of the old link.
+ *      @new_dir contains the inode structure for parent of the new link.
+ *      @new_dentry contains the dentry structure of the new link.
+ *      Return 0 if permission is granted.
+ * @path_rename:
+ *      Check for permission to rename a file or directory.
+ *      @old_dir contains the path structure for parent of the old link.
+ *      @old_dentry contains the dentry structure of the old link.
+ *      @new_dir contains the path structure for parent of the new link.
+ *      @new_dentry contains the dentry structure of the new link.
+ *      Return 0 if permission is granted.
+ * @path_chmod:
+ *      Check for permission to change DAC's permission of a file or directory.
+ *      @dentry contains the dentry structure.
+ *      @mnt contains the vfsmnt structure.
+ *      @mode contains DAC's mode.
+ *      Return 0 if permission is granted.
+ * @path_chown:
+ *      Check for permission to change owner/group of a file or directory.
+ *      @path contains the path structure.
+ *      @uid contains new owner's ID.
+ *      @gid contains new group's ID.
+ *      Return 0 if permission is granted.
+ * @path_chroot:
+ *      Check for permission to change root directory.
+ *      @path contains the path structure.
+ *      Return 0 if permission is granted.
+ * @inode_readlink:
+ *      Check the permission to read the symbolic link.
+ *      @dentry contains the dentry structure for the file link.
+ *      Return 0 if permission is granted.
+ * @inode_follow_link:
+ *      Check permission to follow a symbolic link when looking up a pathname.
+ *      @dentry contains the dentry structure for the link.
+ *      @inode contains the inode, which itself is not stable in RCU-walk
+ *      @rcu indicates whether we are in RCU-walk mode.
+ *      Return 0 if permission is granted.
+ * @inode_permission:
+ *      Check permission before accessing an inode.  This hook is called by the
+ *      existing Linux permission function, so a security module can use it to
+ *      provide additional checking for existing Linux permission checks.
+ *      Notice that this hook is called when a file is opened (as well as many
+ *      other operations), whereas the file_security_ops permission hook is
+ *      called when the actual read/write operations are performed.
+ *      @inode contains the inode structure to check.
+ *      @mask contains the permission mask.
+ *      Return 0 if permission is granted.
+ * @inode_setattr:
+ *      Check permission before setting file attributes.  Note that the kernel
+ *      call to notify_change is performed from several locations, whenever
+ *      file attributes change (such as when a file is truncated, chown/chmod
+ *      operations, transferring disk quotas, etc).
+ *      @dentry contains the dentry structure for the file.
+ *      @attr is the iattr structure containing the new file attributes.
+ *      Return 0 if permission is granted.
+ * @path_truncate:
+ *      Check permission before truncating a file.
+ *      @path contains the path structure for the file.
+ *      Return 0 if permission is granted.
+ * @inode_getattr:
+ *      Check permission before obtaining file attributes.
+ *      @mnt is the vfsmount where the dentry was looked up
+ *      @dentry contains the dentry structure for the file.
+ *      Return 0 if permission is granted.
+ * @inode_setxattr:
+ *      Check permission before setting the extended attributes
+ *      @value identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_post_setxattr:
+ *      Update inode security field after successful setxattr operation.
+ *      @value identified by @name for @dentry.
+ * @inode_getxattr:
+ *      Check permission before obtaining the extended attributes
+ *      identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_listxattr:
+ *      Check permission before obtaining the list of extended attribute
+ *      names for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_removexattr:
+ *      Check permission before removing the extended attribute
+ *      identified by @name for @dentry.
+ *      Return 0 if permission is granted.
+ * @inode_getsecurity:
+ *      Retrieve a copy of the extended attribute representation of the
+ *      security label associated with @name for @inode via @buffer.  Note that
+ *      @name is the remainder of the attribute name after the security prefix
+ *      has been removed. @alloc is used to specify of the call should return a
+ *      value via the buffer or just the value length Return size of buffer on
+ *      success.
+ * @inode_setsecurity:
+ *      Set the security label associated with @name for @inode from the
+ *      extended attribute value @value.  @size indicates the size of the
+ *      @value in bytes.  @flags may be XATTR_CREATE, XATTR_REPLACE, or 0.
+ *      Note that @name is the remainder of the attribute name after the
+ *      security. prefix has been removed.
+ *      Return 0 on success.
+ * @inode_listsecurity:
+ *      Copy the extended attribute names for the security labels
+ *      associated with @inode into @buffer.  The maximum size of @buffer
+ *      is specified by @buffer_size.  @buffer may be NULL to request
+ *      the size of the buffer required.
+ *      Returns number of bytes used/required on success.
+ * @inode_need_killpriv:
+ *      Called when an inode has been changed.
+ *      @dentry is the dentry being changed.
+ *      Return <0 on error to abort the inode change operation.
+ *      Return 0 if inode_killpriv does not need to be called.
+ *      Return >0 if inode_killpriv does need to be called.
+ * @inode_killpriv:
+ *      The setuid bit is being removed.  Remove similar security labels.
+ *      Called with the dentry->d_inode->i_mutex held.
+ *      @dentry is the dentry being changed.
+ *      Return 0 on success.  If error is returned, then the operation
+ *      causing setuid bit removal is failed.
+ * @inode_getsecid:
+ *      Get the secid associated with the node.
+ *      @inode contains a pointer to the inode.
+ *      @secid contains a pointer to the location where result will be saved.
+ *      In case of failure, @secid will be set to zero.
+ *
+ * Security hooks for file operations
+ *
+ * @file_permission:
+ *      Check file permissions before accessing an open file.  This hook is
+ *      called by various operations that read or write files.  A security
+ *      module can use this hook to perform additional checking on these
+ *      operations, e.g.  to revalidate permissions on use to support privilege
+ *      bracketing or policy changes.  Notice that this hook is used when the
+ *      actual read/write operations are performed, whereas the
+ *      inode_security_ops hook is called when a file is opened (as well as
+ *      many other operations).
+ *      Caveat:  Although this hook can be used to revalidate permissions for
+ *      various system call operations that read or write files, it does not
+ *      address the revalidation of permissions for memory-mapped files.
+ *      Security modules must handle this separately if they need such
+ *      revalidation.
+ *      @file contains the file structure being accessed.
+ *      @mask contains the requested permissions.
+ *      Return 0 if permission is granted.
+ * @file_alloc_security:
+ *      Allocate and attach a security structure to the file->f_security field.
+ *      The security field is initialized to NULL when the structure is first
+ *      created.
+ *      @file contains the file structure to secure.
+ *      Return 0 if the hook is successful and permission is granted.
+ * @file_free_security:
+ *      Deallocate and free any security structures stored in file->f_security.
+ *      @file contains the file structure being modified.
+ * @file_ioctl:
+ *      @file contains the file structure.
+ *      @cmd contains the operation to perform.
+ *      @arg contains the operational arguments.
+ *      Check permission for an ioctl operation on @file.  Note that @arg
+ *      sometimes represents a user space pointer; in other cases, it may be a
+ *      simple integer value.  When @arg represents a user space pointer, it
+ *      should never be used by the security module.
+ *      Return 0 if permission is granted.
+ * @mmap_addr :
+ *      Check permissions for a mmap operation at @addr.
+ *      @addr contains virtual address that will be used for the operation.
+ *      Return 0 if permission is granted.
+ * @mmap_file :
+ *      Check permissions for a mmap operation.  The @file may be NULL, e.g.
+ *      if mapping anonymous memory.
+ *      @file contains the file structure for file to map (may be NULL).
+ *      @reqprot contains the protection requested by the application.
+ *      @prot contains the protection that will be applied by the kernel.
+ *      @flags contains the operational flags.
+ *      Return 0 if permission is granted.
+ * @file_mprotect:
+ *      Check permissions before changing memory access permissions.
+ *      @vma contains the memory region to modify.
+ *      @reqprot contains the protection requested by the application.
+ *      @prot contains the protection that will be applied by the kernel.
+ *      Return 0 if permission is granted.
+ * @file_lock:
+ *      Check permission before performing file locking operations.
+ *      Note: this hook mediates both flock and fcntl style locks.
+ *      @file contains the file structure.
+ *      @cmd contains the posix-translated lock operation to perform
+ *      (e.g. F_RDLCK, F_WRLCK).
+ *      Return 0 if permission is granted.
+ * @file_fcntl:
+ *      Check permission before allowing the file operation specified by @cmd
+ *      from being performed on the file @file.  Note that @arg sometimes
+ *      represents a user space pointer; in other cases, it may be a simple
+ *      integer value.  When @arg represents a user space pointer, it should
+ *      never be used by the security module.
+ *      @file contains the file structure.
+ *      @cmd contains the operation to be performed.
+ *      @arg contains the operational arguments.
+ *      Return 0 if permission is granted.
+ * @file_set_fowner:
+ *      Save owner security information (typically from current->security) in
+ *      file->f_security for later use by the send_sigiotask hook.
+ *      @file contains the file structure to update.
+ *      Return 0 on success.
+ * @file_send_sigiotask:
+ *      Check permission for the file owner @fown to send SIGIO or SIGURG to the
+ *      process @tsk.  Note that this hook is sometimes called from interrupt.
+ *      Note that the fown_struct, @fown, is never outside the context of a
+ *      struct file, so the file structure (and associated security information)
+ *      can always be obtained:
+ *              container_of(fown, struct file, f_owner)
+ *      @tsk contains the structure of task receiving signal.
+ *      @fown contains the file owner information.
+ *      @sig is the signal that will be sent.  When 0, kernel sends SIGIO.
+ *      Return 0 if permission is granted.
+ * @file_receive:
+ *      This hook allows security modules to control the ability of a process
+ *      to receive an open file descriptor via socket IPC.
+ *      @file contains the file structure being received.
+ *      Return 0 if permission is granted.
+ * @file_open
+ *      Save open-time permission checking state for later use upon
+ *      file_permission, and recheck access if anything has changed
+ *      since inode_permission.
+ *
+ * Security hooks for task operations.
+ *
+ * @task_create:
+ *      Check permission before creating a child process.  See the clone(2)
+ *      manual page for definitions of the @clone_flags.
+ *      @clone_flags contains the flags indicating what should be shared.
+ *      Return 0 if permission is granted.
+ * @task_free:
+ *      @task task being freed
+ *      Handle release of task-related resources. (Note that this can be called
+ *      from interrupt context.)
+ * @cred_alloc_blank:
+ *      @cred points to the credentials.
+ *      @gfp indicates the atomicity of any memory allocations.
+ *      Only allocate sufficient memory and attach to @cred such that
+ *      cred_transfer() will not get ENOMEM.
+ * @cred_free:
+ *      @cred points to the credentials.
+ *      Deallocate and clear the cred->security field in a set of credentials.
+ * @cred_prepare:
+ *      @new points to the new credentials.
+ *      @old points to the original credentials.
+ *      @gfp indicates the atomicity of any memory allocations.
+ *      Prepare a new set of credentials by copying the data from the old set.
+ * @cred_transfer:
+ *      @new points to the new credentials.
+ *      @old points to the original credentials.
+ *      Transfer data from original creds to new creds
+ * @kernel_act_as:
+ *      Set the credentials for a kernel service to act as (subjective context).
+ *      @new points to the credentials to be modified.
+ *      @secid specifies the security ID to be set
+ *      The current task must be the one that nominated @secid.
+ *      Return 0 if successful.
+ * @kernel_create_files_as:
+ *      Set the file creation context in a set of credentials to be the same as
+ *      the objective context of the specified inode.
+ *      @new points to the credentials to be modified.
+ *      @inode points to the inode to use as a reference.
+ *      The current task must be the one that nominated @inode.
+ *      Return 0 if successful.
+ * @kernel_fw_from_file:
+ *      Load firmware from userspace (not called for built-in firmware).
+ *      @file contains the file structure pointing to the file containing
+ *      the firmware to load. This argument will be NULL if the firmware
+ *      was loaded via the uevent-triggered blob-based interface exposed
+ *      by CONFIG_FW_LOADER_USER_HELPER.
+ *      @buf pointer to buffer containing firmware contents.
+ *      @size length of the firmware contents.
+ *      Return 0 if permission is granted.
+ * @kernel_module_request:
+ *      Ability to trigger the kernel to automatically upcall to userspace for
+ *      userspace to load a kernel module with the given name.
+ *      @kmod_name name of the module requested by the kernel
+ *      Return 0 if successful.
+ * @kernel_module_from_file:
+ *      Load a kernel module from userspace.
+ *      @file contains the file structure pointing to the file containing
+ *      the kernel module to load. If the module is being loaded from a blob,
+ *      this argument will be NULL.
+ *      Return 0 if permission is granted.
+ * @task_fix_setuid:
+ *      Update the module's state after setting one or more of the user
+ *      identity attributes of the current process.  The @flags parameter
+ *      indicates which of the set*uid system calls invoked this hook.  If
+ *      @new is the set of credentials that will be installed.  Modifications
+ *      should be made to this rather than to @current->cred.
+ *      @old is the set of credentials that are being replaces
+ *      @flags contains one of the LSM_SETID_* values.
+ *      Return 0 on success.
+ * @task_setpgid:
+ *      Check permission before setting the process group identifier of the
+ *      process @p to @pgid.
+ *      @p contains the task_struct for process being modified.
+ *      @pgid contains the new pgid.
+ *      Return 0 if permission is granted.
+ * @task_getpgid:
+ *      Check permission before getting the process group identifier of the
+ *      process @p.
+ *      @p contains the task_struct for the process.
+ *      Return 0 if permission is granted.
+ * @task_getsid:
+ *      Check permission before getting the session identifier of the process
+ *      @p.
+ *      @p contains the task_struct for the process.
+ *      Return 0 if permission is granted.
+ * @task_getsecid:
+ *      Retrieve the security identifier of the process @p.
+ *      @p contains the task_struct for the process and place is into @secid.
+ *      In case of failure, @secid will be set to zero.
+ *
+ * @task_setnice:
+ *      Check permission before setting the nice value of @p to @nice.
+ *      @p contains the task_struct of process.
+ *      @nice contains the new nice value.
+ *      Return 0 if permission is granted.
+ * @task_setioprio
+ *      Check permission before setting the ioprio value of @p to @ioprio.
+ *      @p contains the task_struct of process.
+ *      @ioprio contains the new ioprio value
+ *      Return 0 if permission is granted.
+ * @task_getioprio
+ *      Check permission before getting the ioprio value of @p.
+ *      @p contains the task_struct of process.
+ *      Return 0 if permission is granted.
+ * @task_setrlimit:
+ *      Check permission before setting the resource limits of the current
+ *      process for @resource to @new_rlim.  The old resource limit values can
+ *      be examined by dereferencing (current->signal->rlim + resource).
+ *      @resource contains the resource whose limit is being set.
+ *      @new_rlim contains the new limits for @resource.
+ *      Return 0 if permission is granted.
+ * @task_setscheduler:
+ *      Check permission before setting scheduling policy and/or parameters of
+ *      process @p based on @policy and @lp.
+ *      @p contains the task_struct for process.
+ *      @policy contains the scheduling policy.
+ *      @lp contains the scheduling parameters.
+ *      Return 0 if permission is granted.
+ * @task_getscheduler:
+ *      Check permission before obtaining scheduling information for process
+ *      @p.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_movememory
+ *      Check permission before moving memory owned by process @p.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_kill:
+ *      Check permission before sending signal @sig to @p.  @info can be NULL,
+ *      the constant 1, or a pointer to a siginfo structure.  If @info is 1 or
+ *      SI_FROMKERNEL(info) is true, then the signal should be viewed as coming
+ *      from the kernel and should typically be permitted.
+ *      SIGIO signals are handled separately by the send_sigiotask hook in
+ *      file_security_ops.
+ *      @p contains the task_struct for process.
+ *      @info contains the signal information.
+ *      @sig contains the signal value.
+ *      @secid contains the sid of the process where the signal originated
+ *      Return 0 if permission is granted.
+ * @task_wait:
+ *      Check permission before allowing a process to reap a child process @p
+ *      and collect its status information.
+ *      @p contains the task_struct for process.
+ *      Return 0 if permission is granted.
+ * @task_prctl:
+ *      Check permission before performing a process control operation on the
+ *      current process.
+ *      @option contains the operation.
+ *      @arg2 contains a argument.
+ *      @arg3 contains a argument.
+ *      @arg4 contains a argument.
+ *      @arg5 contains a argument.
+ *      Return -ENOSYS if no-one wanted to handle this op, any other value to
+ *      cause prctl() to return immediately with that value.
+ * @task_to_inode:
+ *      Set the security attributes for an inode based on an associated task's
+ *      security attributes, e.g. for /proc/pid inodes.
+ *      @p contains the task_struct for the task.
+ *      @inode contains the inode structure for the inode.
+ *
+ * Security hooks for Netlink messaging.
+ *
+ * @netlink_send:
+ *      Save security information for a netlink message so that permission
+ *      checking can be performed when the message is processed.  The security
+ *      information can be saved using the eff_cap field of the
+ *      netlink_skb_parms structure.  Also may be used to provide fine
+ *      grained control over message transmission.
+ *      @sk associated sock of task sending the message.
+ *      @skb contains the sk_buff structure for the netlink message.
+ *      Return 0 if the information was successfully saved and message
+ *      is allowed to be transmitted.
+ *
+ * Security hooks for Unix domain networking.
+ *
+ * @unix_stream_connect:
+ *      Check permissions before establishing a Unix domain stream connection
+ *      between @sock and @other.
+ *      @sock contains the sock structure.
+ *      @other contains the peer sock structure.
+ *      @newsk contains the new sock structure.
+ *      Return 0 if permission is granted.
+ * @unix_may_send:
+ *      Check permissions before connecting or sending datagrams from @sock to
+ *      @other.
+ *      @sock contains the socket structure.
+ *      @other contains the peer socket structure.
+ *      Return 0 if permission is granted.
+ *
+ * The @unix_stream_connect and @unix_may_send hooks were necessary because
+ * Linux provides an alternative to the conventional file name space for Unix
+ * domain sockets.  Whereas binding and connecting to sockets in the file name
+ * space is mediated by the typical file permissions (and caught by the mknod
+ * and permission hooks in inode_security_ops), binding and connecting to
+ * sockets in the abstract name space is completely unmediated.  Sufficient
+ * control of Unix domain sockets in the abstract name space isn't possible
+ * using only the socket layer hooks, since we need to know the actual target
+ * socket, which is not looked up until we are inside the af_unix code.
+ *
+ * Security hooks for socket operations.
+ *
+ * @socket_create:
+ *      Check permissions prior to creating a new socket.
+ *      @family contains the requested protocol family.
+ *      @type contains the requested communications type.
+ *      @protocol contains the requested protocol.
+ *      @kern set to 1 if a kernel socket.
+ *      Return 0 if permission is granted.
+ * @socket_post_create:
+ *      This hook allows a module to update or allocate a per-socket security
+ *      structure. Note that the security field was not added directly to the
+ *      socket structure, but rather, the socket security information is stored
+ *      in the associated inode.  Typically, the inode alloc_security hook will
+ *      allocate and and attach security information to
+ *      sock->inode->i_security.  This hook may be used to update the
+ *      sock->inode->i_security field with additional information that wasn't
+ *      available when the inode was allocated.
+ *      @sock contains the newly created socket structure.
+ *      @family contains the requested protocol family.
+ *      @type contains the requested communications type.
+ *      @protocol contains the requested protocol.
+ *      @kern set to 1 if a kernel socket.
+ * @socket_bind:
+ *      Check permission before socket protocol layer bind operation is
+ *      performed and the socket @sock is bound to the address specified in the
+ *      @address parameter.
+ *      @sock contains the socket structure.
+ *      @address contains the address to bind to.
+ *      @addrlen contains the length of address.
+ *      Return 0 if permission is granted.
+ * @socket_connect:
+ *      Check permission before socket protocol layer connect operation
+ *      attempts to connect socket @sock to a remote address, @address.
+ *      @sock contains the socket structure.
+ *      @address contains the address of remote endpoint.
+ *      @addrlen contains the length of address.
+ *      Return 0 if permission is granted.
+ * @socket_listen:
+ *      Check permission before socket protocol layer listen operation.
+ *      @sock contains the socket structure.
+ *      @backlog contains the maximum length for the pending connection queue.
+ *      Return 0 if permission is granted.
+ * @socket_accept:
+ *      Check permission before accepting a new connection.  Note that the new
+ *      socket, @newsock, has been created and some information copied to it,
+ *      but the accept operation has not actually been performed.
+ *      @sock contains the listening socket structure.
+ *      @newsock contains the newly created server socket for connection.
+ *      Return 0 if permission is granted.
+ * @socket_sendmsg:
+ *      Check permission before transmitting a message to another socket.
+ *      @sock contains the socket structure.
+ *      @msg contains the message to be transmitted.
+ *      @size contains the size of message.
+ *      Return 0 if permission is granted.
+ * @socket_recvmsg:
+ *      Check permission before receiving a message from a socket.
+ *      @sock contains the socket structure.
+ *      @msg contains the message structure.
+ *      @size contains the size of message structure.
+ *      @flags contains the operational flags.
+ *      Return 0 if permission is granted.
+ * @socket_getsockname:
+ *      Check permission before the local address (name) of the socket object
+ *      @sock is retrieved.
+ *      @sock contains the socket structure.
+ *      Return 0 if permission is granted.
+ * @socket_getpeername:
+ *      Check permission before the remote address (name) of a socket object
+ *      @sock is retrieved.
+ *      @sock contains the socket structure.
+ *      Return 0 if permission is granted.
+ * @socket_getsockopt:
+ *      Check permissions before retrieving the options associated with socket
+ *      @sock.
+ *      @sock contains the socket structure.
+ *      @level contains the protocol level to retrieve option from.
+ *      @optname contains the name of option to retrieve.
+ *      Return 0 if permission is granted.
+ * @socket_setsockopt:
+ *      Check permissions before setting the options associated with socket
+ *      @sock.
+ *      @sock contains the socket structure.
+ *      @level contains the protocol level to set options for.
+ *      @optname contains the name of the option to set.
+ *      Return 0 if permission is granted.
+ * @socket_shutdown:
+ *      Checks permission before all or part of a connection on the socket
+ *      @sock is shut down.
+ *      @sock contains the socket structure.
+ *      @how contains the flag indicating how future sends and receives
+ *      are handled.
+ *      Return 0 if permission is granted.
+ * @socket_sock_rcv_skb:
+ *      Check permissions on incoming network packets.  This hook is distinct
+ *      from Netfilter's IP input hooks since it is the first time that the
+ *      incoming sk_buff @skb has been associated with a particular socket, @sk.
+ *      Must not sleep inside this hook because some callers hold spinlocks.
+ *      @sk contains the sock (not socket) associated with the incoming sk_buff.
+ *      @skb contains the incoming network data.
+ * @socket_getpeersec_stream:
+ *      This hook allows the security module to provide peer socket security
+ *      state for unix or connected tcp sockets to userspace via getsockopt
+ *      SO_GETPEERSEC.  For tcp sockets this can be meaningful if the
+ *      socket is associated with an ipsec SA.
+ *      @sock is the local socket.
+ *      @optval userspace memory where the security state is to be copied.
+ *      @optlen userspace int where the module should copy the actual length
+ *      of the security state.
+ *      @len as input is the maximum length to copy to userspace provided
+ *      by the caller.
+ *      Return 0 if all is well, otherwise, typical getsockopt return
+ *      values.
+ * @socket_getpeersec_dgram:
+ *      This hook allows the security module to provide peer socket security
+ *      state for udp sockets on a per-packet basis to userspace via
+ *      getsockopt SO_GETPEERSEC.  The application must first have indicated
+ *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
+ *      security state returned by this hook for a packet via the SCM_SECURITY
+ *      ancillary message type.
+ *      @skb is the skbuff for the packet being queried
+ *      @secdata is a pointer to a buffer in which to copy the security data
+ *      @seclen is the maximum length for @secdata
+ *      Return 0 on success, error on failure.
+ * @sk_alloc_security:
+ *      Allocate and attach a security structure to the sk->sk_security field,
+ *      which is used to copy security attributes between local stream sockets.
+ * @sk_free_security:
+ *      Deallocate security structure.
+ * @sk_clone_security:
+ *      Clone/copy security structure.
+ * @sk_getsecid:
+ *      Retrieve the LSM-specific secid for the sock to enable caching
+ *      of network authorizations.
+ * @sock_graft:
+ *      Sets the socket's isec sid to the sock's sid.
+ * @inet_conn_request:
+ *      Sets the openreq's sid to socket's sid with MLS portion taken
+ *      from peer sid.
+ * @inet_csk_clone:
+ *      Sets the new child socket's sid to the openreq sid.
+ * @inet_conn_established:
+ *      Sets the connection's peersid to the secmark on skb.
+ * @secmark_relabel_packet:
+ *      check if the process should be allowed to relabel packets to
+ *      the given secid
+ * @security_secmark_refcount_inc
+ *      tells the LSM to increment the number of secmark labeling rules loaded
+ * @security_secmark_refcount_dec
+ *      tells the LSM to decrement the number of secmark labeling rules loaded
+ * @req_classify_flow:
+ *      Sets the flow's sid to the openreq sid.
+ * @tun_dev_alloc_security:
+ *      This hook allows a module to allocate a security structure for a TUN
+ *      device.
+ *      @security pointer to a security structure pointer.
+ *      Returns a zero on success, negative values on failure.
+ * @tun_dev_free_security:
+ *      This hook allows a module to free the security structure for a TUN
+ *      device.
+ *      @security pointer to the TUN device's security structure
+ * @tun_dev_create:
+ *      Check permissions prior to creating a new TUN device.
+ * @tun_dev_attach_queue:
+ *      Check permissions prior to attaching to a TUN device queue.
+ *      @security pointer to the TUN device's security structure.
+ * @tun_dev_attach:
+ *      This hook can be used by the module to update any security state
+ *      associated with the TUN device's sock structure.
+ *      @sk contains the existing sock structure.
+ *      @security pointer to the TUN device's security structure.
+ * @tun_dev_open:
+ *      This hook can be used by the module to update any security state
+ *      associated with the TUN device's security structure.
+ *      @security pointer to the TUN devices's security structure.
+ *
+ * Security hooks for XFRM operations.
+ *
+ * @xfrm_policy_alloc_security:
+ *      @ctxp is a pointer to the xfrm_sec_ctx being added to Security Policy
+ *      Database used by the XFRM system.
+ *      @sec_ctx contains the security context information being provided by
+ *      the user-level policy update program (e.g., setkey).
+ *      Allocate a security structure to the xp->security field; the security
+ *      field is initialized to NULL when the xfrm_policy is allocated.
+ *      Return 0 if operation was successful (memory to allocate, legal context)
+ *      @gfp is to specify the context for the allocation
+ * @xfrm_policy_clone_security:
+ *      @old_ctx contains an existing xfrm_sec_ctx.
+ *      @new_ctxp contains a new xfrm_sec_ctx being cloned from old.
+ *      Allocate a security structure in new_ctxp that contains the
+ *      information from the old_ctx structure.
+ *      Return 0 if operation was successful (memory to allocate).
+ * @xfrm_policy_free_security:
+ *      @ctx contains the xfrm_sec_ctx
+ *      Deallocate xp->security.
+ * @xfrm_policy_delete_security:
+ *      @ctx contains the xfrm_sec_ctx.
+ *      Authorize deletion of xp->security.
+ * @xfrm_state_alloc:
+ *      @x contains the xfrm_state being added to the Security Association
+ *      Database by the XFRM system.
+ *      @sec_ctx contains the security context information being provided by
+ *      the user-level SA generation program (e.g., setkey or racoon).
+ *      Allocate a security structure to the x->security field; the security
+ *      field is initialized to NULL when the xfrm_state is allocated. Set the
+ *      context to correspond to sec_ctx. Return 0 if operation was successful
+ *      (memory to allocate, legal context).
+ * @xfrm_state_alloc_acquire:
+ *      @x contains the xfrm_state being added to the Security Association
+ *      Database by the XFRM system.
+ *      @polsec contains the policy's security context.
+ *      @secid contains the secid from which to take the mls portion of the
+ *      context.
+ *      Allocate a security structure to the x->security field; the security
+ *      field is initialized to NULL when the xfrm_state is allocated. Set the
+ *      context to correspond to secid. Return 0 if operation was successful
+ *      (memory to allocate, legal context).
+ * @xfrm_state_free_security:
+ *      @x contains the xfrm_state.
+ *      Deallocate x->security.
+ * @xfrm_state_delete_security:
+ *      @x contains the xfrm_state.
+ *      Authorize deletion of x->security.
+ * @xfrm_policy_lookup:
+ *      @ctx contains the xfrm_sec_ctx for which the access control is being
+ *      checked.
+ *      @fl_secid contains the flow security label that is used to authorize
+ *      access to the policy xp.
+ *      @dir contains the direction of the flow (input or output).
+ *      Check permission when a flow selects a xfrm_policy for processing
+ *      XFRMs on a packet.  The hook is called when selecting either a
+ *      per-socket policy or a generic xfrm policy.
+ *      Return 0 if permission is granted, -ESRCH otherwise, or -errno
+ *      on other errors.
+ * @xfrm_state_pol_flow_match:
+ *      @x contains the state to match.
+ *      @xp contains the policy to check for a match.
+ *      @fl contains the flow to check for a match.
+ *      Return 1 if there is a match.
+ * @xfrm_decode_session:
+ *      @skb points to skb to decode.
+ *      @secid points to the flow key secid to set.
+ *      @ckall says if all xfrms used should be checked for same secid.
+ *      Return 0 if ckall is zero or all xfrms used have the same secid.
+ *
+ * Security hooks affecting all Key Management operations
+ *
+ * @key_alloc:
+ *      Permit allocation of a key and assign security data. Note that key does
+ *      not have a serial number assigned at this point.
+ *      @key points to the key.
+ *      @flags is the allocation flags
+ *      Return 0 if permission is granted, -ve error otherwise.
+ * @key_free:
+ *      Notification of destruction; free security data.
+ *      @key points to the key.
+ *      No return value.
+ * @key_permission:
+ *      See whether a specific operational right is granted to a process on a
+ *      key.
+ *      @key_ref refers to the key (key pointer + possession attribute bit).
+ *      @cred points to the credentials to provide the context against which to
+ *      evaluate the security data on the key.
+ *      @perm describes the combination of permissions required of this key.
+ *      Return 0 if permission is granted, -ve error otherwise.
+ * @key_getsecurity:
+ *      Get a textual representation of the security context attached to a key
+ *      for the purposes of honouring KEYCTL_GETSECURITY.  This function
+ *      allocates the storage for the NUL-terminated string and the caller
+ *      should free it.
+ *      @key points to the key to be queried.
+ *      @_buffer points to a pointer that should be set to point to the
+ *      resulting string (if no label or an error occurs).
+ *      Return the length of the string (including terminating NUL) or -ve if
+ *      an error.
+ *      May also return 0 (and a NULL buffer pointer) if there is no label.
+ *
+ * Security hooks affecting all System V IPC operations.
+ *
+ * @ipc_permission:
+ *      Check permissions for access to IPC
+ *      @ipcp contains the kernel IPC permission structure
+ *      @flag contains the desired (requested) permission set
+ *      Return 0 if permission is granted.
+ * @ipc_getsecid:
+ *      Get the secid associated with the ipc object.
+ *      @ipcp contains the kernel IPC permission structure.
+ *      @secid contains a pointer to the location where result will be saved.
+ *      In case of failure, @secid will be set to zero.
+ *
+ * Security hooks for individual messages held in System V IPC message queues
+ * @msg_msg_alloc_security:
+ *      Allocate and attach a security structure to the msg->security field.
+ *      The security field is initialized to NULL when the structure is first
+ *      created.
+ *      @msg contains the message structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @msg_msg_free_security:
+ *      Deallocate the security structure for this message.
+ *      @msg contains the message structure to be modified.
+ *
+ * Security hooks for System V IPC Message Queues
+ *
+ * @msg_queue_alloc_security:
+ *      Allocate and attach a security structure to the
+ *      msq->q_perm.security field. The security field is initialized to
+ *      NULL when the structure is first created.
+ *      @msq contains the message queue structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @msg_queue_free_security:
+ *      Deallocate security structure for this message queue.
+ *      @msq contains the message queue structure to be modified.
+ * @msg_queue_associate:
+ *      Check permission when a message queue is requested through the
+ *      msgget system call.  This hook is only called when returning the
+ *      message queue identifier for an existing message queue, not when a
+ *      new message queue is created.
+ *      @msq contains the message queue to act upon.
+ *      @msqflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgctl:
+ *      Check permission when a message control operation specified by @cmd
+ *      is to be performed on the message queue @msq.
+ *      The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO.
+ *      @msq contains the message queue to act upon.  May be NULL.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgsnd:
+ *      Check permission before a message, @msg, is enqueued on the message
+ *      queue, @msq.
+ *      @msq contains the message queue to send message to.
+ *      @msg contains the message to be enqueued.
+ *      @msqflg contains operational flags.
+ *      Return 0 if permission is granted.
+ * @msg_queue_msgrcv:
+ *      Check permission before a message, @msg, is removed from the message
+ *      queue, @msq.  The @target task structure contains a pointer to the
+ *      process that will be receiving the message (not equal to the current
+ *      process when inline receives are being performed).
+ *      @msq contains the message queue to retrieve message from.
+ *      @msg contains the message destination.
+ *      @target contains the task structure for recipient process.
+ *      @type contains the type of message requested.
+ *      @mode contains the operational flags.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for System V Shared Memory Segments
+ *
+ * @shm_alloc_security:
+ *      Allocate and attach a security structure to the shp->shm_perm.security
+ *      field.  The security field is initialized to NULL when the structure is
+ *      first created.
+ *      @shp contains the shared memory structure to be modified.
+ *      Return 0 if operation was successful and permission is granted.
+ * @shm_free_security:
+ *      Deallocate the security struct for this memory segment.
+ *      @shp contains the shared memory structure to be modified.
+ * @shm_associate:
+ *      Check permission when a shared memory region is requested through the
+ *      shmget system call.  This hook is only called when returning the shared
+ *      memory region identifier for an existing region, not when a new shared
+ *      memory region is created.
+ *      @shp contains the shared memory structure to be modified.
+ *      @shmflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @shm_shmctl:
+ *      Check permission when a shared memory control operation specified by
+ *      @cmd is to be performed on the shared memory region @shp.
+ *      The @shp may be NULL, e.g. for IPC_INFO or SHM_INFO.
+ *      @shp contains shared memory structure to be modified.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @shm_shmat:
+ *      Check permissions prior to allowing the shmat system call to attach the
+ *      shared memory segment @shp to the data segment of the calling process.
+ *      The attaching address is specified by @shmaddr.
+ *      @shp contains the shared memory structure to be modified.
+ *      @shmaddr contains the address to attach memory region to.
+ *      @shmflg contains the operational flags.
+ *      Return 0 if permission is granted.
+ *
+ * Security hooks for System V Semaphores
+ *
+ * @sem_alloc_security:
+ *      Allocate and attach a security structure to the sma->sem_perm.security
+ *      field.  The security field is initialized to NULL when the structure is
+ *      first created.
+ *      @sma contains the semaphore structure
+ *      Return 0 if operation was successful and permission is granted.
+ * @sem_free_security:
+ *      deallocate security struct for this semaphore
+ *      @sma contains the semaphore structure.
+ * @sem_associate:
+ *      Check permission when a semaphore is requested through the semget
+ *      system call.  This hook is only called when returning the semaphore
+ *      identifier for an existing semaphore, not when a new one must be
+ *      created.
+ *      @sma contains the semaphore structure.
+ *      @semflg contains the operation control flags.
+ *      Return 0 if permission is granted.
+ * @sem_semctl:
+ *      Check permission when a semaphore operation specified by @cmd is to be
+ *      performed on the semaphore @sma.  The @sma may be NULL, e.g. for
+ *      IPC_INFO or SEM_INFO.
+ *      @sma contains the semaphore structure.  May be NULL.
+ *      @cmd contains the operation to be performed.
+ *      Return 0 if permission is granted.
+ * @sem_semop
+ *      Check permissions before performing operations on members of the
+ *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set
+ *      may be modified.
+ *      @sma contains the semaphore structure.
+ *      @sops contains the operations to perform.
+ *      @nsops contains the number of operations to perform.
+ *      @alter contains the flag indicating whether changes are to be made.
+ *      Return 0 if permission is granted.
+ *
+ * @binder_set_context_mgr
+ *      Check whether @mgr is allowed to be the binder context manager.
+ *      @mgr contains the task_struct for the task being registered.
+ *      Return 0 if permission is granted.
+ * @binder_transaction
+ *      Check whether @from is allowed to invoke a binder transaction call
+ *      to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @to contains the task_struct for the receiving task.
+ * @binder_transfer_binder
+ *      Check whether @from is allowed to transfer a binder reference to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @to contains the task_struct for the receiving task.
+ * @binder_transfer_file
+ *      Check whether @from is allowed to transfer @file to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @file contains the struct file being transferred.
+ *      @to contains the task_struct for the receiving task.
+ *
+ * @ptrace_access_check:
+ *      Check permission before allowing the current process to trace the
+ *      @child process.
+ *      Security modules may also want to perform a process tracing check
+ *      during an execve in the set_security or apply_creds hooks of
+ *      tracing check during an execve in the bprm_set_creds hook of
+ *      binprm_security_ops if the process is being traced and its security
+ *      attributes would be changed by the execve.
+ *      @child contains the task_struct structure for the target process.
+ *      @mode contains the PTRACE_MODE flags indicating the form of access.
+ *      Return 0 if permission is granted.
+ * @ptrace_traceme:
+ *      Check that the @parent process has sufficient permission to trace the
+ *      current process before allowing the current process to present itself
+ *      to the @parent process for tracing.
+ *      @parent contains the task_struct structure for debugger process.
+ *      Return 0 if permission is granted.
+ * @capget:
+ *      Get the @effective, @inheritable, and @permitted capability sets for
+ *      the @target process.  The hook may also perform permission checking to
+ *      determine if the current process is allowed to see the capability sets
+ *      of the @target process.
+ *      @target contains the task_struct structure for target process.
+ *      @effective contains the effective capability set.
+ *      @inheritable contains the inheritable capability set.
+ *      @permitted contains the permitted capability set.
+ *      Return 0 if the capability sets were successfully obtained.
+ * @capset:
+ *      Set the @effective, @inheritable, and @permitted capability sets for
+ *      the current process.
+ *      @new contains the new credentials structure for target process.
+ *      @old contains the current credentials structure for target process.
+ *      @effective contains the effective capability set.
+ *      @inheritable contains the inheritable capability set.
+ *      @permitted contains the permitted capability set.
+ *      Return 0 and update @new if permission is granted.
+ * @capable:
+ *      Check whether the @tsk process has the @cap capability in the indicated
+ *      credentials.
+ *      @cred contains the credentials to use.
+ *      @ns contains the user namespace we want the capability in
+ *      @cap contains the capability <include/linux/capability.h>.
+ *      @audit: Whether to write an audit message or not
+ *      Return 0 if the capability is granted for @tsk.
+ * @syslog:
+ *      Check permission before accessing the kernel message ring or changing
+ *      logging to the console.
+ *      See the syslog(2) manual page for an explanation of the @type values.
+ *      @type contains the type of action.
+ *      @from_file indicates the context of action (if it came from /proc).
+ *      Return 0 if permission is granted.
+ * @settime:
+ *      Check permission to change the system time.
+ *      struct timespec and timezone are defined in include/linux/time.h
+ *      @ts contains new time
+ *      @tz contains new timezone
+ *      Return 0 if permission is granted.
+ * @vm_enough_memory:
+ *      Check permissions for allocating a new virtual mapping.
+ *      @mm contains the mm struct it is being added to.
+ *      @pages contains the number of pages.
+ *      Return 0 if permission is granted.
+ *
+ * @ismaclabel:
+ *      Check if the extended attribute specified by @name
+ *      represents a MAC label. Returns 1 if name is a MAC
+ *      attribute otherwise returns 0.
+ *      @name full extended attribute name to check against
+ *      LSM as a MAC label.
+ *
+ * @secid_to_secctx:
+ *      Convert secid to security context.  If secdata is NULL the length of
+ *      the result will be returned in seclen, but no secdata will be returned.
+ *      This does mean that the length could change between calls to check the
+ *      length and the next call which actually allocates and returns the
+ *      secdata.
+ *      @secid contains the security ID.
+ *      @secdata contains the pointer that stores the converted security
+ *      context.
+ *      @seclen pointer which contains the length of the data
+ * @secctx_to_secid:
+ *      Convert security context to secid.
+ *      @secid contains the pointer to the generated security ID.
+ *      @secdata contains the security context.
+ *
+ * @release_secctx:
+ *      Release the security context.
+ *      @secdata contains the security context.
+ *      @seclen contains the length of the security context.
+ *
+ * Security hooks for Audit
+ *
+ * @audit_rule_init:
+ *      Allocate and initialize an LSM audit rule structure.
+ *      @field contains the required Audit action.
+ *      Fields flags are defined in include/linux/audit.h
+ *      @op contains the operator the rule uses.
+ *      @rulestr contains the context where the rule will be applied to.
+ *      @lsmrule contains a pointer to receive the result.
+ *      Return 0 if @lsmrule has been successfully set,
+ *      -EINVAL in case of an invalid rule.
+ *
+ * @audit_rule_known:
+ *      Specifies whether given @rule contains any fields related to
+ *      current LSM.
+ *      @rule contains the audit rule of interest.
+ *      Return 1 in case of relation found, 0 otherwise.
+ *
+ * @audit_rule_match:
+ *      Determine if given @secid matches a rule previously approved
+ *      by @audit_rule_known.
+ *      @secid contains the security id in question.
+ *      @field contains the field which relates to current LSM.
+ *      @op contains the operator that will be used for matching.
+ *      @rule points to the audit rule that will be checked against.
+ *      @actx points to the audit context associated with the check.
+ *      Return 1 if secid matches the rule, 0 if it does not, -ERRNO on failure.
+ *
+ * @audit_rule_free:
+ *      Deallocate the LSM audit rule structure previously allocated by
+ *      audit_rule_init.
+ *      @rule contains the allocated rule
+ *
+ * @inode_notifysecctx:
+ *      Notify the security module of what the security context of an inode
+ *      should be.  Initializes the incore security context managed by the
+ *      security module for this inode.  Example usage:  NFS client invokes
+ *      this hook to initialize the security context in its incore inode to the
+ *      value provided by the server for the file when the server returned the
+ *      file's attributes to the client.
+ *
+ *      Must be called with inode->i_mutex locked.
+ *
+ *      @inode we wish to set the security context of.
+ *      @ctx contains the string which we wish to set in the inode.
+ *      @ctxlen contains the length of @ctx.
+ *
+ * @inode_setsecctx:
+ *      Change the security context of an inode.  Updates the
+ *      incore security context managed by the security module and invokes the
+ *      fs code as needed (via __vfs_setxattr_noperm) to update any backing
+ *      xattrs that represent the context.  Example usage:  NFS server invokes
+ *      this hook to change the security context in its incore inode and on the
+ *      backing filesystem to a value provided by the client on a SETATTR
+ *      operation.
+ *
+ *      Must be called with inode->i_mutex locked.
+ *
+ *      @dentry contains the inode we wish to set the security context of.
+ *      @ctx contains the string which we wish to set in the inode.
+ *      @ctxlen contains the length of @ctx.
+ *
+ * @inode_getsecctx:
+ *      On success, returns 0 and fills out @ctx and @ctxlen with the security
+ *      context for the given @inode.
+ *
+ *      @inode we wish to get the security context of.
+ *      @ctx is a pointer in which to place the allocated security context.
+ *      @ctxlen points to the place to put the length of @ctx.
+ * This is the main security structure.
+ */
+
+union security_list_options {
+        int (*binder_set_context_mgr)(struct task_struct *mgr);
+        int (*binder_transaction)(struct task_struct *from,
+                                        struct task_struct *to);
+        int (*binder_transfer_binder)(struct task_struct *from,
+                                        struct task_struct *to);
+        int (*binder_transfer_file)(struct task_struct *from,
+                                        struct task_struct *to,
+                                        struct file *file);
+
+        int (*ptrace_access_check)(struct task_struct *child,
+                                        unsigned int mode);
+        int (*ptrace_traceme)(struct task_struct *parent);
+        int (*capget)(struct task_struct *target, kernel_cap_t *effective,
+                        kernel_cap_t *inheritable, kernel_cap_t *permitted);
+        int (*capset)(struct cred *new, const struct cred *old,
+                        const kernel_cap_t *effective,
+                        const kernel_cap_t *inheritable,
+                        const kernel_cap_t *permitted);
+        int (*capable)(const struct cred *cred, struct user_namespace *ns,
+                        int cap, int audit);
+        int (*quotactl)(int cmds, int type, int id, struct super_block *sb);
+        int (*quota_on)(struct dentry *dentry);
+        int (*syslog)(int type);
+        int (*settime)(const struct timespec *ts, const struct timezone *tz);
+        int (*vm_enough_memory)(struct mm_struct *mm, long pages);
+
+        int (*bprm_set_creds)(struct linux_binprm *bprm);
+        int (*bprm_check_security)(struct linux_binprm *bprm);
+        int (*bprm_secureexec)(struct linux_binprm *bprm);
+        void (*bprm_committing_creds)(struct linux_binprm *bprm);
+        void (*bprm_committed_creds)(struct linux_binprm *bprm);
+
+        int (*sb_alloc_security)(struct super_block *sb);
+        void (*sb_free_security)(struct super_block *sb);
+        int (*sb_copy_data)(char *orig, char *copy);
+        int (*sb_remount)(struct super_block *sb, void *data);
+        int (*sb_kern_mount)(struct super_block *sb, int flags, void *data);
+        int (*sb_show_options)(struct seq_file *m, struct super_block *sb);
+        int (*sb_statfs)(struct dentry *dentry);
+        int (*sb_mount)(const char *dev_name, struct path *path,
+                        const char *type, unsigned long flags, void *data);
+        int (*sb_umount)(struct vfsmount *mnt, int flags);
+        int (*sb_pivotroot)(struct path *old_path, struct path *new_path);
+        int (*sb_set_mnt_opts)(struct super_block *sb,
+                                struct security_mnt_opts *opts,
+                                unsigned long kern_flags,
+                                unsigned long *set_kern_flags);
+        int (*sb_clone_mnt_opts)(const struct super_block *oldsb,
+                                        struct super_block *newsb);
+        int (*sb_parse_opts_str)(char *options, struct security_mnt_opts *opts);
+        int (*dentry_init_security)(struct dentry *dentry, int mode,
+                                        struct qstr *name, void **ctx,
+                                        u32 *ctxlen);
+
+
+#ifdef CONFIG_SECURITY_PATH
+        int (*path_unlink)(struct path *dir, struct dentry *dentry);
+        int (*path_mkdir)(struct path *dir, struct dentry *dentry,
+                                umode_t mode);
+        int (*path_rmdir)(struct path *dir, struct dentry *dentry);
+        int (*path_mknod)(struct path *dir, struct dentry *dentry,
+                                umode_t mode, unsigned int dev);
+        int (*path_truncate)(struct path *path);
+        int (*path_symlink)(struct path *dir, struct dentry *dentry,
+                                const char *old_name);
+        int (*path_link)(struct dentry *old_dentry, struct path *new_dir,
+                                struct dentry *new_dentry);
+        int (*path_rename)(struct path *old_dir, struct dentry *old_dentry,
+                                struct path *new_dir,
+                                struct dentry *new_dentry);
+        int (*path_chmod)(struct path *path, umode_t mode);
+        int (*path_chown)(struct path *path, kuid_t uid, kgid_t gid);
+        int (*path_chroot)(struct path *path);
+#endif
+
+        int (*inode_alloc_security)(struct inode *inode);
+        void (*inode_free_security)(struct inode *inode);
+        int (*inode_init_security)(struct inode *inode, struct inode *dir,
+                                        const struct qstr *qstr,
+                                        const char **name, void **value,
+                                        size_t *len);
+        int (*inode_create)(struct inode *dir, struct dentry *dentry,
+                                umode_t mode);
+        int (*inode_link)(struct dentry *old_dentry, struct inode *dir,
+                                struct dentry *new_dentry);
+        int (*inode_unlink)(struct inode *dir, struct dentry *dentry);
+        int (*inode_symlink)(struct inode *dir, struct dentry *dentry,
+                                const char *old_name);
+        int (*inode_mkdir)(struct inode *dir, struct dentry *dentry,
+                                umode_t mode);
+        int (*inode_rmdir)(struct inode *dir, struct dentry *dentry);
+        int (*inode_mknod)(struct inode *dir, struct dentry *dentry,
+                                umode_t mode, dev_t dev);
+        int (*inode_rename)(struct inode *old_dir, struct dentry *old_dentry,
+                                struct inode *new_dir,
+                                struct dentry *new_dentry);
+        int (*inode_readlink)(struct dentry *dentry);
+        int (*inode_follow_link)(struct dentry *dentry, struct inode *inode,
+                                 bool rcu);
+        int (*inode_permission)(struct inode *inode, int mask);
+        int (*inode_setattr)(struct dentry *dentry, struct iattr *attr);
+        int (*inode_getattr)(const struct path *path);
+        int (*inode_setxattr)(struct dentry *dentry, const char *name,
+                                const void *value, size_t size, int flags);
+        void (*inode_post_setxattr)(struct dentry *dentry, const char *name,
+                                        const void *value, size_t size,
+                                        int flags);
+        int (*inode_getxattr)(struct dentry *dentry, const char *name);
+        int (*inode_listxattr)(struct dentry *dentry);
+        int (*inode_removexattr)(struct dentry *dentry, const char *name);
+        int (*inode_need_killpriv)(struct dentry *dentry);
+        int (*inode_killpriv)(struct dentry *dentry);
+        int (*inode_getsecurity)(const struct inode *inode, const char *name,
+                                        void **buffer, bool alloc);
+        int (*inode_setsecurity)(struct inode *inode, const char *name,
+                                        const void *value, size_t size,
+                                        int flags);
+        int (*inode_listsecurity)(struct inode *inode, char *buffer,
+                                        size_t buffer_size);
+        void (*inode_getsecid)(const struct inode *inode, u32 *secid);
+
+        int (*file_permission)(struct file *file, int mask);
+        int (*file_alloc_security)(struct file *file);
+        void (*file_free_security)(struct file *file);
+        int (*file_ioctl)(struct file *file, unsigned int cmd,
+                                unsigned long arg);
+        int (*mmap_addr)(unsigned long addr);
+        int (*mmap_file)(struct file *file, unsigned long reqprot,
+                                unsigned long prot, unsigned long flags);
+        int (*file_mprotect)(struct vm_area_struct *vma, unsigned long reqprot,
+                                unsigned long prot);
+        int (*file_lock)(struct file *file, unsigned int cmd);
+        int (*file_fcntl)(struct file *file, unsigned int cmd,
+                                unsigned long arg);
+        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);
+        int (*file_open)(struct file *file, const struct cred *cred);
+
+        int (*task_create)(unsigned long clone_flags);
+        void (*task_free)(struct task_struct *task);
+        int (*cred_alloc_blank)(struct cred *cred, gfp_t gfp);
+        void (*cred_free)(struct cred *cred);
+        int (*cred_prepare)(struct cred *new, const struct cred *old,
+                                gfp_t gfp);
+        void (*cred_transfer)(struct cred *new, const struct cred *old);
+        int (*kernel_act_as)(struct cred *new, u32 secid);
+        int (*kernel_create_files_as)(struct cred *new, struct inode *inode);
+        int (*kernel_fw_from_file)(struct file *file, char *buf, size_t size);
+        int (*kernel_module_request)(char *kmod_name);
+        int (*kernel_module_from_file)(struct file *file);
+        int (*task_fix_setuid)(struct cred *new, const struct cred *old,
+                                int flags);
+        int (*task_setpgid)(struct task_struct *p, pid_t pgid);
+        int (*task_getpgid)(struct task_struct *p);
+        int (*task_getsid)(struct task_struct *p);
+        void (*task_getsecid)(struct task_struct *p, u32 *secid);
+        int (*task_setnice)(struct task_struct *p, int nice);
+        int (*task_setioprio)(struct task_struct *p, int ioprio);
+        int (*task_getioprio)(struct task_struct *p);
+        int (*task_setrlimit)(struct task_struct *p, unsigned int resource,
+                                struct rlimit *new_rlim);
+        int (*task_setscheduler)(struct task_struct *p);
+        int (*task_getscheduler)(struct task_struct *p);
+        int (*task_movememory)(struct task_struct *p);
+        int (*task_kill)(struct task_struct *p, struct siginfo *info,
+                                int sig, u32 secid);
+        int (*task_wait)(struct task_struct *p);
+        int (*task_prctl)(int option, unsigned long arg2, unsigned long arg3,
+                                unsigned long arg4, unsigned long arg5);
+        void (*task_to_inode)(struct task_struct *p, struct inode *inode);
+
+        int (*ipc_permission)(struct kern_ipc_perm *ipcp, short flag);
+        void (*ipc_getsecid)(struct kern_ipc_perm *ipcp, u32 *secid);
+
+        int (*msg_msg_alloc_security)(struct msg_msg *msg);
+        void (*msg_msg_free_security)(struct msg_msg *msg);
+
+        int (*msg_queue_alloc_security)(struct msg_queue *msq);
+        void (*msg_queue_free_security)(struct msg_queue *msq);
+        int (*msg_queue_associate)(struct msg_queue *msq, int msqflg);
+        int (*msg_queue_msgctl)(struct msg_queue *msq, int cmd);
+        int (*msg_queue_msgsnd)(struct msg_queue *msq, struct msg_msg *msg,
+                                int msqflg);
+        int (*msg_queue_msgrcv)(struct msg_queue *msq, struct msg_msg *msg,
+                                struct task_struct *target, long type,
+                                int mode);
+
+        int (*shm_alloc_security)(struct shmid_kernel *shp);
+        void (*shm_free_security)(struct shmid_kernel *shp);
+        int (*shm_associate)(struct shmid_kernel *shp, int shmflg);
+        int (*shm_shmctl)(struct shmid_kernel *shp, int cmd);
+        int (*shm_shmat)(struct shmid_kernel *shp, char __user *shmaddr,
+                                int shmflg);
+
+        int (*sem_alloc_security)(struct sem_array *sma);
+        void (*sem_free_security)(struct sem_array *sma);
+        int (*sem_associate)(struct sem_array *sma, int semflg);
+        int (*sem_semctl)(struct sem_array *sma, int cmd);
+        int (*sem_semop)(struct sem_array *sma, struct sembuf *sops,
+                                unsigned nsops, int alter);
+
+        int (*netlink_send)(struct sock *sk, struct sk_buff *skb);
+
+        void (*d_instantiate)(struct dentry *dentry, struct inode *inode);
+
+        int (*getprocattr)(struct task_struct *p, char *name, char **value);
+        int (*setprocattr)(struct task_struct *p, char *name, void *value,
+                                size_t size);
+        int (*ismaclabel)(const char *name);
+        int (*secid_to_secctx)(u32 secid, char **secdata, u32 *seclen);
+        int (*secctx_to_secid)(const char *secdata, u32 seclen, u32 *secid);
+        void (*release_secctx)(char *secdata, u32 seclen);
+
+        int (*inode_notifysecctx)(struct inode *inode, void *ctx, u32 ctxlen);
+        int (*inode_setsecctx)(struct dentry *dentry, void *ctx, u32 ctxlen);
+        int (*inode_getsecctx)(struct inode *inode, void **ctx, u32 *ctxlen);
+
+#ifdef CONFIG_SECURITY_NETWORK
+        int (*unix_stream_connect)(struct sock *sock, struct sock *other,
+                                        struct sock *newsk);
+        int (*unix_may_send)(struct socket *sock, struct socket *other);
+
+        int (*socket_create)(int family, int type, int protocol, int kern);
+        int (*socket_post_create)(struct socket *sock, int family, int type,
+                                        int protocol, int kern);
+        int (*socket_bind)(struct socket *sock, struct sockaddr *address,
+                                int addrlen);
+        int (*socket_connect)(struct socket *sock, struct sockaddr *address,
+                                int addrlen);
+        int (*socket_listen)(struct socket *sock, int backlog);
+        int (*socket_accept)(struct socket *sock, struct socket *newsock);
+        int (*socket_sendmsg)(struct socket *sock, struct msghdr *msg,
+                                int size);
+        int (*socket_recvmsg)(struct socket *sock, struct msghdr *msg,
+                                int size, int flags);
+        int (*socket_getsockname)(struct socket *sock);
+        int (*socket_getpeername)(struct socket *sock);
+        int (*socket_getsockopt)(struct socket *sock, int level, int optname);
+        int (*socket_setsockopt)(struct socket *sock, int level, int optname);
+        int (*socket_shutdown)(struct socket *sock, int how);
+        int (*socket_sock_rcv_skb)(struct sock *sk, struct sk_buff *skb);
+        int (*socket_getpeersec_stream)(struct socket *sock,
+                                        char __user *optval,
+                                        int __user *optlen, unsigned len);
+        int (*socket_getpeersec_dgram)(struct socket *sock,
+                                        struct sk_buff *skb, u32 *secid);
+        int (*sk_alloc_security)(struct sock *sk, int family, gfp_t priority);
+        void (*sk_free_security)(struct sock *sk);
+        void (*sk_clone_security)(const struct sock *sk, struct sock *newsk);
+        void (*sk_getsecid)(struct sock *sk, u32 *secid);
+        void (*sock_graft)(struct sock *sk, struct socket *parent);
+        int (*inet_conn_request)(struct sock *sk, struct sk_buff *skb,
+                                        struct request_sock *req);
+        void (*inet_csk_clone)(struct sock *newsk,
+                                const struct request_sock *req);
+        void (*inet_conn_established)(struct sock *sk, struct sk_buff *skb);
+        int (*secmark_relabel_packet)(u32 secid);
+        void (*secmark_refcount_inc)(void);
+        void (*secmark_refcount_dec)(void);
+        void (*req_classify_flow)(const struct request_sock *req,
+                                        struct flowi *fl);
+        int (*tun_dev_alloc_security)(void **security);
+        void (*tun_dev_free_security)(void *security);
+        int (*tun_dev_create)(void);
+        int (*tun_dev_attach_queue)(void *security);
+        int (*tun_dev_attach)(struct sock *sk, void *security);
+        int (*tun_dev_open)(void *security);
+#endif  /* CONFIG_SECURITY_NETWORK */
+
+#ifdef CONFIG_SECURITY_NETWORK_XFRM
+        int (*xfrm_policy_alloc_security)(struct xfrm_sec_ctx **ctxp,
+                                          struct xfrm_user_sec_ctx *sec_ctx,
+                                                gfp_t gfp);
+        int (*xfrm_policy_clone_security)(struct xfrm_sec_ctx *old_ctx,
+                                                struct xfrm_sec_ctx **new_ctx);
+        void (*xfrm_policy_free_security)(struct xfrm_sec_ctx *ctx);
+        int (*xfrm_policy_delete_security)(struct xfrm_sec_ctx *ctx);
+        int (*xfrm_state_alloc)(struct xfrm_state *x,
+                                struct xfrm_user_sec_ctx *sec_ctx);
+        int (*xfrm_state_alloc_acquire)(struct xfrm_state *x,
+                                        struct xfrm_sec_ctx *polsec,
+                                        u32 secid);
+        void (*xfrm_state_free_security)(struct xfrm_state *x);
+        int (*xfrm_state_delete_security)(struct xfrm_state *x);
+        int (*xfrm_policy_lookup)(struct xfrm_sec_ctx *ctx, u32 fl_secid,
+                                        u8 dir);
+        int (*xfrm_state_pol_flow_match)(struct xfrm_state *x,
+                                                struct xfrm_policy *xp,
+                                                const struct flowi *fl);
+        int (*xfrm_decode_session)(struct sk_buff *skb, u32 *secid, int ckall);
+#endif  /* CONFIG_SECURITY_NETWORK_XFRM */
+
+        /* key management security hooks */
+#ifdef CONFIG_KEYS
+        int (*key_alloc)(struct key *key, const struct cred *cred,
+                                unsigned long flags);
+        void (*key_free)(struct key *key);
+        int (*key_permission)(key_ref_t key_ref, const struct cred *cred,
+                                unsigned perm);
+        int (*key_getsecurity)(struct key *key, char **_buffer);
+#endif  /* CONFIG_KEYS */
+
+#ifdef CONFIG_AUDIT
+        int (*audit_rule_init)(u32 field, u32 op, char *rulestr,
+                                void **lsmrule);
+        int (*audit_rule_known)(struct audit_krule *krule);
+        int (*audit_rule_match)(u32 secid, u32 field, u32 op, void *lsmrule,
+                                struct audit_context *actx);
+        void (*audit_rule_free)(void *lsmrule);
+#endif /* CONFIG_AUDIT */
+};
+
+struct security_hook_heads {
+        struct list_head binder_set_context_mgr;
+        struct list_head binder_transaction;
+        struct list_head binder_transfer_binder;
+        struct list_head binder_transfer_file;
+        struct list_head ptrace_access_check;
+        struct list_head ptrace_traceme;
+        struct list_head capget;
+        struct list_head capset;
+        struct list_head capable;
+        struct list_head quotactl;
+        struct list_head quota_on;
+        struct list_head syslog;
+        struct list_head settime;
+        struct list_head vm_enough_memory;
+        struct list_head bprm_set_creds;
+        struct list_head bprm_check_security;
+        struct list_head bprm_secureexec;
+        struct list_head bprm_committing_creds;
+        struct list_head bprm_committed_creds;
+        struct list_head sb_alloc_security;
+        struct list_head sb_free_security;
+        struct list_head sb_copy_data;
+        struct list_head sb_remount;
+        struct list_head sb_kern_mount;
+        struct list_head sb_show_options;
+        struct list_head sb_statfs;
+        struct list_head sb_mount;
+        struct list_head sb_umount;
+        struct list_head sb_pivotroot;
+        struct list_head sb_set_mnt_opts;
+        struct list_head sb_clone_mnt_opts;
+        struct list_head sb_parse_opts_str;
+        struct list_head dentry_init_security;
+#ifdef CONFIG_SECURITY_PATH
+        struct list_head path_unlink;
+        struct list_head path_mkdir;
+        struct list_head path_rmdir;
+        struct list_head path_mknod;
+        struct list_head path_truncate;
+        struct list_head path_symlink;
+        struct list_head path_link;
+        struct list_head path_rename;
+        struct list_head path_chmod;
+        struct list_head path_chown;
+        struct list_head path_chroot;
+#endif
+        struct list_head inode_alloc_security;
+        struct list_head inode_free_security;
+        struct list_head inode_init_security;
+        struct list_head inode_create;
+        struct list_head inode_link;
+        struct list_head inode_unlink;
+        struct list_head inode_symlink;
+        struct list_head inode_mkdir;
+        struct list_head inode_rmdir;
+        struct list_head inode_mknod;
+        struct list_head inode_rename;
+        struct list_head inode_readlink;
+        struct list_head inode_follow_link;
+        struct list_head inode_permission;
+        struct list_head inode_setattr;
+        struct list_head inode_getattr;
+        struct list_head inode_setxattr;
+        struct list_head inode_post_setxattr;
+        struct list_head inode_getxattr;
+        struct list_head inode_listxattr;
+        struct list_head inode_removexattr;
+        struct list_head inode_need_killpriv;
+        struct list_head inode_killpriv;
+        struct list_head inode_getsecurity;
+        struct list_head inode_setsecurity;
+        struct list_head inode_listsecurity;
+        struct list_head inode_getsecid;
+        struct list_head file_permission;
+        struct list_head file_alloc_security;
+        struct list_head file_free_security;
+        struct list_head file_ioctl;
+        struct list_head mmap_addr;
+        struct list_head mmap_file;
+        struct list_head file_mprotect;
+        struct list_head file_lock;
+        struct list_head file_fcntl;
+        struct list_head file_set_fowner;
+        struct list_head file_send_sigiotask;
+        struct list_head file_receive;
+        struct list_head file_open;
+        struct list_head task_create;
+        struct list_head task_free;
+        struct list_head cred_alloc_blank;
+        struct list_head cred_free;
+        struct list_head cred_prepare;
+        struct list_head cred_transfer;
+        struct list_head kernel_act_as;
+        struct list_head kernel_create_files_as;
+        struct list_head kernel_fw_from_file;
+        struct list_head kernel_module_request;
+        struct list_head kernel_module_from_file;
+        struct list_head task_fix_setuid;
+        struct list_head task_setpgid;
+        struct list_head task_getpgid;
+        struct list_head task_getsid;
+        struct list_head task_getsecid;
+        struct list_head task_setnice;
+        struct list_head task_setioprio;
+        struct list_head task_getioprio;
+        struct list_head task_setrlimit;
+        struct list_head task_setscheduler;
+        struct list_head task_getscheduler;
+        struct list_head task_movememory;
+        struct list_head task_kill;
+        struct list_head task_wait;
+        struct list_head task_prctl;
+        struct list_head task_to_inode;
+        struct list_head ipc_permission;
+        struct list_head ipc_getsecid;
+        struct list_head msg_msg_alloc_security;
+        struct list_head msg_msg_free_security;
+        struct list_head msg_queue_alloc_security;
+        struct list_head msg_queue_free_security;
+        struct list_head msg_queue_associate;
+        struct list_head msg_queue_msgctl;
+        struct list_head msg_queue_msgsnd;
+        struct list_head msg_queue_msgrcv;
+        struct list_head shm_alloc_security;
+        struct list_head shm_free_security;
+        struct list_head shm_associate;
+        struct list_head shm_shmctl;
+        struct list_head shm_shmat;
+        struct list_head sem_alloc_security;
+        struct list_head sem_free_security;
+        struct list_head sem_associate;
+        struct list_head sem_semctl;
+        struct list_head sem_semop;
+        struct list_head netlink_send;
+        struct list_head d_instantiate;
+        struct list_head getprocattr;
+        struct list_head setprocattr;
+        struct list_head ismaclabel;
+        struct list_head secid_to_secctx;
+        struct list_head secctx_to_secid;
+        struct list_head release_secctx;
+        struct list_head inode_notifysecctx;
+        struct list_head inode_setsecctx;
+        struct list_head inode_getsecctx;
+#ifdef CONFIG_SECURITY_NETWORK
+        struct list_head unix_stream_connect;
+        struct list_head unix_may_send;
+        struct list_head socket_create;
+        struct list_head socket_post_create;
+        struct list_head socket_bind;
+        struct list_head socket_connect;
+        struct list_head socket_listen;
+        struct list_head socket_accept;
+        struct list_head socket_sendmsg;
+        struct list_head socket_recvmsg;
+        struct list_head socket_getsockname;
+        struct list_head socket_getpeername;
+        struct list_head socket_getsockopt;
+        struct list_head socket_setsockopt;
+        struct list_head socket_shutdown;
+        struct list_head socket_sock_rcv_skb;
+        struct list_head socket_getpeersec_stream;
+        struct list_head socket_getpeersec_dgram;
+        struct list_head sk_alloc_security;
+        struct list_head sk_free_security;
+        struct list_head sk_clone_security;
+        struct list_head sk_getsecid;
+        struct list_head sock_graft;
+        struct list_head inet_conn_request;
+        struct list_head inet_csk_clone;
+        struct list_head inet_conn_established;
+        struct list_head secmark_relabel_packet;
+        struct list_head secmark_refcount_inc;
+        struct list_head secmark_refcount_dec;
+        struct list_head req_classify_flow;
+        struct list_head tun_dev_alloc_security;
+        struct list_head tun_dev_free_security;
+        struct list_head tun_dev_create;
+        struct list_head tun_dev_attach_queue;
+        struct list_head tun_dev_attach;
+        struct list_head tun_dev_open;
+        struct list_head skb_owned_by;
+#endif  /* CONFIG_SECURITY_NETWORK */
+#ifdef CONFIG_SECURITY_NETWORK_XFRM
+        struct list_head xfrm_policy_alloc_security;
+        struct list_head xfrm_policy_clone_security;
+        struct list_head xfrm_policy_free_security;
+        struct list_head xfrm_policy_delete_security;
+        struct list_head xfrm_state_alloc;
+        struct list_head xfrm_state_alloc_acquire;
+        struct list_head xfrm_state_free_security;
+        struct list_head xfrm_state_delete_security;
+        struct list_head xfrm_policy_lookup;
+        struct list_head xfrm_state_pol_flow_match;
+        struct list_head xfrm_decode_session;
+#endif  /* CONFIG_SECURITY_NETWORK_XFRM */
+#ifdef CONFIG_KEYS
+        struct list_head key_alloc;
+        struct list_head key_free;
+        struct list_head key_permission;
+        struct list_head key_getsecurity;
+#endif  /* CONFIG_KEYS */
+#ifdef CONFIG_AUDIT
+        struct list_head audit_rule_init;
+        struct list_head audit_rule_known;
+        struct list_head audit_rule_match;
+        struct list_head audit_rule_free;
+#endif /* CONFIG_AUDIT */
+};
+
+/*
+ * Security module hook list structure.
+ * For use with generic list macros for common operations.
+ */
+struct security_hook_list {
+        struct list_head                list;
+        struct list_head                *head;
+        union security_list_options     hook;
+};
+
+/*
+ * Initializing a security_hook_list structure takes
+ * up a lot of space in a source file. This macro takes
+ * care of the common case and reduces the amount of
+ * text involved.
+ */
+#define LSM_HOOK_INIT(HEAD, HOOK) \
+        { .head = &security_hook_heads.HEAD, .hook = { .HEAD = HOOK } }
+
+extern struct security_hook_heads security_hook_heads;
+
+static inline void security_add_hooks(struct security_hook_list *hooks,
+                                      int count)
+{
+        int i;
+
+        for (i = 0; i < count; i++)
+                list_add_tail_rcu(&hooks[i].list, hooks[i].head);
+}
+
+#ifdef CONFIG_SECURITY_SELINUX_DISABLE
+/*
+ * Assuring the safety of deleting a security module is up to
+ * the security module involved. This may entail ordering the
+ * module's hook list in a particular way, refusing to disable
+ * the module once a policy is loaded or any number of other
+ * actions better imagined than described.
+ *
+ * The name of the configuration option reflects the only module
+ * that currently uses the mechanism. Any developer who thinks
+ * disabling their module is a good idea needs to be at least as
+ * careful as the SELinux team.
+ */
+static inline void security_delete_hooks(struct security_hook_list *hooks,
+                                                int count)
+{
+        int i;
+
+        for (i = 0; i < count; i++)
+                list_del_rcu(&hooks[i].list);
+}
+#endif /* CONFIG_SECURITY_SELINUX_DISABLE */
+
+extern int __init security_module_enable(const char *module);
+extern void __init capability_add_hooks(void);
+#ifdef CONFIG_SECURITY_YAMA_STACKED
+void __init yama_add_hooks(void);
+#endif
+
+#endif /* ! __LINUX_LSM_HOOKS_H */
diff --git a/include/linux/mailbox_client.h b/include/linux/mailbox_client.h
index 1726ccbd8009..44348710953f 100644
--- a/include/linux/mailbox_client.h
+++ b/include/linux/mailbox_client.h
@@ -40,6 +40,8 @@ struct mbox_client {
         void (*tx_done)(struct mbox_client *cl, void *mssg, int r);
 };
 
+struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl,
+                                              const char *name);
 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 */
diff --git a/include/linux/mailbox_controller.h b/include/linux/mailbox_controller.h
index d4cf96f07cfc..68c42454439b 100644
--- a/include/linux/mailbox_controller.h
+++ b/include/linux/mailbox_controller.h
@@ -72,7 +72,7 @@ struct mbox_chan_ops {
  */
 struct mbox_controller {
         struct device *dev;
-        struct mbox_chan_ops *ops;
+        const struct mbox_chan_ops *ops;
         struct mbox_chan *chans;
         int num_chans;
         bool txdone_irq;
diff --git a/include/linux/mdio-gpio.h b/include/linux/mdio-gpio.h
index 66c30a763b10..11f00cdabe3d 100644
--- a/include/linux/mdio-gpio.h
+++ b/include/linux/mdio-gpio.h
@@ -23,7 +23,8 @@ struct mdio_gpio_platform_data {
         bool mdio_active_low;
         bool mdo_active_low;
 
-        unsigned int phy_mask;
+        u32 phy_mask;
+        u32 phy_ignore_ta_mask;
         int irqs[PHY_MAX_ADDR];
         /* reset callback */
         int (*reset)(struct mii_bus *bus);
diff --git a/include/linux/mei_cl_bus.h b/include/linux/mei_cl_bus.h
index 0819d36a3a74..a16b1f9c1aca 100644
--- a/include/linux/mei_cl_bus.h
+++ b/include/linux/mei_cl_bus.h
@@ -7,6 +7,42 @@
 
 struct mei_cl_device;
 
+typedef void (*mei_cl_event_cb_t)(struct mei_cl_device *device,
+                               u32 events, void *context);
+
+/**
+ * struct mei_cl_device - MEI device handle
+ * An mei_cl_device pointer is returned from mei_add_device()
+ * and links MEI bus clients to their actual ME host client pointer.
+ * Drivers for MEI devices will get an mei_cl_device pointer
+ * when being probed and shall use it for doing ME bus I/O.
+ *
+ * @dev: linux driver model device pointer
+ * @me_cl: me client
+ * @cl: mei client
+ * @name: device name
+ * @event_work: async work to execute event callback
+ * @event_cb: Drivers register this callback to get asynchronous ME
+ *      events (e.g. Rx buffer pending) notifications.
+ * @event_context: event callback run context
+ * @events: Events bitmask sent to the driver.
+ * @priv_data: client private data
+ */
+struct mei_cl_device {
+        struct device dev;
+
+        struct mei_me_client *me_cl;
+        struct mei_cl *cl;
+        char name[MEI_CL_NAME_SIZE];
+
+        struct work_struct event_work;
+        mei_cl_event_cb_t event_cb;
+        void *event_context;
+        unsigned long events;
+
+        void *priv_data;
+};
+
 struct mei_cl_driver {
         struct device_driver driver;
         const char *name;
@@ -28,8 +64,6 @@ void mei_cl_driver_unregister(struct mei_cl_driver *driver);
 ssize_t mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length);
 ssize_t  mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length);
 
-typedef void (*mei_cl_event_cb_t)(struct mei_cl_device *device,
-                               u32 events, void *context);
 int mei_cl_register_event_cb(struct mei_cl_device *device,
                           mei_cl_event_cb_t read_cb, void *context);
 
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 9497ec7c77ea..cc4b01972060 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -21,7 +21,11 @@
 #define INIT_PHYSMEM_REGIONS    4
 
 /* Definition of memblock flags. */
-#define MEMBLOCK_HOTPLUG        0x1     /* hotpluggable region */
+enum {
+        MEMBLOCK_NONE           = 0x0,  /* No special request */
+        MEMBLOCK_HOTPLUG        = 0x1,  /* hotpluggable region */
+        MEMBLOCK_MIRROR         = 0x2,  /* mirrored region */
+};
 
 struct memblock_region {
         phys_addr_t base;
@@ -61,7 +65,7 @@ extern bool movable_node_enabled;
 
 phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
                                             phys_addr_t start, phys_addr_t end,
-                                            int nid);
+                                            int nid, ulong flags);
 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
                                    phys_addr_t size, phys_addr_t align);
 phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
@@ -75,6 +79,8 @@ int memblock_reserve(phys_addr_t base, phys_addr_t size);
 void memblock_trim_memory(phys_addr_t align);
 int memblock_mark_hotplug(phys_addr_t base, phys_addr_t size);
 int memblock_clear_hotplug(phys_addr_t base, phys_addr_t size);
+int memblock_mark_mirror(phys_addr_t base, phys_addr_t size);
+ulong choose_memblock_flags(void);
 
 /* Low level functions */
 int memblock_add_range(struct memblock_type *type,
@@ -85,14 +91,19 @@ int memblock_remove_range(struct memblock_type *type,
                           phys_addr_t base,
                           phys_addr_t size);
 
-void __next_mem_range(u64 *idx, int nid, struct memblock_type *type_a,
+void __next_mem_range(u64 *idx, int nid, ulong flags,
+                      struct memblock_type *type_a,
                       struct memblock_type *type_b, phys_addr_t *out_start,
                       phys_addr_t *out_end, int *out_nid);
 
-void __next_mem_range_rev(u64 *idx, int nid, struct memblock_type *type_a,
+void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
+                          struct memblock_type *type_a,
                           struct memblock_type *type_b, phys_addr_t *out_start,
                           phys_addr_t *out_end, int *out_nid);
 
+void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start,
+                               phys_addr_t *out_end);
+
 /**
  * for_each_mem_range - iterate through memblock areas from type_a and not
  * included in type_b. Or just type_a if type_b is NULL.
@@ -100,16 +111,17 @@ void __next_mem_range_rev(u64 *idx, int nid, struct memblock_type *type_a,
  * @type_a: ptr to memblock_type to iterate
  * @type_b: ptr to memblock_type which excludes from the iteration
  * @nid: node selector, %NUMA_NO_NODE for all nodes
+ * @flags: pick from blocks based on memory attributes
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
  */
-#define for_each_mem_range(i, type_a, type_b, nid,                      \
+#define for_each_mem_range(i, type_a, type_b, nid, flags,               \
                            p_start, p_end, p_nid)                       \
-        for (i = 0, __next_mem_range(&i, nid, type_a, type_b,           \
+        for (i = 0, __next_mem_range(&i, nid, flags, type_a, type_b,    \
                                      p_start, p_end, p_nid);            \
              i != (u64)ULLONG_MAX;                                      \
-             __next_mem_range(&i, nid, type_a, type_b,                  \
+             __next_mem_range(&i, nid, flags, type_a, type_b,           \
                               p_start, p_end, p_nid))
 
 /**
@@ -119,19 +131,35 @@ void __next_mem_range_rev(u64 *idx, int nid, struct memblock_type *type_a,
  * @type_a: ptr to memblock_type to iterate
  * @type_b: ptr to memblock_type which excludes from the iteration
  * @nid: node selector, %NUMA_NO_NODE for all nodes
+ * @flags: pick from blocks based on memory attributes
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
  */
-#define for_each_mem_range_rev(i, type_a, type_b, nid,                  \
+#define for_each_mem_range_rev(i, type_a, type_b, nid, flags,           \
                                p_start, p_end, p_nid)                   \
         for (i = (u64)ULLONG_MAX,                                       \
-                     __next_mem_range_rev(&i, nid, type_a, type_b,      \
+                     __next_mem_range_rev(&i, nid, flags, type_a, type_b,\
                                          p_start, p_end, p_nid);        \
              i != (u64)ULLONG_MAX;                                      \
-             __next_mem_range_rev(&i, nid, type_a, type_b,              \
+             __next_mem_range_rev(&i, nid, flags, type_a, type_b,       \
                                   p_start, p_end, p_nid))
 
+/**
+ * for_each_reserved_mem_region - iterate over all reserved memblock areas
+ * @i: u64 used as loop variable
+ * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
+ * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
+ *
+ * Walks over reserved areas of memblock. Available as soon as memblock
+ * is initialized.
+ */
+#define for_each_reserved_mem_region(i, p_start, p_end)                 \
+        for (i = 0UL,                                                   \
+             __next_reserved_mem_region(&i, p_start, p_end);            \
+             i != (u64)ULLONG_MAX;                                      \
+             __next_reserved_mem_region(&i, p_start, p_end))
+
 #ifdef CONFIG_MOVABLE_NODE
 static inline bool memblock_is_hotpluggable(struct memblock_region *m)
 {
@@ -153,6 +181,11 @@ static inline bool movable_node_is_enabled(void)
 }
 #endif
 
+static inline bool memblock_is_mirror(struct memblock_region *m)
+{
+        return m->flags & MEMBLOCK_MIRROR;
+}
+
 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
 int memblock_search_pfn_nid(unsigned long pfn, unsigned long *start_pfn,
                             unsigned long  *end_pfn);
@@ -181,13 +214,14 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
+ * @flags: pick from blocks based on memory attributes
  *
  * Walks over free (memory && !reserved) areas of memblock.  Available as
  * soon as memblock is initialized.
  */
-#define for_each_free_mem_range(i, nid, p_start, p_end, p_nid)          \
+#define for_each_free_mem_range(i, nid, flags, p_start, p_end, p_nid)   \
         for_each_mem_range(i, &memblock.memory, &memblock.reserved,     \
-                           nid, p_start, p_end, p_nid)
+                           nid, flags, p_start, p_end, p_nid)
 
 /**
  * for_each_free_mem_range_reverse - rev-iterate through free memblock areas
@@ -196,13 +230,15 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  * @p_nid: ptr to int for nid of the range, can be %NULL
+ * @flags: pick from blocks based on memory attributes
  *
  * Walks over free (memory && !reserved) areas of memblock in reverse
  * order.  Available as soon as memblock is initialized.
  */
-#define for_each_free_mem_range_reverse(i, nid, p_start, p_end, p_nid)  \
+#define for_each_free_mem_range_reverse(i, nid, flags, p_start, p_end,  \
+                                        p_nid)                          \
         for_each_mem_range_rev(i, &memblock.memory, &memblock.reserved, \
-                               nid, p_start, p_end, p_nid)
+                               nid, flags, p_start, p_end, p_nid)
 
 static inline void memblock_set_region_flags(struct memblock_region *r,
                                              unsigned long flags)
@@ -273,7 +309,8 @@ static inline bool memblock_bottom_up(void) { return false; }
 #define MEMBLOCK_ALLOC_ACCESSIBLE       0
 
 phys_addr_t __init memblock_alloc_range(phys_addr_t size, phys_addr_t align,
-                                        phys_addr_t start, phys_addr_t end);
+                                        phys_addr_t start, phys_addr_t end,
+                                        ulong flags);
 phys_addr_t memblock_alloc_base(phys_addr_t size, phys_addr_t align,
                                 phys_addr_t max_addr);
 phys_addr_t __memblock_alloc_base(phys_addr_t size, phys_addr_t align,
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 6c8918114804..73b02b0a8f60 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -41,6 +41,7 @@ enum mem_cgroup_stat_index {
         MEM_CGROUP_STAT_RSS,            /* # of pages charged as anon rss */
         MEM_CGROUP_STAT_RSS_HUGE,       /* # of pages charged as anon huge */
         MEM_CGROUP_STAT_FILE_MAPPED,    /* # of pages charged as file rss */
+        MEM_CGROUP_STAT_DIRTY,          /* # of dirty pages in page cache */
         MEM_CGROUP_STAT_WRITEBACK,      /* # of pages under writeback */
         MEM_CGROUP_STAT_SWAP,           /* # of pages, swapped out */
         MEM_CGROUP_STAT_NSTATS,
@@ -67,6 +68,8 @@ enum mem_cgroup_events_index {
 };
 
 #ifdef CONFIG_MEMCG
+extern struct cgroup_subsys_state *mem_cgroup_root_css;
+
 void mem_cgroup_events(struct mem_cgroup *memcg,
                        enum mem_cgroup_events_index idx,
                        unsigned int nr);
@@ -112,6 +115,7 @@ static inline bool mm_match_cgroup(struct mm_struct *mm,
 }
 
 extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg);
+extern struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page);
 
 struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
                                    struct mem_cgroup *,
@@ -195,6 +199,8 @@ void mem_cgroup_split_huge_fixup(struct page *head);
 #else /* CONFIG_MEMCG */
 struct mem_cgroup;
 
+#define mem_cgroup_root_css ((struct cgroup_subsys_state *)ERR_PTR(-EINVAL))
+
 static inline void mem_cgroup_events(struct mem_cgroup *memcg,
                                      enum mem_cgroup_events_index idx,
                                      unsigned int nr)
@@ -382,6 +388,29 @@ enum {
         OVER_LIMIT,
 };
 
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+struct list_head *mem_cgroup_cgwb_list(struct mem_cgroup *memcg);
+struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb);
+void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pavail,
+                         unsigned long *pdirty, unsigned long *pwriteback);
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb)
+{
+        return NULL;
+}
+
+static inline void mem_cgroup_wb_stats(struct bdi_writeback *wb,
+                                       unsigned long *pavail,
+                                       unsigned long *pdirty,
+                                       unsigned long *pwriteback)
+{
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
 struct sock;
 #if defined(CONFIG_INET) && defined(CONFIG_MEMCG_KMEM)
 void sock_update_memcg(struct sock *sk);
diff --git a/include/linux/mfd/arizona/core.h b/include/linux/mfd/arizona/core.h
index 16a498f48169..2f434f4f79a1 100644
--- a/include/linux/mfd/arizona/core.h
+++ b/include/linux/mfd/arizona/core.h
@@ -117,6 +117,7 @@ struct arizona {
         int num_core_supplies;
         struct regulator_bulk_data core_supplies[ARIZONA_MAX_CORE_SUPPLIES];
         struct regulator *dcvdd;
+        bool has_fully_powered_off;
 
         struct arizona_pdata pdata;
 
@@ -153,7 +154,15 @@ int arizona_request_irq(struct arizona *arizona, int irq, char *name,
 void arizona_free_irq(struct arizona *arizona, int irq, void *data);
 int arizona_set_irq_wake(struct arizona *arizona, int irq, int on);
 
+#ifdef CONFIG_MFD_WM5102
 int wm5102_patch(struct arizona *arizona);
+#else
+static inline int wm5102_patch(struct arizona *arizona)
+{
+        return 0;
+}
+#endif
+
 int wm5110_patch(struct arizona *arizona);
 int wm8997_patch(struct arizona *arizona);
 
diff --git a/include/linux/mfd/arizona/pdata.h b/include/linux/mfd/arizona/pdata.h
index 1789cb0f4f17..43db4faad143 100644
--- a/include/linux/mfd/arizona/pdata.h
+++ b/include/linux/mfd/arizona/pdata.h
@@ -121,6 +121,9 @@ struct arizona_pdata {
         /** GPIO used for mic isolation with HPDET */
         int hpdet_id_gpio;
 
+        /** Channel to use for headphone detection */
+        unsigned int hpdet_channel;
+
         /** Extra debounce timeout used during initial mic detection (ms) */
         int micd_detect_debounce;
 
@@ -156,7 +159,10 @@ struct arizona_pdata {
         /** MICBIAS configurations */
         struct arizona_micbias micbias[ARIZONA_MAX_MICBIAS];
 
-        /** Mode of input structures */
+        /**
+         * Mode of input structures
+         * One of the ARIZONA_INMODE_xxx values
+         */
         int inmode[ARIZONA_MAX_INPUT];
 
         /** Mode for outputs */
diff --git a/include/linux/mfd/arizona/registers.h b/include/linux/mfd/arizona/registers.h
index aacc10d7789c..3499d36e6067 100644
--- a/include/linux/mfd/arizona/registers.h
+++ b/include/linux/mfd/arizona/registers.h
@@ -2515,9 +2515,12 @@
 #define ARIZONA_IN1_DMIC_SUP_MASK                0x1800  /* IN1_DMIC_SUP - [12:11] */
 #define ARIZONA_IN1_DMIC_SUP_SHIFT                   11  /* IN1_DMIC_SUP - [12:11] */
 #define ARIZONA_IN1_DMIC_SUP_WIDTH                    2  /* IN1_DMIC_SUP - [12:11] */
-#define ARIZONA_IN1_MODE_MASK                    0x0600  /* IN1_MODE - [10:9] */
-#define ARIZONA_IN1_MODE_SHIFT                        9  /* IN1_MODE - [10:9] */
-#define ARIZONA_IN1_MODE_WIDTH                        2  /* IN1_MODE - [10:9] */
+#define ARIZONA_IN1_MODE_MASK                    0x0400  /* IN1_MODE - [10] */
+#define ARIZONA_IN1_MODE_SHIFT                       10  /* IN1_MODE - [10] */
+#define ARIZONA_IN1_MODE_WIDTH                        1  /* IN1_MODE - [10] */
+#define ARIZONA_IN1_SINGLE_ENDED_MASK            0x0200  /* IN1_MODE - [9] */
+#define ARIZONA_IN1_SINGLE_ENDED_SHIFT                9  /* IN1_MODE - [9] */
+#define ARIZONA_IN1_SINGLE_ENDED_WIDTH                1  /* IN1_MODE - [9] */
 #define ARIZONA_IN1L_PGA_VOL_MASK                0x00FE  /* IN1L_PGA_VOL - [7:1] */
 #define ARIZONA_IN1L_PGA_VOL_SHIFT                    1  /* IN1L_PGA_VOL - [7:1] */
 #define ARIZONA_IN1L_PGA_VOL_WIDTH                    7  /* IN1L_PGA_VOL - [7:1] */
@@ -2588,9 +2591,12 @@
 #define ARIZONA_IN2_DMIC_SUP_MASK                0x1800  /* IN2_DMIC_SUP - [12:11] */
 #define ARIZONA_IN2_DMIC_SUP_SHIFT                   11  /* IN2_DMIC_SUP - [12:11] */
 #define ARIZONA_IN2_DMIC_SUP_WIDTH                    2  /* IN2_DMIC_SUP - [12:11] */
-#define ARIZONA_IN2_MODE_MASK                    0x0600  /* IN2_MODE - [10:9] */
-#define ARIZONA_IN2_MODE_SHIFT                        9  /* IN2_MODE - [10:9] */
-#define ARIZONA_IN2_MODE_WIDTH                        2  /* IN2_MODE - [10:9] */
+#define ARIZONA_IN2_MODE_MASK                    0x0400  /* IN2_MODE - [10] */
+#define ARIZONA_IN2_MODE_SHIFT                       10  /* IN2_MODE - [10] */
+#define ARIZONA_IN2_MODE_WIDTH                        1  /* IN2_MODE - [10] */
+#define ARIZONA_IN2_SINGLE_ENDED_MASK            0x0200  /* IN2_MODE - [9] */
+#define ARIZONA_IN2_SINGLE_ENDED_SHIFT                9  /* IN2_MODE - [9] */
+#define ARIZONA_IN2_SINGLE_ENDED_WIDTH                1  /* IN2_MODE - [9] */
 #define ARIZONA_IN2L_PGA_VOL_MASK                0x00FE  /* IN2L_PGA_VOL - [7:1] */
 #define ARIZONA_IN2L_PGA_VOL_SHIFT                    1  /* IN2L_PGA_VOL - [7:1] */
 #define ARIZONA_IN2L_PGA_VOL_WIDTH                    7  /* IN2L_PGA_VOL - [7:1] */
@@ -2661,9 +2667,12 @@
 #define ARIZONA_IN3_DMIC_SUP_MASK                0x1800  /* IN3_DMIC_SUP - [12:11] */
 #define ARIZONA_IN3_DMIC_SUP_SHIFT                   11  /* IN3_DMIC_SUP - [12:11] */
 #define ARIZONA_IN3_DMIC_SUP_WIDTH                    2  /* IN3_DMIC_SUP - [12:11] */
-#define ARIZONA_IN3_MODE_MASK                    0x0600  /* IN3_MODE - [10:9] */
-#define ARIZONA_IN3_MODE_SHIFT                        9  /* IN3_MODE - [10:9] */
-#define ARIZONA_IN3_MODE_WIDTH                        2  /* IN3_MODE - [10:9] */
+#define ARIZONA_IN3_MODE_MASK                    0x0400  /* IN3_MODE - [10] */
+#define ARIZONA_IN3_MODE_SHIFT                       10  /* IN3_MODE - [10] */
+#define ARIZONA_IN3_MODE_WIDTH                        1  /* IN3_MODE - [10] */
+#define ARIZONA_IN3_SINGLE_ENDED_MASK            0x0200  /* IN3_MODE - [9] */
+#define ARIZONA_IN3_SINGLE_ENDED_SHIFT                9  /* IN3_MODE - [9] */
+#define ARIZONA_IN3_SINGLE_ENDED_WIDTH                1  /* IN3_MODE - [9] */
 #define ARIZONA_IN3L_PGA_VOL_MASK                0x00FE  /* IN3L_PGA_VOL - [7:1] */
 #define ARIZONA_IN3L_PGA_VOL_SHIFT                    1  /* IN3L_PGA_VOL - [7:1] */
 #define ARIZONA_IN3L_PGA_VOL_WIDTH                    7  /* IN3L_PGA_VOL - [7:1] */
diff --git a/include/linux/mfd/axp20x.h b/include/linux/mfd/axp20x.h
index dfabd6db7ddf..c2aa853fb412 100644
--- a/include/linux/mfd/axp20x.h
+++ b/include/linux/mfd/axp20x.h
@@ -14,6 +14,7 @@
 enum {
         AXP202_ID = 0,
         AXP209_ID,
+        AXP221_ID,
         AXP288_ID,
         NR_AXP20X_VARIANTS,
 };
@@ -45,6 +46,28 @@ enum {
 #define AXP20X_V_LTF_DISCHRG            0x3c
 #define AXP20X_V_HTF_DISCHRG            0x3d
 
+#define AXP22X_PWR_OUT_CTRL1            0x10
+#define AXP22X_PWR_OUT_CTRL2            0x12
+#define AXP22X_PWR_OUT_CTRL3            0x13
+#define AXP22X_DLDO1_V_OUT              0x15
+#define AXP22X_DLDO2_V_OUT              0x16
+#define AXP22X_DLDO3_V_OUT              0x17
+#define AXP22X_DLDO4_V_OUT              0x18
+#define AXP22X_ELDO1_V_OUT              0x19
+#define AXP22X_ELDO2_V_OUT              0x1a
+#define AXP22X_ELDO3_V_OUT              0x1b
+#define AXP22X_DC5LDO_V_OUT             0x1c
+#define AXP22X_DCDC1_V_OUT              0x21
+#define AXP22X_DCDC2_V_OUT              0x22
+#define AXP22X_DCDC3_V_OUT              0x23
+#define AXP22X_DCDC4_V_OUT              0x24
+#define AXP22X_DCDC5_V_OUT              0x25
+#define AXP22X_DCDC23_V_RAMP_CTRL       0x27
+#define AXP22X_ALDO1_V_OUT              0x28
+#define AXP22X_ALDO2_V_OUT              0x29
+#define AXP22X_ALDO3_V_OUT              0x2a
+#define AXP22X_CHRG_CTRL3               0x35
+
 /* Interrupt */
 #define AXP20X_IRQ1_EN                  0x40
 #define AXP20X_IRQ2_EN                  0x41
@@ -100,6 +123,9 @@ enum {
 #define AXP20X_VBUS_MON                 0x8b
 #define AXP20X_OVER_TMP                 0x8f
 
+#define AXP22X_PWREN_CTRL1              0x8c
+#define AXP22X_PWREN_CTRL2              0x8d
+
 /* GPIO */
 #define AXP20X_GPIO0_CTRL               0x90
 #define AXP20X_LDO5_V_OUT               0x91
@@ -108,6 +134,11 @@ enum {
 #define AXP20X_GPIO20_SS                0x94
 #define AXP20X_GPIO3_CTRL               0x95
 
+#define AXP22X_LDO_IO0_V_OUT            0x91
+#define AXP22X_LDO_IO1_V_OUT            0x93
+#define AXP22X_GPIO_STATE               0x94
+#define AXP22X_GPIO_PULL_DOWN           0x95
+
 /* Battery */
 #define AXP20X_CHRG_CC_31_24            0xb0
 #define AXP20X_CHRG_CC_23_16            0xb1
@@ -120,6 +151,9 @@ enum {
 #define AXP20X_CC_CTRL                  0xb8
 #define AXP20X_FG_RES                   0xb9
 
+/* AXP22X specific registers */
+#define AXP22X_BATLOW_THRES1            0xe6
+
 /* AXP288 specific registers */
 #define AXP288_PMIC_ADC_H               0x56
 #define AXP288_PMIC_ADC_L               0x57
@@ -158,6 +192,30 @@ enum {
         AXP20X_REG_ID_MAX,
 };
 
+enum {
+        AXP22X_DCDC1 = 0,
+        AXP22X_DCDC2,
+        AXP22X_DCDC3,
+        AXP22X_DCDC4,
+        AXP22X_DCDC5,
+        AXP22X_DC1SW,
+        AXP22X_DC5LDO,
+        AXP22X_ALDO1,
+        AXP22X_ALDO2,
+        AXP22X_ALDO3,
+        AXP22X_ELDO1,
+        AXP22X_ELDO2,
+        AXP22X_ELDO3,
+        AXP22X_DLDO1,
+        AXP22X_DLDO2,
+        AXP22X_DLDO3,
+        AXP22X_DLDO4,
+        AXP22X_RTC_LDO,
+        AXP22X_LDO_IO0,
+        AXP22X_LDO_IO1,
+        AXP22X_REG_ID_MAX,
+};
+
 /* IRQs */
 enum {
         AXP20X_IRQ_ACIN_OVER_V = 1,
@@ -199,6 +257,34 @@ enum {
         AXP20X_IRQ_GPIO0_INPUT,
 };
 
+enum axp22x_irqs {
+        AXP22X_IRQ_ACIN_OVER_V = 1,
+        AXP22X_IRQ_ACIN_PLUGIN,
+        AXP22X_IRQ_ACIN_REMOVAL,
+        AXP22X_IRQ_VBUS_OVER_V,
+        AXP22X_IRQ_VBUS_PLUGIN,
+        AXP22X_IRQ_VBUS_REMOVAL,
+        AXP22X_IRQ_VBUS_V_LOW,
+        AXP22X_IRQ_BATT_PLUGIN,
+        AXP22X_IRQ_BATT_REMOVAL,
+        AXP22X_IRQ_BATT_ENT_ACT_MODE,
+        AXP22X_IRQ_BATT_EXIT_ACT_MODE,
+        AXP22X_IRQ_CHARG,
+        AXP22X_IRQ_CHARG_DONE,
+        AXP22X_IRQ_BATT_TEMP_HIGH,
+        AXP22X_IRQ_BATT_TEMP_LOW,
+        AXP22X_IRQ_DIE_TEMP_HIGH,
+        AXP22X_IRQ_PEK_SHORT,
+        AXP22X_IRQ_PEK_LONG,
+        AXP22X_IRQ_LOW_PWR_LVL1,
+        AXP22X_IRQ_LOW_PWR_LVL2,
+        AXP22X_IRQ_TIMER,
+        AXP22X_IRQ_PEK_RIS_EDGE,
+        AXP22X_IRQ_PEK_FAL_EDGE,
+        AXP22X_IRQ_GPIO1_INPUT,
+        AXP22X_IRQ_GPIO0_INPUT,
+};
+
 enum axp288_irqs {
         AXP288_IRQ_VBUS_FALL     = 2,
         AXP288_IRQ_VBUS_RISE,
@@ -275,4 +361,16 @@ struct axp20x_fg_pdata {
         int thermistor_curve[MAX_THERM_CURVE_SIZE][2];
 };
 
+struct axp20x_chrg_pdata {
+        int max_cc;
+        int max_cv;
+        int def_cc;
+        int def_cv;
+};
+
+struct axp288_extcon_pdata {
+        /* GPIO pin control to switch D+/D- lines b/w PMIC and SOC */
+        struct gpio_desc *gpio_mux_cntl;
+};
+
 #endif /* __LINUX_MFD_AXP20X_H */
diff --git a/include/linux/mfd/cros_ec.h b/include/linux/mfd/cros_ec.h
index 324a34683971..da72671a42fa 100644
--- a/include/linux/mfd/cros_ec.h
+++ b/include/linux/mfd/cros_ec.h
@@ -17,10 +17,29 @@
 #define __LINUX_MFD_CROS_EC_H
 
 #include <linux/cdev.h>
+#include <linux/device.h>
 #include <linux/notifier.h>
 #include <linux/mfd/cros_ec_commands.h>
 #include <linux/mutex.h>
 
+#define CROS_EC_DEV_NAME "cros_ec"
+#define CROS_EC_DEV_PD_NAME "cros_pd"
+
+/*
+ * The EC is unresponsive for a time after a reboot command.  Add a
+ * simple delay to make sure that the bus stays locked.
+ */
+#define EC_REBOOT_DELAY_MS             50
+
+/*
+ * Max bus-specific overhead incurred by request/responses.
+ * I2C requires 1 additional byte for requests.
+ * I2C requires 2 additional bytes for responses.
+ * */
+#define EC_PROTO_VERSION_UNKNOWN        0
+#define EC_MAX_REQUEST_OVERHEAD         1
+#define EC_MAX_RESPONSE_OVERHEAD        2
+
 /*
  * Command interface between EC and AP, for LPC, I2C and SPI interfaces.
  */
@@ -42,8 +61,7 @@ enum {
  * @outsize: Outgoing length in bytes
  * @insize: Max number of bytes to accept from EC
  * @result: EC's response to the command (separate from communication failure)
- * @outdata: Outgoing data to EC
- * @indata: Where to put the incoming data from EC
+ * @data: Where to put the incoming data from EC and outgoing data to EC
  */
 struct cros_ec_command {
         uint32_t version;
@@ -51,18 +69,14 @@ struct cros_ec_command {
         uint32_t outsize;
         uint32_t insize;
         uint32_t result;
-        uint8_t outdata[EC_PROTO2_MAX_PARAM_SIZE];
-        uint8_t indata[EC_PROTO2_MAX_PARAM_SIZE];
+        uint8_t data[0];
 };
 
 /**
  * struct cros_ec_device - Information about a ChromeOS EC device
  *
- * @ec_name: name of EC device (e.g. 'chromeos-ec')
  * @phys_name: name of physical comms layer (e.g. 'i2c-4')
  * @dev: Device pointer for physical comms device
- * @vdev: Device pointer for virtual comms device
- * @cdev: Character device structure for virtual comms device
  * @was_wake_device: true if this device was set to wake the system from
  * sleep at the last suspend
  * @cmd_readmem: direct read of the EC memory-mapped region, if supported
@@ -74,6 +88,7 @@ struct cros_ec_command {
  *
  * @priv: Private data
  * @irq: Interrupt to use
+ * @id: Device id
  * @din: input buffer (for data from EC)
  * @dout: output buffer (for data to EC)
  * \note
@@ -85,41 +100,72 @@ struct cros_ec_command {
  * to using dword.
  * @din_size: size of din buffer to allocate (zero to use static din)
  * @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.
+ * @pkt_xfer: send packet to EC and get response
  * @lock: one transaction at a time
  */
 struct cros_ec_device {
 
         /* These are used by other drivers that want to talk to the EC */
-        const char *ec_name;
         const char *phys_name;
         struct device *dev;
-        struct device *vdev;
-        struct cdev cdev;
         bool was_wake_device;
         struct class *cros_class;
         int (*cmd_readmem)(struct cros_ec_device *ec, unsigned int offset,
                            unsigned int bytes, void *dest);
 
         /* These are used to implement the platform-specific interface */
+        u16 max_request;
+        u16 max_response;
+        u16 max_passthru;
+        u16 proto_version;
         void *priv;
         int irq;
-        uint8_t *din;
-        uint8_t *dout;
+        u8 *din;
+        u8 *dout;
         int din_size;
         int dout_size;
-        struct device *parent;
         bool wake_enabled;
         int (*cmd_xfer)(struct cros_ec_device *ec,
                         struct cros_ec_command *msg);
+        int (*pkt_xfer)(struct cros_ec_device *ec,
+                        struct cros_ec_command *msg);
         struct mutex lock;
 };
 
+/* struct cros_ec_platform - ChromeOS EC platform information
+ *
+ * @ec_name: name of EC device (e.g. 'cros-ec', 'cros-pd', ...)
+ * used in /dev/ and sysfs.
+ * @cmd_offset: offset to apply for each command. Set when
+ * registering a devicde behind another one.
+ */
+struct cros_ec_platform {
+        const char *ec_name;
+        u16 cmd_offset;
+};
+
+/*
+ * struct cros_ec_dev - ChromeOS EC device entry point
+ *
+ * @class_dev: Device structure used in sysfs
+ * @cdev: Character device structure in /dev
+ * @ec_dev: cros_ec_device structure to talk to the physical device
+ * @dev: pointer to the platform device
+ * @cmd_offset: offset to apply for each command.
+ */
+struct cros_ec_dev {
+        struct device class_dev;
+        struct cdev cdev;
+        struct cros_ec_device *ec_dev;
+        struct device *dev;
+        u16 cmd_offset;
+};
+
 /**
  * cros_ec_suspend - Handle a suspend operation for the ChromeOS EC device
  *
@@ -198,4 +244,16 @@ int cros_ec_remove(struct cros_ec_device *ec_dev);
  */
 int cros_ec_register(struct cros_ec_device *ec_dev);
 
+/**
+ * cros_ec_register -  Query the protocol version supported by the ChromeOS EC
+ *
+ * @ec_dev: Device to register
+ * @return 0 if ok, -ve on error
+ */
+int cros_ec_query_all(struct cros_ec_device *ec_dev);
+
+/* sysfs stuff */
+extern struct attribute_group cros_ec_attr_group;
+extern struct attribute_group cros_ec_lightbar_attr_group;
+
 #endif /* __LINUX_MFD_CROS_EC_H */
diff --git a/include/linux/mfd/cros_ec_commands.h b/include/linux/mfd/cros_ec_commands.h
index a49cd41feea7..13b630c10d4c 100644
--- a/include/linux/mfd/cros_ec_commands.h
+++ b/include/linux/mfd/cros_ec_commands.h
@@ -515,7 +515,7 @@ struct ec_host_response {
 /*
  * Notes on commands:
  *
- * Each command is an 8-byte command value.  Commands which take params or
+ * Each command is an 16-bit command value.  Commands which take params or
  * return response data specify structs for that data.  If no struct is
  * specified, the command does not input or output data, respectively.
  * Parameter/response length is implicit in the structs.  Some underlying
@@ -966,7 +966,7 @@ struct rgb_s {
 /* List of tweakable parameters. NOTE: It's __packed so it can be sent in a
  * host command, but the alignment is the same regardless. Keep it that way.
  */
-struct lightbar_params {
+struct lightbar_params_v0 {
         /* Timing */
         int32_t google_ramp_up;
         int32_t google_ramp_down;
@@ -1000,32 +1000,81 @@ struct lightbar_params {
         struct rgb_s color[8];                  /* 0-3 are Google colors */
 } __packed;
 
+struct lightbar_params_v1 {
+        /* Timing */
+        int32_t google_ramp_up;
+        int32_t google_ramp_down;
+        int32_t s3s0_ramp_up;
+        int32_t s0_tick_delay[2];               /* AC=0/1 */
+        int32_t s0a_tick_delay[2];              /* AC=0/1 */
+        int32_t s0s3_ramp_down;
+        int32_t s3_sleep_for;
+        int32_t s3_ramp_up;
+        int32_t s3_ramp_down;
+        int32_t tap_tick_delay;
+        int32_t tap_display_time;
+
+        /* Tap-for-battery params */
+        uint8_t tap_pct_red;
+        uint8_t tap_pct_green;
+        uint8_t tap_seg_min_on;
+        uint8_t tap_seg_max_on;
+        uint8_t tap_seg_osc;
+        uint8_t tap_idx[3];
+
+        /* Oscillation */
+        uint8_t osc_min[2];                     /* AC=0/1 */
+        uint8_t osc_max[2];                     /* AC=0/1 */
+        uint8_t w_ofs[2];                       /* AC=0/1 */
+
+        /* Brightness limits based on the backlight and AC. */
+        uint8_t bright_bl_off_fixed[2];         /* AC=0/1 */
+        uint8_t bright_bl_on_min[2];            /* AC=0/1 */
+        uint8_t bright_bl_on_max[2];            /* AC=0/1 */
+
+        /* Battery level thresholds */
+        uint8_t battery_threshold[LB_BATTERY_LEVELS - 1];
+
+        /* Map [AC][battery_level] to color index */
+        uint8_t s0_idx[2][LB_BATTERY_LEVELS];   /* AP is running */
+        uint8_t s3_idx[2][LB_BATTERY_LEVELS];   /* AP is sleeping */
+
+        /* Color palette */
+        struct rgb_s color[8];                  /* 0-3 are Google colors */
+} __packed;
+
 struct ec_params_lightbar {
         uint8_t cmd;                  /* Command (see enum lightbar_command) */
         union {
                 struct {
                         /* no args */
-                } dump, off, on, init, get_seq, get_params, version;
+                } dump, off, on, init, get_seq, get_params_v0, get_params_v1,
+                        version, get_brightness, get_demo;
 
-                struct num {
+                struct {
                         uint8_t num;
-                } brightness, seq, demo;
+                } set_brightness, seq, demo;
 
-                struct reg {
+                struct {
                         uint8_t ctrl, reg, value;
                 } reg;
 
-                struct rgb {
+                struct {
                         uint8_t led, red, green, blue;
-                } rgb;
+                } set_rgb;
+
+                struct {
+                        uint8_t led;
+                } get_rgb;
 
-                struct lightbar_params set_params;
+                struct lightbar_params_v0 set_params_v0;
+                struct lightbar_params_v1 set_params_v1;
         };
 } __packed;
 
 struct ec_response_lightbar {
         union {
-                struct dump {
+                struct {
                         struct {
                                 uint8_t reg;
                                 uint8_t ic0;
@@ -1033,20 +1082,26 @@ struct ec_response_lightbar {
                         } vals[23];
                 } dump;
 
-                struct get_seq {
+                struct  {
                         uint8_t num;
-                } get_seq;
+                } get_seq, get_brightness, get_demo;
 
-                struct lightbar_params get_params;
+                struct lightbar_params_v0 get_params_v0;
+                struct lightbar_params_v1 get_params_v1;
 
-                struct version {
+                struct {
                         uint32_t num;
                         uint32_t flags;
                 } version;
 
                 struct {
+                        uint8_t red, green, blue;
+                } get_rgb;
+
+                struct {
                         /* no return params */
-                } off, on, init, brightness, seq, reg, rgb, demo, set_params;
+                } off, on, init, set_brightness, seq, reg, set_rgb,
+                        demo, set_params_v0, set_params_v1;
         };
 } __packed;
 
@@ -1056,15 +1111,20 @@ enum lightbar_command {
         LIGHTBAR_CMD_OFF = 1,
         LIGHTBAR_CMD_ON = 2,
         LIGHTBAR_CMD_INIT = 3,
-        LIGHTBAR_CMD_BRIGHTNESS = 4,
+        LIGHTBAR_CMD_SET_BRIGHTNESS = 4,
         LIGHTBAR_CMD_SEQ = 5,
         LIGHTBAR_CMD_REG = 6,
-        LIGHTBAR_CMD_RGB = 7,
+        LIGHTBAR_CMD_SET_RGB = 7,
         LIGHTBAR_CMD_GET_SEQ = 8,
         LIGHTBAR_CMD_DEMO = 9,
-        LIGHTBAR_CMD_GET_PARAMS = 10,
-        LIGHTBAR_CMD_SET_PARAMS = 11,
+        LIGHTBAR_CMD_GET_PARAMS_V0 = 10,
+        LIGHTBAR_CMD_SET_PARAMS_V0 = 11,
         LIGHTBAR_CMD_VERSION = 12,
+        LIGHTBAR_CMD_GET_BRIGHTNESS = 13,
+        LIGHTBAR_CMD_GET_RGB = 14,
+        LIGHTBAR_CMD_GET_DEMO = 15,
+        LIGHTBAR_CMD_GET_PARAMS_V1 = 16,
+        LIGHTBAR_CMD_SET_PARAMS_V1 = 17,
         LIGHTBAR_NUM_CMDS
 };
 
@@ -1421,8 +1481,40 @@ struct ec_response_rtc {
 /*****************************************************************************/
 /* Port80 log access */
 
+/* Maximum entries that can be read/written in a single command */
+#define EC_PORT80_SIZE_MAX 32
+
 /* Get last port80 code from previous boot */
 #define EC_CMD_PORT80_LAST_BOOT 0x48
+#define EC_CMD_PORT80_READ 0x48
+
+enum ec_port80_subcmd {
+        EC_PORT80_GET_INFO = 0,
+        EC_PORT80_READ_BUFFER,
+};
+
+struct ec_params_port80_read {
+        uint16_t subcmd;
+        union {
+                struct {
+                        uint32_t offset;
+                        uint32_t num_entries;
+                } read_buffer;
+        };
+} __packed;
+
+struct ec_response_port80_read {
+        union {
+                struct {
+                        uint32_t writes;
+                        uint32_t history_size;
+                        uint32_t last_boot;
+                } get_info;
+                struct {
+                        uint16_t codes[EC_PORT80_SIZE_MAX];
+                } data;
+        };
+} __packed;
 
 struct ec_response_port80_last_boot {
         uint16_t code;
@@ -1782,6 +1874,7 @@ struct ec_params_gpio_set {
 /* Get GPIO value */
 #define EC_CMD_GPIO_GET 0x93
 
+/* Version 0 of input params and response */
 struct ec_params_gpio_get {
         char name[32];
 } __packed;
@@ -1789,6 +1882,38 @@ struct ec_response_gpio_get {
         uint8_t val;
 } __packed;
 
+/* Version 1 of input params and response */
+struct ec_params_gpio_get_v1 {
+        uint8_t subcmd;
+        union {
+                struct {
+                        char name[32];
+                } get_value_by_name;
+                struct {
+                        uint8_t index;
+                } get_info;
+        };
+} __packed;
+
+struct ec_response_gpio_get_v1 {
+        union {
+                struct {
+                        uint8_t val;
+                } get_value_by_name, get_count;
+                struct {
+                        uint8_t val;
+                        char name[32];
+                        uint32_t flags;
+                } get_info;
+        };
+} __packed;
+
+enum gpio_get_subcmd {
+        EC_GPIO_GET_BY_NAME = 0,
+        EC_GPIO_GET_COUNT = 1,
+        EC_GPIO_GET_INFO = 2,
+};
+
 /*****************************************************************************/
 /* I2C commands. Only available when flash write protect is unlocked. */
 
@@ -1857,13 +1982,21 @@ struct ec_params_charge_control {
 /*****************************************************************************/
 
 /*
- * Cut off battery power output if the battery supports.
+ * Cut off battery power immediately or after the host has shut down.
  *
- * For unsupported battery, just don't implement this command and lets EC
- * return EC_RES_INVALID_COMMAND.
+ * return EC_RES_INVALID_COMMAND if unsupported by a board/battery.
+ *        EC_RES_SUCCESS if the command was successful.
+ *        EC_RES_ERROR if the cut off command failed.
  */
+
 #define EC_CMD_BATTERY_CUT_OFF 0x99
 
+#define EC_BATTERY_CUTOFF_FLAG_AT_SHUTDOWN      (1 << 0)
+
+struct ec_params_battery_cutoff {
+        uint8_t flags;
+} __packed;
+
 /*****************************************************************************/
 /* USB port mux control. */
 
@@ -2142,6 +2275,32 @@ struct ec_params_sb_wr_block {
 } __packed;
 
 /*****************************************************************************/
+/* Battery vendor parameters
+ *
+ * Get or set vendor-specific parameters in the battery. Implementations may
+ * differ between boards or batteries. On a set operation, the response
+ * contains the actual value set, which may be rounded or clipped from the
+ * requested value.
+ */
+
+#define EC_CMD_BATTERY_VENDOR_PARAM 0xb4
+
+enum ec_battery_vendor_param_mode {
+        BATTERY_VENDOR_PARAM_MODE_GET = 0,
+        BATTERY_VENDOR_PARAM_MODE_SET,
+};
+
+struct ec_params_battery_vendor_param {
+        uint32_t param;
+        uint32_t value;
+        uint8_t mode;
+} __packed;
+
+struct ec_response_battery_vendor_param {
+        uint32_t value;
+} __packed;
+
+/*****************************************************************************/
 /* System commands */
 
 /*
@@ -2338,6 +2497,80 @@ struct ec_params_reboot_ec {
 
 /*****************************************************************************/
 /*
+ * PD commands
+ *
+ * These commands are for PD MCU communication.
+ */
+
+/* EC to PD MCU exchange status command */
+#define EC_CMD_PD_EXCHANGE_STATUS 0x100
+
+/* Status of EC being sent to PD */
+struct ec_params_pd_status {
+        int8_t batt_soc; /* battery state of charge */
+} __packed;
+
+/* Status of PD being sent back to EC */
+struct ec_response_pd_status {
+        int8_t status;        /* PD MCU status */
+        uint32_t curr_lim_ma; /* input current limit */
+} __packed;
+
+/* Set USB type-C port role and muxes */
+#define EC_CMD_USB_PD_CONTROL 0x101
+
+enum usb_pd_control_role {
+        USB_PD_CTRL_ROLE_NO_CHANGE = 0,
+        USB_PD_CTRL_ROLE_TOGGLE_ON = 1, /* == AUTO */
+        USB_PD_CTRL_ROLE_TOGGLE_OFF = 2,
+        USB_PD_CTRL_ROLE_FORCE_SINK = 3,
+        USB_PD_CTRL_ROLE_FORCE_SOURCE = 4,
+};
+
+enum usb_pd_control_mux {
+        USB_PD_CTRL_MUX_NO_CHANGE = 0,
+        USB_PD_CTRL_MUX_NONE = 1,
+        USB_PD_CTRL_MUX_USB = 2,
+        USB_PD_CTRL_MUX_DP = 3,
+        USB_PD_CTRL_MUX_DOCK = 4,
+        USB_PD_CTRL_MUX_AUTO = 5,
+};
+
+struct ec_params_usb_pd_control {
+        uint8_t port;
+        uint8_t role;
+        uint8_t mux;
+} __packed;
+
+/*****************************************************************************/
+/*
+ * Passthru commands
+ *
+ * Some platforms have sub-processors chained to each other.  For example.
+ *
+ *     AP <--> EC <--> PD MCU
+ *
+ * The top 2 bits of the command number are used to indicate which device the
+ * command is intended for.  Device 0 is always the device receiving the
+ * command; other device mapping is board-specific.
+ *
+ * When a device receives a command to be passed to a sub-processor, it passes
+ * it on with the device number set back to 0.  This allows the sub-processor
+ * to remain blissfully unaware of whether the command originated on the next
+ * device up the chain, or was passed through from the AP.
+ *
+ * In the above example, if the AP wants to send command 0x0002 to the PD MCU,
+ *     AP sends command 0x4002 to the EC
+ *     EC sends command 0x0002 to the PD MCU
+ *     EC forwards PD MCU response back to the AP
+ */
+
+/* Offset and max command number for sub-device n */
+#define EC_CMD_PASSTHRU_OFFSET(n) (0x4000 * (n))
+#define EC_CMD_PASSTHRU_MAX(n) (EC_CMD_PASSTHRU_OFFSET(n) + 0x3fff)
+
+/*****************************************************************************/
+/*
  * Deprecated constants. These constants have been renamed for clarity. The
  * meaning and size has not changed. Programs that use the old names should
  * switch to the new names soon, as the old names may not be carried forward
diff --git a/include/linux/mfd/da9055/core.h b/include/linux/mfd/da9055/core.h
index 956afa445998..5dc743fd63a6 100644
--- a/include/linux/mfd/da9055/core.h
+++ b/include/linux/mfd/da9055/core.h
@@ -89,6 +89,6 @@ static inline int da9055_reg_update(struct da9055 *da9055, unsigned char reg,
 int da9055_device_init(struct da9055 *da9055);
 void da9055_device_exit(struct da9055 *da9055);
 
-extern struct regmap_config da9055_regmap_config;
+extern const struct regmap_config da9055_regmap_config;
 
 #endif /* __DA9055_CORE_H */
diff --git a/include/linux/mfd/da9063/pdata.h b/include/linux/mfd/da9063/pdata.h
index 95c8742215a7..612383bd80ae 100644
--- a/include/linux/mfd/da9063/pdata.h
+++ b/include/linux/mfd/da9063/pdata.h
@@ -103,6 +103,7 @@ struct da9063;
 struct da9063_pdata {
         int                             (*init)(struct da9063 *da9063);
         int                             irq_base;
+        bool                            key_power;
         unsigned                        flags;
         struct da9063_regulators_pdata  *regulators_pdata;
         struct led_platform_data        *leds_pdata;
diff --git a/include/linux/mfd/max77686.h b/include/linux/mfd/max77686.h
index bb995ab9a575..d4b72d519115 100644
--- a/include/linux/mfd/max77686.h
+++ b/include/linux/mfd/max77686.h
@@ -125,9 +125,4 @@ enum max77686_opmode {
         MAX77686_OPMODE_STANDBY,
 };
 
-struct max77686_opmode_data {
-        int id;
-        int mode;
-};
-
 #endif /* __LINUX_MFD_MAX77686_H */
diff --git a/include/linux/mfd/stmpe.h b/include/linux/mfd/stmpe.h
index c9d869027300..cb83883918a7 100644
--- a/include/linux/mfd/stmpe.h
+++ b/include/linux/mfd/stmpe.h
@@ -118,47 +118,6 @@ extern int stmpe_disable(struct stmpe *stmpe, unsigned int blocks);
 #define STMPE_GPIO_NOREQ_811_TOUCH      (0xf0)
 
 /**
- * struct stmpe_ts_platform_data - stmpe811 touch screen controller platform
- * data
- * @sample_time: ADC converstion time in number of clock.
- * (0 -> 36 clocks, 1 -> 44 clocks, 2 -> 56 clocks, 3 -> 64 clocks,
- * 4 -> 80 clocks, 5 -> 96 clocks, 6 -> 144 clocks),
- * recommended is 4.
- * @mod_12b: ADC Bit mode (0 -> 10bit ADC, 1 -> 12bit ADC)
- * @ref_sel: ADC reference source
- * (0 -> internal reference, 1 -> external reference)
- * @adc_freq: ADC Clock speed
- * (0 -> 1.625 MHz, 1 -> 3.25 MHz, 2 || 3 -> 6.5 MHz)
- * @ave_ctrl: Sample average control
- * (0 -> 1 sample, 1 -> 2 samples, 2 -> 4 samples, 3 -> 8 samples)
- * @touch_det_delay: Touch detect interrupt delay
- * (0 -> 10 us, 1 -> 50 us, 2 -> 100 us, 3 -> 500 us,
- * 4-> 1 ms, 5 -> 5 ms, 6 -> 10 ms, 7 -> 50 ms)
- * recommended is 3
- * @settling: Panel driver settling time
- * (0 -> 10 us, 1 -> 100 us, 2 -> 500 us, 3 -> 1 ms,
- * 4 -> 5 ms, 5 -> 10 ms, 6 for 50 ms, 7 -> 100 ms)
- * recommended is 2
- * @fraction_z: Length of the fractional part in z
- * (fraction_z ([0..7]) = Count of the fractional part)
- * recommended is 7
- * @i_drive: current limit value of the touchscreen drivers
- * (0 -> 20 mA typical 35 mA max, 1 -> 50 mA typical 80 mA max)
- *
- * */
-struct stmpe_ts_platform_data {
-       u8 sample_time;
-       u8 mod_12b;
-       u8 ref_sel;
-       u8 adc_freq;
-       u8 ave_ctrl;
-       u8 touch_det_delay;
-       u8 settling;
-       u8 fraction_z;
-       u8 i_drive;
-};
-
-/**
  * struct stmpe_platform_data - STMPE platform data
  * @id: device id to distinguish between multiple STMPEs on the same board
  * @blocks: bitmask of blocks to enable (use STMPE_BLOCK_*)
@@ -168,7 +127,6 @@ struct stmpe_ts_platform_data {
  * @irq_over_gpio: true if gpio is used to get irq
  * @irq_gpio: gpio number over which irq will be requested (significant only if
  *            irq_over_gpio is true)
- * @ts: touchscreen-specific platform data
  */
 struct stmpe_platform_data {
         int id;
@@ -178,8 +136,6 @@ struct stmpe_platform_data {
         bool irq_over_gpio;
         int irq_gpio;
         int autosleep_timeout;
-
-        struct stmpe_ts_platform_data *ts;
 };
 
 #endif
diff --git a/include/linux/mfd/syscon/atmel-mc.h b/include/linux/mfd/syscon/atmel-mc.h
new file mode 100644
index 000000000000..afd9b8f1e363
--- /dev/null
+++ b/include/linux/mfd/syscon/atmel-mc.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2005 Ivan Kokshaysky
+ * Copyright (C) SAN People
+ *
+ * Memory Controllers (MC, EBI, SMC, SDRAMC, BFC) - System peripherals
+ * registers.
+ * Based on AT91RM9200 datasheet revision E.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef _LINUX_MFD_SYSCON_ATMEL_MC_H_
+#define _LINUX_MFD_SYSCON_ATMEL_MC_H_
+
+/* Memory Controller */
+#define AT91_MC_RCR                     0x00
+#define AT91_MC_RCB                     BIT(0)
+
+#define AT91_MC_ASR                     0x04
+#define AT91_MC_UNADD                   BIT(0)
+#define AT91_MC_MISADD                  BIT(1)
+#define AT91_MC_ABTSZ                   GENMASK(9, 8)
+#define AT91_MC_ABTSZ_BYTE              (0 << 8)
+#define AT91_MC_ABTSZ_HALFWORD          (1 << 8)
+#define AT91_MC_ABTSZ_WORD              (2 << 8)
+#define AT91_MC_ABTTYP                  GENMASK(11, 10)
+#define AT91_MC_ABTTYP_DATAREAD         (0 << 10)
+#define AT91_MC_ABTTYP_DATAWRITE        (1 << 10)
+#define AT91_MC_ABTTYP_FETCH            (2 << 10)
+#define AT91_MC_MST(n)                  BIT(16 + (n))
+#define AT91_MC_SVMST(n)                BIT(24 + (n))
+
+#define AT91_MC_AASR                    0x08
+
+#define AT91_MC_MPR                     0x0c
+#define AT91_MPR_MSTP(n)                GENMASK(2 + ((x) * 4), ((x) * 4))
+
+/* External Bus Interface (EBI) registers */
+#define AT91_MC_EBI_CSA                 0x60
+#define AT91_MC_EBI_CS(n)               BIT(x)
+#define AT91_MC_EBI_NUM_CS              8
+
+#define AT91_MC_EBI_CFGR                0x64
+#define AT91_MC_EBI_DBPUC               BIT(0)
+
+/* Static Memory Controller (SMC) registers */
+#define AT91_MC_SMC_CSR(n)              (0x70 + ((n) * 4))
+#define AT91_MC_SMC_NWS                 GENMASK(6, 0)
+#define AT91_MC_SMC_NWS_(x)             ((x) << 0)
+#define AT91_MC_SMC_WSEN                BIT(7)
+#define AT91_MC_SMC_TDF                 GENMASK(11, 8)
+#define AT91_MC_SMC_TDF_(x)             ((x) << 8)
+#define AT91_MC_SMC_TDF_MAX             0xf
+#define AT91_MC_SMC_BAT                 BIT(12)
+#define AT91_MC_SMC_DBW                 GENMASK(14, 13)
+#define AT91_MC_SMC_DBW_16              (1 << 13)
+#define AT91_MC_SMC_DBW_8               (2 << 13)
+#define AT91_MC_SMC_DPR                 BIT(15)
+#define AT91_MC_SMC_ACSS                GENMASK(17, 16)
+#define AT91_MC_SMC_ACSS_(x)            ((x) << 16)
+#define AT91_MC_SMC_ACSS_MAX            3
+#define AT91_MC_SMC_RWSETUP             GENMASK(26, 24)
+#define AT91_MC_SMC_RWSETUP_(x)         ((x) << 24)
+#define AT91_MC_SMC_RWHOLD              GENMASK(30, 28)
+#define AT91_MC_SMC_RWHOLD_(x)          ((x) << 28)
+#define AT91_MC_SMC_RWHOLDSETUP_MAX     7
+
+/* SDRAM Controller registers */
+#define AT91_MC_SDRAMC_MR               0x90
+#define AT91_MC_SDRAMC_MODE             GENMASK(3, 0)
+#define AT91_MC_SDRAMC_MODE_NORMAL      (0 << 0)
+#define AT91_MC_SDRAMC_MODE_NOP         (1 << 0)
+#define AT91_MC_SDRAMC_MODE_PRECHARGE   (2 << 0)
+#define AT91_MC_SDRAMC_MODE_LMR         (3 << 0)
+#define AT91_MC_SDRAMC_MODE_REFRESH     (4 << 0)
+#define AT91_MC_SDRAMC_DBW_16           BIT(4)
+
+#define AT91_MC_SDRAMC_TR               0x94
+#define AT91_MC_SDRAMC_COUNT            GENMASK(11, 0)
+
+#define AT91_MC_SDRAMC_CR               0x98
+#define AT91_MC_SDRAMC_NC               GENMASK(1, 0)
+#define AT91_MC_SDRAMC_NC_8             (0 << 0)
+#define AT91_MC_SDRAMC_NC_9             (1 << 0)
+#define AT91_MC_SDRAMC_NC_10            (2 << 0)
+#define AT91_MC_SDRAMC_NC_11            (3 << 0)
+#define AT91_MC_SDRAMC_NR               GENMASK(3, 2)
+#define AT91_MC_SDRAMC_NR_11            (0 << 2)
+#define AT91_MC_SDRAMC_NR_12            (1 << 2)
+#define AT91_MC_SDRAMC_NR_13            (2 << 2)
+#define AT91_MC_SDRAMC_NB               BIT(4)
+#define AT91_MC_SDRAMC_NB_2             (0 << 4)
+#define AT91_MC_SDRAMC_NB_4             (1 << 4)
+#define AT91_MC_SDRAMC_CAS              GENMASK(6, 5)
+#define AT91_MC_SDRAMC_CAS_2            (2 << 5)
+#define AT91_MC_SDRAMC_TWR              GENMASK(10,  7)
+#define AT91_MC_SDRAMC_TRC              GENMASK(14, 11)
+#define AT91_MC_SDRAMC_TRP              GENMASK(18, 15)
+#define AT91_MC_SDRAMC_TRCD             GENMASK(22, 19)
+#define AT91_MC_SDRAMC_TRAS             GENMASK(26, 23)
+#define AT91_MC_SDRAMC_TXSR             GENMASK(30, 27)
+
+#define AT91_MC_SDRAMC_SRR              0x9c
+#define AT91_MC_SDRAMC_SRCB             BIT(0)
+
+#define AT91_MC_SDRAMC_LPR              0xa0
+#define AT91_MC_SDRAMC_LPCB             BIT(0)
+
+#define AT91_MC_SDRAMC_IER              0xa4
+#define AT91_MC_SDRAMC_IDR              0xa8
+#define AT91_MC_SDRAMC_IMR              0xac
+#define AT91_MC_SDRAMC_ISR              0xb0
+#define AT91_MC_SDRAMC_RES              BIT(0)
+
+/* Burst Flash Controller register */
+#define AT91_MC_BFC_MR                  0xc0
+#define AT91_MC_BFC_BFCOM               GENMASK(1, 0)
+#define AT91_MC_BFC_BFCOM_DISABLED      (0 << 0)
+#define AT91_MC_BFC_BFCOM_ASYNC         (1 << 0)
+#define AT91_MC_BFC_BFCOM_BURST         (2 << 0)
+#define AT91_MC_BFC_BFCC                GENMASK(3, 2)
+#define AT91_MC_BFC_BFCC_MCK            (1 << 2)
+#define AT91_MC_BFC_BFCC_DIV2           (2 << 2)
+#define AT91_MC_BFC_BFCC_DIV4           (3 << 2)
+#define AT91_MC_BFC_AVL                 GENMASK(7,  4)
+#define AT91_MC_BFC_PAGES               GENMASK(10, 8)
+#define AT91_MC_BFC_PAGES_NO_PAGE       (0 << 8)
+#define AT91_MC_BFC_PAGES_16            (1 << 8)
+#define AT91_MC_BFC_PAGES_32            (2 << 8)
+#define AT91_MC_BFC_PAGES_64            (3 << 8)
+#define AT91_MC_BFC_PAGES_128           (4 << 8)
+#define AT91_MC_BFC_PAGES_256           (5 << 8)
+#define AT91_MC_BFC_PAGES_512           (6 << 8)
+#define AT91_MC_BFC_PAGES_1024          (7 << 8)
+#define AT91_MC_BFC_OEL                 GENMASK(13, 12)
+#define AT91_MC_BFC_BAAEN               BIT(16)
+#define AT91_MC_BFC_BFOEH               BIT(17)
+#define AT91_MC_BFC_MUXEN               BIT(18)
+#define AT91_MC_BFC_RDYEN               BIT(19)
+
+#endif /* _LINUX_MFD_SYSCON_ATMEL_MC_H_ */
diff --git a/include/linux/mlx4/cmd.h b/include/linux/mlx4/cmd.h
index f62e7cf227c6..58391f2e0414 100644
--- a/include/linux/mlx4/cmd.h
+++ b/include/linux/mlx4/cmd.h
@@ -35,6 +35,8 @@
 
 #include <linux/dma-mapping.h>
 #include <linux/if_link.h>
+#include <linux/mlx4/device.h>
+#include <linux/netdevice.h>
 
 enum {
         /* initialization and general commands */
@@ -300,6 +302,10 @@ static inline int mlx4_cmd_imm(struct mlx4_dev *dev, u64 in_param, u64 *out_para
 struct mlx4_cmd_mailbox *mlx4_alloc_cmd_mailbox(struct mlx4_dev *dev);
 void mlx4_free_cmd_mailbox(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox);
 
+int mlx4_get_counter_stats(struct mlx4_dev *dev, int counter_index,
+                           struct mlx4_counter *counter_stats, int reset);
+int mlx4_get_vf_stats(struct mlx4_dev *dev, int port, int vf_idx,
+                      struct ifla_vf_stats *vf_stats);
 u32 mlx4_comm_get_version(void);
 int mlx4_set_vf_mac(struct mlx4_dev *dev, int port, int vf, u64 mac);
 int mlx4_set_vf_vlan(struct mlx4_dev *dev, int port, int vf, u16 vlan, u8 qos);
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 83e80ab94500..fd13c1ce3b4a 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -46,8 +46,9 @@
 
 #define MAX_MSIX_P_PORT         17
 #define MAX_MSIX                64
-#define MSIX_LEGACY_SZ          4
 #define MIN_MSIX_P_PORT         5
+#define MLX4_IS_LEGACY_EQ_MODE(dev_cap) ((dev_cap).num_comp_vectors < \
+                                         (dev_cap).num_ports * MIN_MSIX_P_PORT)
 
 #define MLX4_MAX_100M_UNITS_VAL         255     /*
                                                  * work around: can't set values
@@ -528,7 +529,6 @@ struct mlx4_caps {
         int                     num_eqs;
         int                     reserved_eqs;
         int                     num_comp_vectors;
-        int                     comp_pool;
         int                     num_mpts;
         int                     max_fmr_maps;
         int                     num_mtts;
@@ -771,6 +771,14 @@ union mlx4_ext_av {
         struct mlx4_eth_av      eth;
 };
 
+/* Counters should be saturate once they reach their maximum value */
+#define ASSIGN_32BIT_COUNTER(counter, value) do {       \
+        if ((value) > U32_MAX)                          \
+                counter = cpu_to_be32(U32_MAX);         \
+        else                                            \
+                counter = cpu_to_be32(value);           \
+} while (0)
+
 struct mlx4_counter {
         u8      reserved1[3];
         u8      counter_mode;
@@ -829,6 +837,12 @@ struct mlx4_dev {
         struct mlx4_vf_dev     *dev_vfs;
 };
 
+struct mlx4_clock_params {
+        u64 offset;
+        u8 bar;
+        u8 size;
+};
+
 struct mlx4_eqe {
         u8                      reserved1;
         u8                      type;
@@ -957,6 +971,7 @@ struct mlx4_mad_ifc {
                         ((dev)->caps.flags & MLX4_DEV_CAP_FLAG_IBOE))
 
 #define MLX4_INVALID_SLAVE_ID   0xFF
+#define MLX4_SINK_COUNTER_INDEX(dev)    (dev->caps.max_counters - 1)
 
 void handle_port_mgmt_change_event(struct work_struct *work);
 
@@ -1332,10 +1347,13 @@ void mlx4_fmr_unmap(struct mlx4_dev *dev, struct mlx4_fmr *fmr,
 int mlx4_fmr_free(struct mlx4_dev *dev, struct mlx4_fmr *fmr);
 int mlx4_SYNC_TPT(struct mlx4_dev *dev);
 int mlx4_test_interrupts(struct mlx4_dev *dev);
-int mlx4_assign_eq(struct mlx4_dev *dev, char *name, struct cpu_rmap *rmap,
-                   int *vector);
+u32 mlx4_get_eqs_per_port(struct mlx4_dev *dev, u8 port);
+bool mlx4_is_eq_vector_valid(struct mlx4_dev *dev, u8 port, int vector);
+struct cpu_rmap *mlx4_get_cpu_rmap(struct mlx4_dev *dev, int port);
+int mlx4_assign_eq(struct mlx4_dev *dev, u8 port, int *vector);
 void mlx4_release_eq(struct mlx4_dev *dev, int vec);
 
+int mlx4_is_eq_shared(struct mlx4_dev *dev, int vector);
 int mlx4_eq_get_irq(struct mlx4_dev *dev, int vec);
 
 int mlx4_get_phys_port_id(struct mlx4_dev *dev);
@@ -1344,6 +1362,7 @@ int mlx4_wol_write(struct mlx4_dev *dev, u64 config, int port);
 
 int mlx4_counter_alloc(struct mlx4_dev *dev, u32 *idx);
 void mlx4_counter_free(struct mlx4_dev *dev, u32 idx);
+int mlx4_get_default_counter_index(struct mlx4_dev *dev, int port);
 
 void mlx4_set_admin_guid(struct mlx4_dev *dev, __be64 guid, int entry,
                          int port);
@@ -1485,4 +1504,7 @@ int mlx4_ACCESS_PTYS_REG(struct mlx4_dev *dev,
                          enum mlx4_access_reg_method method,
                          struct mlx4_ptys_reg *ptys_reg);
 
+int mlx4_get_internal_clock_params(struct mlx4_dev *dev,
+                                   struct mlx4_clock_params *params);
+
 #endif /* MLX4_DEVICE_H */
diff --git a/include/linux/mlx5/cq.h b/include/linux/mlx5/cq.h
index 2695ced222df..abc4767695e4 100644
--- a/include/linux/mlx5/cq.h
+++ b/include/linux/mlx5/cq.h
@@ -169,6 +169,9 @@ int mlx5_core_query_cq(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq,
                        struct mlx5_query_cq_mbox_out *out);
 int mlx5_core_modify_cq(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq,
                         struct mlx5_modify_cq_mbox_in *in, int in_sz);
+int mlx5_core_modify_cq_moderation(struct mlx5_core_dev *dev,
+                                   struct mlx5_core_cq *cq, u16 cq_period,
+                                   u16 cq_max_count);
 int mlx5_debug_cq_add(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq);
 void mlx5_debug_cq_remove(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq);
 
diff --git a/include/linux/mlx5/device.h b/include/linux/mlx5/device.h
index abf65c790421..b943cd9e2097 100644
--- a/include/linux/mlx5/device.h
+++ b/include/linux/mlx5/device.h
@@ -35,6 +35,7 @@
 
 #include <linux/types.h>
 #include <rdma/ib_verbs.h>
+#include <linux/mlx5/mlx5_ifc.h>
 
 #if defined(__LITTLE_ENDIAN)
 #define MLX5_SET_HOST_ENDIANNESS        0
@@ -58,6 +59,8 @@
 #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_UN_SZ_BYTES(typ) (sizeof(union mlx5_ifc_##typ##_bits) / 8)
+#define MLX5_UN_SZ_DW(typ) (sizeof(union 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))
 
@@ -70,6 +73,14 @@
                      << __mlx5_dw_bit_off(typ, fld))); \
 } while (0)
 
+#define MLX5_SET_TO_ONES(typ, p, fld) 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))) | ((__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))
@@ -88,6 +99,12 @@ __mlx5_mask(typ, fld))
 
 #define MLX5_GET64(typ, p, fld) be64_to_cpu(*((__be64 *)(p) + __mlx5_64_off(typ, fld)))
 
+#define MLX5_GET64_PR(typ, p, fld) ({ \
+        u64 ___t = MLX5_GET64(typ, p, fld); \
+        pr_debug(#fld " = 0x%llx\n", ___t); \
+        ___t; \
+})
+
 enum {
         MLX5_MAX_COMMANDS               = 32,
         MLX5_CMD_DATA_BLOCK_SIZE        = 512,
@@ -115,6 +132,10 @@ enum {
 };
 
 enum {
+        MLX5_HW_START_PADDING = MLX5_INLINE_SEG,
+};
+
+enum {
         MLX5_MIN_PKEY_TABLE_SIZE = 128,
         MLX5_MAX_LOG_PKEY_TABLE  = 5,
 };
@@ -264,6 +285,7 @@ enum {
         MLX5_OPCODE_RDMA_WRITE_IMM      = 0x09,
         MLX5_OPCODE_SEND                = 0x0a,
         MLX5_OPCODE_SEND_IMM            = 0x0b,
+        MLX5_OPCODE_LSO                 = 0x0e,
         MLX5_OPCODE_RDMA_READ           = 0x10,
         MLX5_OPCODE_ATOMIC_CS           = 0x11,
         MLX5_OPCODE_ATOMIC_FA           = 0x12,
@@ -312,13 +334,6 @@ enum {
         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];
@@ -541,6 +556,10 @@ struct mlx5_cmd_prot_block {
         u8              sig;
 };
 
+enum {
+        MLX5_CQE_SYND_FLUSHED_IN_ERROR = 5,
+};
+
 struct mlx5_err_cqe {
         u8      rsvd0[32];
         __be32  srqn;
@@ -554,13 +573,22 @@ struct mlx5_err_cqe {
 };
 
 struct mlx5_cqe64 {
-        u8              rsvd0[17];
+        u8              rsvd0[4];
+        u8              lro_tcppsh_abort_dupack;
+        u8              lro_min_ttl;
+        __be16          lro_tcp_win;
+        __be32          lro_ack_seq_num;
+        __be32          rss_hash_result;
+        u8              rss_hash_type;
         u8              ml_path;
-        u8              rsvd20[4];
+        u8              rsvd20[2];
+        __be16          check_sum;
         __be16          slid;
         __be32          flags_rqpn;
-        u8              rsvd28[4];
-        __be32          srqn;
+        u8              hds_ip_ext;
+        u8              l4_hdr_type_etc;
+        __be16          vlan_info;
+        __be32          srqn; /* [31:24]: lro_num_seg, [23:0]: srqn */
         __be32          imm_inval_pkey;
         u8              rsvd40[4];
         __be32          byte_cnt;
@@ -571,6 +599,40 @@ struct mlx5_cqe64 {
         u8              op_own;
 };
 
+static inline int get_cqe_lro_tcppsh(struct mlx5_cqe64 *cqe)
+{
+        return (cqe->lro_tcppsh_abort_dupack >> 6) & 1;
+}
+
+static inline u8 get_cqe_l4_hdr_type(struct mlx5_cqe64 *cqe)
+{
+        return (cqe->l4_hdr_type_etc >> 4) & 0x7;
+}
+
+static inline int cqe_has_vlan(struct mlx5_cqe64 *cqe)
+{
+        return !!(cqe->l4_hdr_type_etc & 0x1);
+}
+
+enum {
+        CQE_L4_HDR_TYPE_NONE                    = 0x0,
+        CQE_L4_HDR_TYPE_TCP_NO_ACK              = 0x1,
+        CQE_L4_HDR_TYPE_UDP                     = 0x2,
+        CQE_L4_HDR_TYPE_TCP_ACK_NO_DATA         = 0x3,
+        CQE_L4_HDR_TYPE_TCP_ACK_AND_DATA        = 0x4,
+};
+
+enum {
+        CQE_RSS_HTYPE_IP        = 0x3 << 6,
+        CQE_RSS_HTYPE_L4        = 0x3 << 2,
+};
+
+enum {
+        CQE_L2_OK       = 1 << 0,
+        CQE_L3_OK       = 1 << 1,
+        CQE_L4_OK       = 1 << 2,
+};
+
 struct mlx5_sig_err_cqe {
         u8              rsvd0[16];
         __be32          expected_trans_sig;
@@ -996,4 +1058,135 @@ struct mlx5_destroy_psv_out {
         u8                      rsvd[8];
 };
 
+#define MLX5_CMD_OP_MAX 0x920
+
+enum {
+        VPORT_STATE_DOWN                = 0x0,
+        VPORT_STATE_UP                  = 0x1,
+};
+
+enum {
+        MLX5_L3_PROT_TYPE_IPV4          = 0,
+        MLX5_L3_PROT_TYPE_IPV6          = 1,
+};
+
+enum {
+        MLX5_L4_PROT_TYPE_TCP           = 0,
+        MLX5_L4_PROT_TYPE_UDP           = 1,
+};
+
+enum {
+        MLX5_HASH_FIELD_SEL_SRC_IP      = 1 << 0,
+        MLX5_HASH_FIELD_SEL_DST_IP      = 1 << 1,
+        MLX5_HASH_FIELD_SEL_L4_SPORT    = 1 << 2,
+        MLX5_HASH_FIELD_SEL_L4_DPORT    = 1 << 3,
+        MLX5_HASH_FIELD_SEL_IPSEC_SPI   = 1 << 4,
+};
+
+enum {
+        MLX5_MATCH_OUTER_HEADERS        = 1 << 0,
+        MLX5_MATCH_MISC_PARAMETERS      = 1 << 1,
+        MLX5_MATCH_INNER_HEADERS        = 1 << 2,
+
+};
+
+enum {
+        MLX5_FLOW_TABLE_TYPE_NIC_RCV    = 0,
+        MLX5_FLOW_TABLE_TYPE_ESWITCH    = 4,
+};
+
+enum {
+        MLX5_FLOW_CONTEXT_DEST_TYPE_VPORT       = 0,
+        MLX5_FLOW_CONTEXT_DEST_TYPE_FLOW_TABLE  = 1,
+        MLX5_FLOW_CONTEXT_DEST_TYPE_TIR         = 2,
+};
+
+enum {
+        MLX5_RQC_RQ_TYPE_MEMORY_RQ_INLINE = 0x0,
+        MLX5_RQC_RQ_TYPE_MEMORY_RQ_RPM    = 0x1,
+};
+
+/* MLX5 DEV CAPs */
+
+/* TODO: EAT.ME */
+enum mlx5_cap_mode {
+        HCA_CAP_OPMOD_GET_MAX   = 0,
+        HCA_CAP_OPMOD_GET_CUR   = 1,
+};
+
+enum mlx5_cap_type {
+        MLX5_CAP_GENERAL = 0,
+        MLX5_CAP_ETHERNET_OFFLOADS,
+        MLX5_CAP_ODP,
+        MLX5_CAP_ATOMIC,
+        MLX5_CAP_ROCE,
+        MLX5_CAP_IPOIB_OFFLOADS,
+        MLX5_CAP_EOIB_OFFLOADS,
+        MLX5_CAP_FLOW_TABLE,
+        /* NUM OF CAP Types */
+        MLX5_CAP_NUM
+};
+
+/* GET Dev Caps macros */
+#define MLX5_CAP_GEN(mdev, cap) \
+        MLX5_GET(cmd_hca_cap, mdev->hca_caps_cur[MLX5_CAP_GENERAL], cap)
+
+#define MLX5_CAP_GEN_MAX(mdev, cap) \
+        MLX5_GET(cmd_hca_cap, mdev->hca_caps_max[MLX5_CAP_GENERAL], cap)
+
+#define MLX5_CAP_ETH(mdev, cap) \
+        MLX5_GET(per_protocol_networking_offload_caps,\
+                 mdev->hca_caps_cur[MLX5_CAP_ETHERNET_OFFLOADS], cap)
+
+#define MLX5_CAP_ETH_MAX(mdev, cap) \
+        MLX5_GET(per_protocol_networking_offload_caps,\
+                 mdev->hca_caps_max[MLX5_CAP_ETHERNET_OFFLOADS], cap)
+
+#define MLX5_CAP_ROCE(mdev, cap) \
+        MLX5_GET(roce_cap, mdev->hca_caps_cur[MLX5_CAP_ROCE], cap)
+
+#define MLX5_CAP_ROCE_MAX(mdev, cap) \
+        MLX5_GET(roce_cap, mdev->hca_caps_max[MLX5_CAP_ROCE], cap)
+
+#define MLX5_CAP_ATOMIC(mdev, cap) \
+        MLX5_GET(atomic_caps, mdev->hca_caps_cur[MLX5_CAP_ATOMIC], cap)
+
+#define MLX5_CAP_ATOMIC_MAX(mdev, cap) \
+        MLX5_GET(atomic_caps, mdev->hca_caps_max[MLX5_CAP_ATOMIC], cap)
+
+#define MLX5_CAP_FLOWTABLE(mdev, cap) \
+        MLX5_GET(flow_table_nic_cap, mdev->hca_caps_cur[MLX5_CAP_FLOW_TABLE], cap)
+
+#define MLX5_CAP_FLOWTABLE_MAX(mdev, cap) \
+        MLX5_GET(flow_table_nic_cap, mdev->hca_caps_max[MLX5_CAP_FLOW_TABLE], cap)
+
+#define MLX5_CAP_ODP(mdev, cap)\
+        MLX5_GET(odp_cap, mdev->hca_caps_cur[MLX5_CAP_ODP], cap)
+
+enum {
+        MLX5_CMD_STAT_OK                        = 0x0,
+        MLX5_CMD_STAT_INT_ERR                   = 0x1,
+        MLX5_CMD_STAT_BAD_OP_ERR                = 0x2,
+        MLX5_CMD_STAT_BAD_PARAM_ERR             = 0x3,
+        MLX5_CMD_STAT_BAD_SYS_STATE_ERR         = 0x4,
+        MLX5_CMD_STAT_BAD_RES_ERR               = 0x5,
+        MLX5_CMD_STAT_RES_BUSY                  = 0x6,
+        MLX5_CMD_STAT_LIM_ERR                   = 0x8,
+        MLX5_CMD_STAT_BAD_RES_STATE_ERR         = 0x9,
+        MLX5_CMD_STAT_IX_ERR                    = 0xa,
+        MLX5_CMD_STAT_NO_RES_ERR                = 0xf,
+        MLX5_CMD_STAT_BAD_INP_LEN_ERR           = 0x50,
+        MLX5_CMD_STAT_BAD_OUTP_LEN_ERR          = 0x51,
+        MLX5_CMD_STAT_BAD_QP_STATE_ERR          = 0x10,
+        MLX5_CMD_STAT_BAD_PKT_ERR               = 0x30,
+        MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR    = 0x40,
+};
+
+static inline u16 mlx5_to_sw_pkey_sz(int pkey_sz)
+{
+        if (pkey_sz > MLX5_MAX_LOG_PKEY_TABLE)
+                return 0;
+        return MLX5_MIN_PKEY_TABLE_SIZE << pkey_sz;
+}
+
 #endif /* MLX5_DEVICE_H */
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index 9a90e7523dc2..5722d88c2429 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -44,7 +44,6 @@
 
 #include <linux/mlx5/device.h>
 #include <linux/mlx5/doorbell.h>
-#include <linux/mlx5/mlx5_ifc.h>
 
 enum {
         MLX5_BOARD_ID_LEN = 64,
@@ -85,7 +84,7 @@ enum {
 };
 
 enum {
-        MLX5_MAX_EQ_NAME        = 32
+        MLX5_MAX_IRQ_NAME       = 32
 };
 
 enum {
@@ -108,6 +107,7 @@ enum {
         MLX5_REG_PUDE            = 0x5009,
         MLX5_REG_PMPE            = 0x5010,
         MLX5_REG_PELC            = 0x500e,
+        MLX5_REG_PVLC            = 0x500f,
         MLX5_REG_PMLP            = 0, /* TBD */
         MLX5_REG_NODE_DESC       = 0x6001,
         MLX5_REG_HOST_ENDIANNESS = 0x7004,
@@ -150,6 +150,11 @@ enum mlx5_dev_event {
         MLX5_DEV_EVENT_CLIENT_REREG,
 };
 
+enum mlx5_port_status {
+        MLX5_PORT_UP        = 1 << 1,
+        MLX5_PORT_DOWN      = 1 << 2,
+};
+
 struct mlx5_uuar_info {
         struct mlx5_uar        *uars;
         int                     num_uars;
@@ -269,56 +274,7 @@ struct mlx5_cmd {
 struct mlx5_port_caps {
         int     gid_table_len;
         int     pkey_table_len;
-};
-
-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;
-        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;
-        struct mlx5_port_caps   port[MLX5_MAX_PORTS];
-        u8                      ext_port_cap[MLX5_MAX_PORTS];
-        int     max_vf;
-        u32     reserved_lkey;
-        u8      local_ca_ack_delay;
-        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;
+        u8      ext_port_cap;
 };
 
 struct mlx5_cmd_mailbox {
@@ -334,8 +290,6 @@ struct mlx5_buf_list {
 
 struct mlx5_buf {
         struct mlx5_buf_list    direct;
-        struct mlx5_buf_list   *page_list;
-        int                     nbufs;
         int                     npages;
         int                     size;
         u8                      page_shift;
@@ -351,7 +305,6 @@ struct mlx5_eq {
         u8                      eqn;
         int                     nent;
         u64                     mask;
-        char                    name[MLX5_MAX_EQ_NAME];
         struct list_head        list;
         int                     index;
         struct mlx5_rsc_debug   *dbg;
@@ -387,6 +340,8 @@ struct mlx5_core_mr {
 
 enum mlx5_res_type {
         MLX5_RES_QP,
+        MLX5_RES_SRQ,
+        MLX5_RES_XSRQ,
 };
 
 struct mlx5_core_rsc_common {
@@ -396,6 +351,7 @@ struct mlx5_core_rsc_common {
 };
 
 struct mlx5_core_srq {
+        struct mlx5_core_rsc_common     common; /* must be first */
         u32             srqn;
         int             max;
         int             max_gs;
@@ -414,7 +370,6 @@ struct mlx5_eq_table {
         struct mlx5_eq          pages_eq;
         struct mlx5_eq          async_eq;
         struct mlx5_eq          cmd_eq;
-        struct msix_entry       *msix_arr;
         int                     num_comp_vectors;
         /* protect EQs list
          */
@@ -467,9 +422,16 @@ struct mlx5_mr_table {
         struct radix_tree_root  tree;
 };
 
+struct mlx5_irq_info {
+        cpumask_var_t mask;
+        char name[MLX5_MAX_IRQ_NAME];
+};
+
 struct mlx5_priv {
         char                    name[MLX5_MAX_NAME_LEN];
         struct mlx5_eq_table    eq_table;
+        struct msix_entry       *msix_arr;
+        struct mlx5_irq_info    *irq_info;
         struct mlx5_uuar_info   uuari;
         MLX5_DECLARE_DOORBELL_LOCK(cq_uar_lock);
 
@@ -520,7 +482,9 @@ struct mlx5_core_dev {
         u8                      rev_id;
         char                    board_id[MLX5_BOARD_ID_LEN];
         struct mlx5_cmd         cmd;
-        struct mlx5_caps        caps;
+        struct mlx5_port_caps   port_caps[MLX5_MAX_PORTS];
+        u32 hca_caps_cur[MLX5_CAP_NUM][MLX5_UN_SZ_DW(hca_cap_union)];
+        u32 hca_caps_max[MLX5_CAP_NUM][MLX5_UN_SZ_DW(hca_cap_union)];
         phys_addr_t             iseg_base;
         struct mlx5_init_seg __iomem *iseg;
         void                    (*event) (struct mlx5_core_dev *dev,
@@ -529,6 +493,7 @@ struct mlx5_core_dev {
         struct mlx5_priv        priv;
         struct mlx5_profile     *profile;
         atomic_t                num_qps;
+        u32                     issi;
 };
 
 struct mlx5_db {
@@ -549,6 +514,11 @@ enum {
         MLX5_COMP_EQ_SIZE = 1024,
 };
 
+enum {
+        MLX5_PTYS_IB = 1 << 0,
+        MLX5_PTYS_EN = 1 << 2,
+};
+
 struct mlx5_db_pgdir {
         struct list_head        list;
         DECLARE_BITMAP(bitmap, MLX5_DB_PER_PAGE);
@@ -584,13 +554,44 @@ struct mlx5_pas {
         u8      log_sz;
 };
 
+enum port_state_policy {
+        MLX5_AAA_000
+};
+
+enum phy_port_state {
+        MLX5_AAA_111
+};
+
+struct mlx5_hca_vport_context {
+        u32                     field_select;
+        bool                    sm_virt_aware;
+        bool                    has_smi;
+        bool                    has_raw;
+        enum port_state_policy  policy;
+        enum phy_port_state     phys_state;
+        enum ib_port_state      vport_state;
+        u8                      port_physical_state;
+        u64                     sys_image_guid;
+        u64                     port_guid;
+        u64                     node_guid;
+        u32                     cap_mask1;
+        u32                     cap_mask1_perm;
+        u32                     cap_mask2;
+        u32                     cap_mask2_perm;
+        u16                     lid;
+        u8                      init_type_reply; /* bitmask: see ib spec 14.2.5.6 InitTypeReply */
+        u8                      lmc;
+        u8                      subnet_timeout;
+        u16                     sm_lid;
+        u8                      sm_sl;
+        u16                     qkey_violation_counter;
+        u16                     pkey_violation_counter;
+        bool                    grh_required;
+};
+
 static inline void *mlx5_buf_offset(struct mlx5_buf *buf, int offset)
 {
-        if (likely(BITS_PER_LONG == 64 || buf->nbufs == 1))
                 return buf->direct.buf + offset;
-        else
-                return buf->page_list[offset >> PAGE_SHIFT].buf +
-                        (offset & (PAGE_SIZE - 1));
 }
 
 extern struct workqueue_struct *mlx5_core_wq;
@@ -654,8 +655,8 @@ 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_core_get_caps(struct mlx5_core_dev *dev, enum mlx5_cap_type cap_type,
+                       enum mlx5_cap_mode cap_mode);
 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,
@@ -665,19 +666,21 @@ int mlx5_cmd_alloc_uar(struct mlx5_core_dev *dev, u32 *uarn);
 int mlx5_cmd_free_uar(struct mlx5_core_dev *dev, u32 uarn);
 int mlx5_alloc_uuars(struct mlx5_core_dev *dev, struct mlx5_uuar_info *uuari);
 int mlx5_free_uuars(struct mlx5_core_dev *dev, struct mlx5_uuar_info *uuari);
+int mlx5_alloc_map_uar(struct mlx5_core_dev *mdev, struct mlx5_uar *uar);
+void mlx5_unmap_free_uar(struct mlx5_core_dev *mdev, struct mlx5_uar *uar);
 void mlx5_health_cleanup(void);
 void  __init mlx5_health_init(void);
 void mlx5_start_health_poll(struct mlx5_core_dev *dev);
 void mlx5_stop_health_poll(struct mlx5_core_dev *dev);
-int mlx5_buf_alloc(struct mlx5_core_dev *dev, int size, int max_direct,
-                   struct mlx5_buf *buf);
+int mlx5_buf_alloc(struct mlx5_core_dev *dev, int size, struct mlx5_buf *buf);
 void mlx5_buf_free(struct mlx5_core_dev *dev, struct mlx5_buf *buf);
 struct mlx5_cmd_mailbox *mlx5_alloc_cmd_mailbox_chain(struct mlx5_core_dev *dev,
                                                       gfp_t flags, int npages);
 void mlx5_free_cmd_mailbox_chain(struct mlx5_core_dev *dev,
                                  struct mlx5_cmd_mailbox *head);
 int mlx5_core_create_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
-                         struct mlx5_create_srq_mbox_in *in, int inlen);
+                         struct mlx5_create_srq_mbox_in *in, int inlen,
+                         int is_xrc);
 int mlx5_core_destroy_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq);
 int mlx5_core_query_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
                         struct mlx5_query_srq_mbox_out *out);
@@ -696,7 +699,7 @@ int mlx5_core_dump_fill_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mr *mr,
                              u32 *mkey);
 int mlx5_core_alloc_pd(struct mlx5_core_dev *dev, u32 *pdn);
 int mlx5_core_dealloc_pd(struct mlx5_core_dev *dev, u32 pdn);
-int mlx5_core_mad_ifc(struct mlx5_core_dev *dev, void *inb, void *outb,
+int mlx5_core_mad_ifc(struct mlx5_core_dev *dev, const void *inb, void *outb,
                       u16 opmod, u8 port);
 void mlx5_pagealloc_init(struct mlx5_core_dev *dev);
 void mlx5_pagealloc_cleanup(struct mlx5_core_dev *dev);
@@ -734,7 +737,32 @@ void mlx5_qp_debugfs_cleanup(struct mlx5_core_dev *dev);
 int mlx5_core_access_reg(struct mlx5_core_dev *dev, void *data_in,
                          int size_in, void *data_out, int size_out,
                          u16 reg_num, int arg, int write);
+
 int mlx5_set_port_caps(struct mlx5_core_dev *dev, u8 port_num, u32 caps);
+int mlx5_query_port_ptys(struct mlx5_core_dev *dev, u32 *ptys,
+                         int ptys_size, int proto_mask, u8 local_port);
+int mlx5_query_port_proto_cap(struct mlx5_core_dev *dev,
+                              u32 *proto_cap, int proto_mask);
+int mlx5_query_port_proto_admin(struct mlx5_core_dev *dev,
+                                u32 *proto_admin, int proto_mask);
+int mlx5_query_port_link_width_oper(struct mlx5_core_dev *dev,
+                                    u8 *link_width_oper, u8 local_port);
+int mlx5_query_port_proto_oper(struct mlx5_core_dev *dev,
+                               u8 *proto_oper, int proto_mask,
+                               u8 local_port);
+int mlx5_set_port_proto(struct mlx5_core_dev *dev, u32 proto_admin,
+                        int proto_mask);
+int mlx5_set_port_status(struct mlx5_core_dev *dev,
+                         enum mlx5_port_status status);
+int mlx5_query_port_status(struct mlx5_core_dev *dev, u8 *status);
+
+int mlx5_set_port_mtu(struct mlx5_core_dev *dev, int mtu, u8 port);
+void mlx5_query_port_max_mtu(struct mlx5_core_dev *dev, int *max_mtu, u8 port);
+void mlx5_query_port_oper_mtu(struct mlx5_core_dev *dev, int *oper_mtu,
+                              u8 port);
+
+int mlx5_query_port_vl_hw_cap(struct mlx5_core_dev *dev,
+                              u8 *vl_hw_cap, u8 local_port);
 
 int mlx5_debug_eq_add(struct mlx5_core_dev *dev, struct mlx5_eq *eq);
 void mlx5_debug_eq_remove(struct mlx5_core_dev *dev, struct mlx5_eq *eq);
@@ -799,6 +827,7 @@ struct mlx5_interface {
 void *mlx5_get_protocol_dev(struct mlx5_core_dev *mdev, int protocol);
 int mlx5_register_interface(struct mlx5_interface *intf);
 void mlx5_unregister_interface(struct mlx5_interface *intf);
+int mlx5_core_query_vendor_id(struct mlx5_core_dev *mdev, u32 *vendor_id);
 
 struct mlx5_profile {
         u64     mask;
@@ -809,4 +838,14 @@ struct mlx5_profile {
         } mr_cache[MAX_MR_CACHE_ENTRIES];
 };
 
+static inline int mlx5_get_gid_table_len(u16 param)
+{
+        if (param > 4) {
+                pr_warn("gid table length is zero\n");
+                return 0;
+        }
+
+        return 8 * (1 << param);
+}
+
 #endif /* MLX5_DRIVER_H */
diff --git a/include/linux/mlx5/flow_table.h b/include/linux/mlx5/flow_table.h
new file mode 100644
index 000000000000..5f922c6d4fc2
--- /dev/null
+++ b/include/linux/mlx5/flow_table.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  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_FLOW_TABLE_H
+#define MLX5_FLOW_TABLE_H
+
+#include <linux/mlx5/driver.h>
+
+struct mlx5_flow_table_group {
+        u8      log_sz;
+        u8      match_criteria_enable;
+        u32     match_criteria[MLX5_ST_SZ_DW(fte_match_param)];
+};
+
+void *mlx5_create_flow_table(struct mlx5_core_dev *dev, u8 level, u8 table_type,
+                             u16 num_groups,
+                             struct mlx5_flow_table_group *group);
+void mlx5_destroy_flow_table(void *flow_table);
+int mlx5_add_flow_table_entry(void *flow_table, u8 match_criteria_enable,
+                              void *match_criteria, void *flow_context,
+                              u32 *flow_index);
+void mlx5_del_flow_table_entry(void *flow_table, u32 flow_index);
+u32 mlx5_get_flow_table_id(void *flow_table);
+
+#endif /* MLX5_FLOW_TABLE_H */
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index cb3ad17edd1f..6d2f6fee041c 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  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
@@ -28,12 +28,45 @@
  * 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_EVENT_TYPE_CODING_COMPLETION_EVENTS                   = 0x0,
+        MLX5_EVENT_TYPE_CODING_PATH_MIGRATED_SUCCEEDED             = 0x1,
+        MLX5_EVENT_TYPE_CODING_COMMUNICATION_ESTABLISHED           = 0x2,
+        MLX5_EVENT_TYPE_CODING_SEND_QUEUE_DRAINED                  = 0x3,
+        MLX5_EVENT_TYPE_CODING_LAST_WQE_REACHED                    = 0x13,
+        MLX5_EVENT_TYPE_CODING_SRQ_LIMIT                           = 0x14,
+        MLX5_EVENT_TYPE_CODING_DCT_ALL_CONNECTIONS_CLOSED          = 0x1c,
+        MLX5_EVENT_TYPE_CODING_DCT_ACCESS_KEY_VIOLATION            = 0x1d,
+        MLX5_EVENT_TYPE_CODING_CQ_ERROR                            = 0x4,
+        MLX5_EVENT_TYPE_CODING_LOCAL_WQ_CATASTROPHIC_ERROR         = 0x5,
+        MLX5_EVENT_TYPE_CODING_PATH_MIGRATION_FAILED               = 0x7,
+        MLX5_EVENT_TYPE_CODING_PAGE_FAULT_EVENT                    = 0xc,
+        MLX5_EVENT_TYPE_CODING_INVALID_REQUEST_LOCAL_WQ_ERROR      = 0x10,
+        MLX5_EVENT_TYPE_CODING_LOCAL_ACCESS_VIOLATION_WQ_ERROR     = 0x11,
+        MLX5_EVENT_TYPE_CODING_LOCAL_SRQ_CATASTROPHIC_ERROR        = 0x12,
+        MLX5_EVENT_TYPE_CODING_INTERNAL_ERROR                      = 0x8,
+        MLX5_EVENT_TYPE_CODING_PORT_STATE_CHANGE                   = 0x9,
+        MLX5_EVENT_TYPE_CODING_GPIO_EVENT                          = 0x15,
+        MLX5_EVENT_TYPE_CODING_REMOTE_CONFIGURATION_PROTOCOL_EVENT = 0x19,
+        MLX5_EVENT_TYPE_CODING_DOORBELL_BLUEFLAME_CONGESTION_EVENT = 0x1a,
+        MLX5_EVENT_TYPE_CODING_STALL_VL_EVENT                      = 0x1b,
+        MLX5_EVENT_TYPE_CODING_DROPPED_PACKET_LOGGED_EVENT         = 0x1f,
+        MLX5_EVENT_TYPE_CODING_COMMAND_INTERFACE_COMPLETION        = 0xa,
+        MLX5_EVENT_TYPE_CODING_PAGE_REQUEST                        = 0xb
+};
+
+enum {
+        MLX5_MODIFY_TIR_BITMASK_LRO                   = 0x0,
+        MLX5_MODIFY_TIR_BITMASK_INDIRECT_TABLE        = 0x1,
+        MLX5_MODIFY_TIR_BITMASK_HASH                  = 0x2,
+        MLX5_MODIFY_TIR_BITMASK_TUNNELED_OFFLOAD_EN   = 0x3
+};
+
+enum {
         MLX5_CMD_OP_QUERY_HCA_CAP                 = 0x100,
         MLX5_CMD_OP_QUERY_ADAPTER                 = 0x101,
         MLX5_CMD_OP_INIT_HCA                      = 0x102,
@@ -43,6 +76,8 @@ enum {
         MLX5_CMD_OP_QUERY_PAGES                   = 0x107,
         MLX5_CMD_OP_MANAGE_PAGES                  = 0x108,
         MLX5_CMD_OP_SET_HCA_CAP                   = 0x109,
+        MLX5_CMD_OP_QUERY_ISSI                    = 0x10a,
+        MLX5_CMD_OP_SET_ISSI                      = 0x10b,
         MLX5_CMD_OP_CREATE_MKEY                   = 0x200,
         MLX5_CMD_OP_QUERY_MKEY                    = 0x201,
         MLX5_CMD_OP_DESTROY_MKEY                  = 0x202,
@@ -66,6 +101,7 @@ enum {
         MLX5_CMD_OP_2ERR_QP                       = 0x507,
         MLX5_CMD_OP_2RST_QP                       = 0x50a,
         MLX5_CMD_OP_QUERY_QP                      = 0x50b,
+        MLX5_CMD_OP_SQD_RTS_QP                    = 0x50c,
         MLX5_CMD_OP_INIT2INIT_QP                  = 0x50e,
         MLX5_CMD_OP_CREATE_PSV                    = 0x600,
         MLX5_CMD_OP_DESTROY_PSV                   = 0x601,
@@ -73,7 +109,10 @@ enum {
         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_XRC_SRQ                = 0x705,
+        MLX5_CMD_OP_DESTROY_XRC_SRQ               = 0x706,
+        MLX5_CMD_OP_QUERY_XRC_SRQ                 = 0x707,
+        MLX5_CMD_OP_ARM_XRC_SRQ                   = 0x708,
         MLX5_CMD_OP_CREATE_DCT                    = 0x710,
         MLX5_CMD_OP_DESTROY_DCT                   = 0x711,
         MLX5_CMD_OP_DRAIN_DCT                     = 0x712,
@@ -85,8 +124,12 @@ enum {
         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_QUERY_ROCE_ADDRESS            = 0x760,
         MLX5_CMD_OP_SET_ROCE_ADDRESS              = 0x761,
+        MLX5_CMD_OP_QUERY_HCA_VPORT_CONTEXT       = 0x762,
+        MLX5_CMD_OP_MODIFY_HCA_VPORT_CONTEXT      = 0x763,
+        MLX5_CMD_OP_QUERY_HCA_VPORT_GID           = 0x764,
+        MLX5_CMD_OP_QUERY_HCA_VPORT_PKEY          = 0x765,
         MLX5_CMD_OP_QUERY_VPORT_COUNTER           = 0x770,
         MLX5_CMD_OP_ALLOC_Q_COUNTER               = 0x771,
         MLX5_CMD_OP_DEALLOC_Q_COUNTER             = 0x772,
@@ -98,7 +141,7 @@ enum {
         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_DETTACH_FROM_MCG              = 0x807,
         MLX5_CMD_OP_GET_DROPPED_PACKET_LOG        = 0x80a,
         MLX5_CMD_OP_MAD_IFC                       = 0x50d,
         MLX5_CMD_OP_QUERY_MAD_DEMUX               = 0x80b,
@@ -106,23 +149,22 @@ enum {
         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_ALLOC_TRANSPORT_DOMAIN        = 0x816,
+        MLX5_CMD_OP_DEALLOC_TRANSPORT_DOMAIN      = 0x817,
+        MLX5_CMD_OP_QUERY_CONG_STATUS             = 0x822,
+        MLX5_CMD_OP_MODIFY_CONG_STATUS            = 0x823,
+        MLX5_CMD_OP_QUERY_CONG_PARAMS             = 0x824,
+        MLX5_CMD_OP_MODIFY_CONG_PARAMS            = 0x825,
+        MLX5_CMD_OP_QUERY_CONG_STATISTICS         = 0x826,
+        MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT           = 0x827,
+        MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT        = 0x828,
+        MLX5_CMD_OP_SET_L2_TABLE_ENTRY            = 0x829,
+        MLX5_CMD_OP_QUERY_L2_TABLE_ENTRY          = 0x82a,
+        MLX5_CMD_OP_DELETE_L2_TABLE_ENTRY         = 0x82b,
         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,
@@ -135,9 +177,430 @@ enum {
         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
+        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_RQT                    = 0x916,
+        MLX5_CMD_OP_MODIFY_RQT                    = 0x917,
+        MLX5_CMD_OP_DESTROY_RQT                   = 0x918,
+        MLX5_CMD_OP_QUERY_RQT                     = 0x919,
+        MLX5_CMD_OP_CREATE_FLOW_TABLE             = 0x930,
+        MLX5_CMD_OP_DESTROY_FLOW_TABLE            = 0x931,
+        MLX5_CMD_OP_QUERY_FLOW_TABLE              = 0x932,
+        MLX5_CMD_OP_CREATE_FLOW_GROUP             = 0x933,
+        MLX5_CMD_OP_DESTROY_FLOW_GROUP            = 0x934,
+        MLX5_CMD_OP_QUERY_FLOW_GROUP              = 0x935,
+        MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY          = 0x936,
+        MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY        = 0x937,
+        MLX5_CMD_OP_DELETE_FLOW_TABLE_ENTRY       = 0x938
+};
+
+struct mlx5_ifc_flow_table_fields_supported_bits {
+        u8         outer_dmac[0x1];
+        u8         outer_smac[0x1];
+        u8         outer_ether_type[0x1];
+        u8         reserved_0[0x1];
+        u8         outer_first_prio[0x1];
+        u8         outer_first_cfi[0x1];
+        u8         outer_first_vid[0x1];
+        u8         reserved_1[0x1];
+        u8         outer_second_prio[0x1];
+        u8         outer_second_cfi[0x1];
+        u8         outer_second_vid[0x1];
+        u8         reserved_2[0x1];
+        u8         outer_sip[0x1];
+        u8         outer_dip[0x1];
+        u8         outer_frag[0x1];
+        u8         outer_ip_protocol[0x1];
+        u8         outer_ip_ecn[0x1];
+        u8         outer_ip_dscp[0x1];
+        u8         outer_udp_sport[0x1];
+        u8         outer_udp_dport[0x1];
+        u8         outer_tcp_sport[0x1];
+        u8         outer_tcp_dport[0x1];
+        u8         outer_tcp_flags[0x1];
+        u8         outer_gre_protocol[0x1];
+        u8         outer_gre_key[0x1];
+        u8         outer_vxlan_vni[0x1];
+        u8         reserved_3[0x5];
+        u8         source_eswitch_port[0x1];
+
+        u8         inner_dmac[0x1];
+        u8         inner_smac[0x1];
+        u8         inner_ether_type[0x1];
+        u8         reserved_4[0x1];
+        u8         inner_first_prio[0x1];
+        u8         inner_first_cfi[0x1];
+        u8         inner_first_vid[0x1];
+        u8         reserved_5[0x1];
+        u8         inner_second_prio[0x1];
+        u8         inner_second_cfi[0x1];
+        u8         inner_second_vid[0x1];
+        u8         reserved_6[0x1];
+        u8         inner_sip[0x1];
+        u8         inner_dip[0x1];
+        u8         inner_frag[0x1];
+        u8         inner_ip_protocol[0x1];
+        u8         inner_ip_ecn[0x1];
+        u8         inner_ip_dscp[0x1];
+        u8         inner_udp_sport[0x1];
+        u8         inner_udp_dport[0x1];
+        u8         inner_tcp_sport[0x1];
+        u8         inner_tcp_dport[0x1];
+        u8         inner_tcp_flags[0x1];
+        u8         reserved_7[0x9];
+
+        u8         reserved_8[0x40];
+};
+
+struct mlx5_ifc_flow_table_prop_layout_bits {
+        u8         ft_support[0x1];
+        u8         reserved_0[0x1f];
+
+        u8         reserved_1[0x2];
+        u8         log_max_ft_size[0x6];
+        u8         reserved_2[0x10];
+        u8         max_ft_level[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         reserved_4[0x18];
+        u8         log_max_ft_num[0x8];
+
+        u8         reserved_5[0x18];
+        u8         log_max_destination[0x8];
+
+        u8         reserved_6[0x18];
+        u8         log_max_flow[0x8];
+
+        u8         reserved_7[0x40];
+
+        struct mlx5_ifc_flow_table_fields_supported_bits ft_field_support;
+
+        struct mlx5_ifc_flow_table_fields_supported_bits ft_field_bitmask_support;
+};
+
+struct mlx5_ifc_odp_per_transport_service_cap_bits {
+        u8         send[0x1];
+        u8         receive[0x1];
+        u8         write[0x1];
+        u8         read[0x1];
+        u8         reserved_0[0x1];
+        u8         srq_receive[0x1];
+        u8         reserved_1[0x1a];
+};
+
+struct mlx5_ifc_fte_match_set_lyr_2_4_bits {
+        u8         smac_47_16[0x20];
+
+        u8         smac_15_0[0x10];
+        u8         ethertype[0x10];
+
+        u8         dmac_47_16[0x20];
+
+        u8         dmac_15_0[0x10];
+        u8         first_prio[0x3];
+        u8         first_cfi[0x1];
+        u8         first_vid[0xc];
+
+        u8         ip_protocol[0x8];
+        u8         ip_dscp[0x6];
+        u8         ip_ecn[0x2];
+        u8         vlan_tag[0x1];
+        u8         reserved_0[0x1];
+        u8         frag[0x1];
+        u8         reserved_1[0x4];
+        u8         tcp_flags[0x9];
+
+        u8         tcp_sport[0x10];
+        u8         tcp_dport[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         udp_sport[0x10];
+        u8         udp_dport[0x10];
+
+        u8         src_ip[4][0x20];
+
+        u8         dst_ip[4][0x20];
+};
+
+struct mlx5_ifc_fte_match_set_misc_bits {
+        u8         reserved_0[0x20];
+
+        u8         reserved_1[0x10];
+        u8         source_port[0x10];
+
+        u8         outer_second_prio[0x3];
+        u8         outer_second_cfi[0x1];
+        u8         outer_second_vid[0xc];
+        u8         inner_second_prio[0x3];
+        u8         inner_second_cfi[0x1];
+        u8         inner_second_vid[0xc];
+
+        u8         outer_second_vlan_tag[0x1];
+        u8         inner_second_vlan_tag[0x1];
+        u8         reserved_2[0xe];
+        u8         gre_protocol[0x10];
+
+        u8         gre_key_h[0x18];
+        u8         gre_key_l[0x8];
+
+        u8         vxlan_vni[0x18];
+        u8         reserved_3[0x8];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0xc];
+        u8         outer_ipv6_flow_label[0x14];
+
+        u8         reserved_6[0xc];
+        u8         inner_ipv6_flow_label[0x14];
+
+        u8         reserved_7[0xe0];
+};
+
+struct mlx5_ifc_cmd_pas_bits {
+        u8         pa_h[0x20];
+
+        u8         pa_l[0x14];
+        u8         reserved_0[0xc];
+};
+
+struct mlx5_ifc_uint64_bits {
+        u8         hi[0x20];
+
+        u8         lo[0x20];
+};
+
+enum {
+        MLX5_ADS_STAT_RATE_NO_LIMIT  = 0x0,
+        MLX5_ADS_STAT_RATE_2_5GBPS   = 0x7,
+        MLX5_ADS_STAT_RATE_10GBPS    = 0x8,
+        MLX5_ADS_STAT_RATE_30GBPS    = 0x9,
+        MLX5_ADS_STAT_RATE_5GBPS     = 0xa,
+        MLX5_ADS_STAT_RATE_20GBPS    = 0xb,
+        MLX5_ADS_STAT_RATE_40GBPS    = 0xc,
+        MLX5_ADS_STAT_RATE_60GBPS    = 0xd,
+        MLX5_ADS_STAT_RATE_80GBPS    = 0xe,
+        MLX5_ADS_STAT_RATE_120GBPS   = 0xf,
+};
+
+struct mlx5_ifc_ads_bits {
+        u8         fl[0x1];
+        u8         free_ar[0x1];
+        u8         reserved_0[0xe];
+        u8         pkey_index[0x10];
+
+        u8         reserved_1[0x8];
+        u8         grh[0x1];
+        u8         mlid[0x7];
+        u8         rlid[0x10];
+
+        u8         ack_timeout[0x5];
+        u8         reserved_2[0x3];
+        u8         src_addr_index[0x8];
+        u8         reserved_3[0x4];
+        u8         stat_rate[0x4];
+        u8         hop_limit[0x8];
+
+        u8         reserved_4[0x4];
+        u8         tclass[0x8];
+        u8         flow_label[0x14];
+
+        u8         rgid_rip[16][0x8];
+
+        u8         reserved_5[0x4];
+        u8         f_dscp[0x1];
+        u8         f_ecn[0x1];
+        u8         reserved_6[0x1];
+        u8         f_eth_prio[0x1];
+        u8         ecn[0x2];
+        u8         dscp[0x6];
+        u8         udp_sport[0x10];
+
+        u8         dei_cfi[0x1];
+        u8         eth_prio[0x3];
+        u8         sl[0x4];
+        u8         port[0x8];
+        u8         rmac_47_32[0x10];
+
+        u8         rmac_31_0[0x20];
+};
+
+struct mlx5_ifc_flow_table_nic_cap_bits {
+        u8         reserved_0[0x200];
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_receive;
+
+        u8         reserved_1[0x200];
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_receive_sniffer;
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_transmit;
+
+        u8         reserved_2[0x200];
+
+        struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_transmit_sniffer;
+
+        u8         reserved_3[0x7200];
+};
+
+struct mlx5_ifc_per_protocol_networking_offload_caps_bits {
+        u8         csum_cap[0x1];
+        u8         vlan_cap[0x1];
+        u8         lro_cap[0x1];
+        u8         lro_psh_flag[0x1];
+        u8         lro_time_stamp[0x1];
+        u8         reserved_0[0x6];
+        u8         max_lso_cap[0x5];
+        u8         reserved_1[0x4];
+        u8         rss_ind_tbl_cap[0x4];
+        u8         reserved_2[0x3];
+        u8         tunnel_lso_const_out_ip_id[0x1];
+        u8         reserved_3[0x2];
+        u8         tunnel_statless_gre[0x1];
+        u8         tunnel_stateless_vxlan[0x1];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x10];
+        u8         lro_min_mss_size[0x10];
+
+        u8         reserved_6[0x120];
+
+        u8         lro_timer_supported_periods[4][0x20];
+
+        u8         reserved_7[0x600];
+};
+
+struct mlx5_ifc_roce_cap_bits {
+        u8         roce_apm[0x1];
+        u8         reserved_0[0x1f];
+
+        u8         reserved_1[0x60];
+
+        u8         reserved_2[0xc];
+        u8         l3_type[0x4];
+        u8         reserved_3[0x8];
+        u8         roce_version[0x8];
+
+        u8         reserved_4[0x10];
+        u8         r_roce_dest_udp_port[0x10];
+
+        u8         r_roce_max_src_udp_port[0x10];
+        u8         r_roce_min_src_udp_port[0x10];
+
+        u8         reserved_5[0x10];
+        u8         roce_address_table_size[0x10];
+
+        u8         reserved_6[0x700];
+};
+
+enum {
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_1_BYTE     = 0x0,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_2_BYTES    = 0x2,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_4_BYTES    = 0x4,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_8_BYTES    = 0x8,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_16_BYTES   = 0x10,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_32_BYTES   = 0x20,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_64_BYTES   = 0x40,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_128_BYTES  = 0x80,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_256_BYTES  = 0x100,
+};
+
+enum {
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_1_BYTE     = 0x1,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_2_BYTES    = 0x2,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_4_BYTES    = 0x4,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_8_BYTES    = 0x8,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_16_BYTES   = 0x10,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_32_BYTES   = 0x20,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_64_BYTES   = 0x40,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_128_BYTES  = 0x80,
+        MLX5_ATOMIC_CAPS_ATOMIC_SIZE_DC_256_BYTES  = 0x100,
+};
+
+struct mlx5_ifc_atomic_caps_bits {
+        u8         reserved_0[0x40];
+
+        u8         atomic_req_endianness[0x1];
+        u8         reserved_1[0x1f];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x10];
+        u8         atomic_operations[0x10];
+
+        u8         reserved_4[0x10];
+        u8         atomic_size_qp[0x10];
+
+        u8         reserved_5[0x10];
+        u8         atomic_size_dc[0x10];
+
+        u8         reserved_6[0x720];
+};
+
+struct mlx5_ifc_odp_cap_bits {
+        u8         reserved_0[0x40];
+
+        u8         sig[0x1];
+        u8         reserved_1[0x1f];
+
+        u8         reserved_2[0x20];
+
+        struct mlx5_ifc_odp_per_transport_service_cap_bits rc_odp_caps;
+
+        struct mlx5_ifc_odp_per_transport_service_cap_bits uc_odp_caps;
+
+        struct mlx5_ifc_odp_per_transport_service_cap_bits ud_odp_caps;
+
+        u8         reserved_3[0x720];
+};
+
+enum {
+        MLX5_WQ_TYPE_LINKED_LIST  = 0x0,
+        MLX5_WQ_TYPE_CYCLIC       = 0x1,
+        MLX5_WQ_TYPE_STRQ         = 0x2,
+};
+
+enum {
+        MLX5_WQ_END_PAD_MODE_NONE   = 0x0,
+        MLX5_WQ_END_PAD_MODE_ALIGN  = 0x1,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_8_GID_ENTRIES    = 0x0,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_16_GID_ENTRIES   = 0x1,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_32_GID_ENTRIES   = 0x2,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_64_GID_ENTRIES   = 0x3,
+        MLX5_CMD_HCA_CAP_GID_TABLE_SIZE_128_GID_ENTRIES  = 0x4,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_128_ENTRIES  = 0x0,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_256_ENTRIES  = 0x1,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_512_ENTRIES  = 0x2,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_1K_ENTRIES   = 0x3,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_2K_ENTRIES   = 0x4,
+        MLX5_CMD_HCA_CAP_PKEY_TABLE_SIZE_4K_ENTRIES   = 0x5,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_PORT_TYPE_IB        = 0x0,
+        MLX5_CMD_HCA_CAP_PORT_TYPE_ETHERNET  = 0x1,
+};
+
+enum {
+        MLX5_CMD_HCA_CAP_CMDIF_CHECKSUM_DISABLED       = 0x0,
+        MLX5_CMD_HCA_CAP_CMDIF_CHECKSUM_INITIAL_STATE  = 0x1,
+        MLX5_CMD_HCA_CAP_CMDIF_CHECKSUM_ENABLED        = 0x3,
+};
+
+enum {
+        MLX5_CAP_PORT_TYPE_IB  = 0x0,
+        MLX5_CAP_PORT_TYPE_ETH = 0x1,
 };
 
 struct mlx5_ifc_cmd_hca_cap_bits {
@@ -148,9 +611,8 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         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_2[0xb];
+        u8         log_max_srq[0x5];
         u8         reserved_3[0x10];
 
         u8         reserved_4[0x8];
@@ -185,123 +647,2112 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         pad_cap[0x1];
         u8         cc_query_allowed[0x1];
         u8         cc_modify_allowed[0x1];
-        u8         reserved_15[0x1d];
+        u8         reserved_15[0xd];
+        u8         gid_table_size[0x10];
 
-        u8         reserved_16[0x6];
+        u8         out_of_seq_cnt[0x1];
+        u8         vport_counters[0x1];
+        u8         reserved_16[0x4];
         u8         max_qp_cnt[0xa];
         u8         pkey_table_size[0x10];
 
-        u8         eswitch_owner[0x1];
-        u8         reserved_17[0xa];
+        u8         vport_group_manager[0x1];
+        u8         vhca_group_manager[0x1];
+        u8         ib_virt[0x1];
+        u8         eth_virt[0x1];
+        u8         reserved_17[0x1];
+        u8         ets[0x1];
+        u8         nic_flow_table[0x1];
+        u8         reserved_18[0x4];
         u8         local_ca_ack_delay[0x5];
-        u8         reserved_18[0x8];
+        u8         reserved_19[0x6];
+        u8         port_type[0x2];
         u8         num_ports[0x8];
 
-        u8         reserved_19[0x3];
+        u8         reserved_20[0x3];
         u8         log_max_msg[0x5];
-        u8         reserved_20[0x18];
+        u8         reserved_21[0x18];
 
         u8         stat_rate_support[0x10];
-        u8         reserved_21[0x10];
+        u8         reserved_22[0xc];
+        u8         cqe_version[0x4];
 
-        u8         reserved_22[0x10];
+        u8         compact_address_vector[0x1];
+        u8         reserved_23[0xe];
+        u8         drain_sigerr[0x1];
         u8         cmdif_checksum[0x2];
         u8         sigerr_cqe[0x1];
-        u8         reserved_23[0x1];
+        u8         reserved_24[0x1];
         u8         wq_signature[0x1];
         u8         sctr_data_cqe[0x1];
-        u8         reserved_24[0x1];
+        u8         reserved_25[0x1];
         u8         sho[0x1];
         u8         tph[0x1];
         u8         rf[0x1];
-        u8         dc[0x1];
-        u8         reserved_25[0x2];
+        u8         dct[0x1];
+        u8         reserved_26[0x1];
+        u8         eth_net_offloads[0x1];
         u8         roce[0x1];
         u8         atomic[0x1];
-        u8         rsz_srq[0x1];
+        u8         reserved_27[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         reserved_28[0x3];
+        u8         cq_eq_remap[0x1];
         u8         pg[0x1];
         u8         block_lb_mc[0x1];
-        u8         reserved_27[0x3];
+        u8         reserved_29[0x1];
+        u8         scqe_break_moderation[0x1];
+        u8         reserved_30[0x1];
         u8         cd[0x1];
-        u8         reserved_28[0x1];
+        u8         reserved_31[0x1];
         u8         apm[0x1];
-        u8         reserved_29[0x7];
+        u8         reserved_32[0x7];
         u8         qkv[0x1];
         u8         pkv[0x1];
-        u8         reserved_30[0x4];
+        u8         reserved_33[0x4];
         u8         xrc[0x1];
         u8         ud[0x1];
         u8         uc[0x1];
         u8         rc[0x1];
 
-        u8         reserved_31[0xa];
+        u8         reserved_34[0xa];
         u8         uar_sz[0x6];
-        u8         reserved_32[0x8];
+        u8         reserved_35[0x8];
         u8         log_pg_sz[0x8];
 
         u8         bf[0x1];
-        u8         reserved_33[0xa];
+        u8         reserved_36[0x1];
+        u8         pad_tx_eth_packet[0x1];
+        u8         reserved_37[0x8];
         u8         log_bf_reg_size[0x5];
-        u8         reserved_34[0x10];
+        u8         reserved_38[0x10];
 
-        u8         reserved_35[0x10];
+        u8         reserved_39[0x10];
         u8         max_wqe_sz_sq[0x10];
 
-        u8         reserved_36[0x10];
+        u8         reserved_40[0x10];
         u8         max_wqe_sz_rq[0x10];
 
-        u8         reserved_37[0x10];
+        u8         reserved_41[0x10];
         u8         max_wqe_sz_sq_dc[0x10];
 
-        u8         reserved_38[0x7];
+        u8         reserved_42[0x7];
         u8         max_qp_mcg[0x19];
 
-        u8         reserved_39[0x18];
+        u8         reserved_43[0x18];
         u8         log_max_mcg[0x8];
 
-        u8         reserved_40[0xb];
+        u8         reserved_44[0x3];
+        u8         log_max_transport_domain[0x5];
+        u8         reserved_45[0x3];
         u8         log_max_pd[0x5];
-        u8         reserved_41[0xb];
+        u8         reserved_46[0xb];
         u8         log_max_xrcd[0x5];
 
-        u8         reserved_42[0x20];
+        u8         reserved_47[0x20];
 
-        u8         reserved_43[0x3];
+        u8         reserved_48[0x3];
         u8         log_max_rq[0x5];
-        u8         reserved_44[0x3];
+        u8         reserved_49[0x3];
         u8         log_max_sq[0x5];
-        u8         reserved_45[0x3];
+        u8         reserved_50[0x3];
         u8         log_max_tir[0x5];
-        u8         reserved_46[0x3];
+        u8         reserved_51[0x3];
         u8         log_max_tis[0x5];
 
-        u8         reserved_47[0x13];
-        u8         log_max_rq_per_tir[0x5];
-        u8         reserved_48[0x3];
+        u8         basic_cyclic_rcv_wqe[0x1];
+        u8         reserved_52[0x2];
+        u8         log_max_rmp[0x5];
+        u8         reserved_53[0x3];
+        u8         log_max_rqt[0x5];
+        u8         reserved_54[0x3];
+        u8         log_max_rqt_size[0x5];
+        u8         reserved_55[0x3];
         u8         log_max_tis_per_sq[0x5];
 
-        u8         reserved_49[0xe0];
+        u8         reserved_56[0x3];
+        u8         log_max_stride_sz_rq[0x5];
+        u8         reserved_57[0x3];
+        u8         log_min_stride_sz_rq[0x5];
+        u8         reserved_58[0x3];
+        u8         log_max_stride_sz_sq[0x5];
+        u8         reserved_59[0x3];
+        u8         log_min_stride_sz_sq[0x5];
 
-        u8         reserved_50[0x10];
+        u8         reserved_60[0x1b];
+        u8         log_max_wq_sz[0x5];
+
+        u8         reserved_61[0xa0];
+
+        u8         reserved_62[0x3];
+        u8         log_max_l2_table[0x5];
+        u8         reserved_63[0x8];
         u8         log_uar_page_sz[0x10];
 
-        u8         reserved_51[0x100];
+        u8         reserved_64[0x100];
 
-        u8         reserved_52[0x1f];
+        u8         reserved_65[0x1f];
         u8         cqe_zip[0x1];
 
         u8         cqe_zip_timeout[0x10];
         u8         cqe_zip_max_num[0x10];
 
-        u8         reserved_53[0x220];
+        u8         reserved_66[0x220];
+};
+
+enum {
+        MLX5_DEST_FORMAT_STRUCT_DESTINATION_TYPE_FLOW_TABLE_  = 0x1,
+        MLX5_DEST_FORMAT_STRUCT_DESTINATION_TYPE_TIR          = 0x2,
+};
+
+struct mlx5_ifc_dest_format_struct_bits {
+        u8         destination_type[0x8];
+        u8         destination_id[0x18];
+
+        u8         reserved_0[0x20];
+};
+
+struct mlx5_ifc_fte_match_param_bits {
+        struct mlx5_ifc_fte_match_set_lyr_2_4_bits outer_headers;
+
+        struct mlx5_ifc_fte_match_set_misc_bits misc_parameters;
+
+        struct mlx5_ifc_fte_match_set_lyr_2_4_bits inner_headers;
+
+        u8         reserved_0[0xa00];
+};
+
+enum {
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_SRC_IP     = 0x0,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_DST_IP     = 0x1,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_L4_SPORT   = 0x2,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_L4_DPORT   = 0x3,
+        MLX5_RX_HASH_FIELD_SELECT_SELECTED_FIELDS_IPSEC_SPI  = 0x4,
+};
+
+struct mlx5_ifc_rx_hash_field_select_bits {
+        u8         l3_prot_type[0x1];
+        u8         l4_prot_type[0x1];
+        u8         selected_fields[0x1e];
+};
+
+enum {
+        MLX5_WQ_WQ_TYPE_WQ_LINKED_LIST  = 0x0,
+        MLX5_WQ_WQ_TYPE_WQ_CYCLIC       = 0x1,
+};
+
+enum {
+        MLX5_WQ_END_PADDING_MODE_END_PAD_NONE   = 0x0,
+        MLX5_WQ_END_PADDING_MODE_END_PAD_ALIGN  = 0x1,
+};
+
+struct mlx5_ifc_wq_bits {
+        u8         wq_type[0x4];
+        u8         wq_signature[0x1];
+        u8         end_padding_mode[0x2];
+        u8         cd_slave[0x1];
+        u8         reserved_0[0x18];
+
+        u8         hds_skip_first_sge[0x1];
+        u8         log2_hds_buf_size[0x3];
+        u8         reserved_1[0x7];
+        u8         page_offset[0x5];
+        u8         lwm[0x10];
+
+        u8         reserved_2[0x8];
+        u8         pd[0x18];
+
+        u8         reserved_3[0x8];
+        u8         uar_page[0x18];
+
+        u8         dbr_addr[0x40];
+
+        u8         hw_counter[0x20];
+
+        u8         sw_counter[0x20];
+
+        u8         reserved_4[0xc];
+        u8         log_wq_stride[0x4];
+        u8         reserved_5[0x3];
+        u8         log_wq_pg_sz[0x5];
+        u8         reserved_6[0x3];
+        u8         log_wq_sz[0x5];
+
+        u8         reserved_7[0x4e0];
+
+        struct mlx5_ifc_cmd_pas_bits pas[0];
+};
+
+struct mlx5_ifc_rq_num_bits {
+        u8         reserved_0[0x8];
+        u8         rq_num[0x18];
+};
+
+struct mlx5_ifc_mac_address_layout_bits {
+        u8         reserved_0[0x10];
+        u8         mac_addr_47_32[0x10];
+
+        u8         mac_addr_31_0[0x20];
+};
+
+struct mlx5_ifc_cong_control_r_roce_ecn_np_bits {
+        u8         reserved_0[0xa0];
+
+        u8         min_time_between_cnps[0x20];
+
+        u8         reserved_1[0x12];
+        u8         cnp_dscp[0x6];
+        u8         reserved_2[0x5];
+        u8         cnp_802p_prio[0x3];
+
+        u8         reserved_3[0x720];
+};
+
+struct mlx5_ifc_cong_control_r_roce_ecn_rp_bits {
+        u8         reserved_0[0x60];
+
+        u8         reserved_1[0x4];
+        u8         clamp_tgt_rate[0x1];
+        u8         reserved_2[0x3];
+        u8         clamp_tgt_rate_after_time_inc[0x1];
+        u8         reserved_3[0x17];
+
+        u8         reserved_4[0x20];
+
+        u8         rpg_time_reset[0x20];
+
+        u8         rpg_byte_reset[0x20];
+
+        u8         rpg_threshold[0x20];
+
+        u8         rpg_max_rate[0x20];
+
+        u8         rpg_ai_rate[0x20];
+
+        u8         rpg_hai_rate[0x20];
+
+        u8         rpg_gd[0x20];
+
+        u8         rpg_min_dec_fac[0x20];
+
+        u8         rpg_min_rate[0x20];
+
+        u8         reserved_5[0xe0];
+
+        u8         rate_to_set_on_first_cnp[0x20];
+
+        u8         dce_tcp_g[0x20];
+
+        u8         dce_tcp_rtt[0x20];
+
+        u8         rate_reduce_monitor_period[0x20];
+
+        u8         reserved_6[0x20];
+
+        u8         initial_alpha_value[0x20];
+
+        u8         reserved_7[0x4a0];
+};
+
+struct mlx5_ifc_cong_control_802_1qau_rp_bits {
+        u8         reserved_0[0x80];
+
+        u8         rppp_max_rps[0x20];
+
+        u8         rpg_time_reset[0x20];
+
+        u8         rpg_byte_reset[0x20];
+
+        u8         rpg_threshold[0x20];
+
+        u8         rpg_max_rate[0x20];
+
+        u8         rpg_ai_rate[0x20];
+
+        u8         rpg_hai_rate[0x20];
+
+        u8         rpg_gd[0x20];
+
+        u8         rpg_min_dec_fac[0x20];
+
+        u8         rpg_min_rate[0x20];
+
+        u8         reserved_1[0x640];
+};
+
+enum {
+        MLX5_RESIZE_FIELD_SELECT_RESIZE_FIELD_SELECT_LOG_CQ_SIZE    = 0x1,
+        MLX5_RESIZE_FIELD_SELECT_RESIZE_FIELD_SELECT_PAGE_OFFSET    = 0x2,
+        MLX5_RESIZE_FIELD_SELECT_RESIZE_FIELD_SELECT_LOG_PAGE_SIZE  = 0x4,
+};
+
+struct mlx5_ifc_resize_field_select_bits {
+        u8         resize_field_select[0x20];
+};
+
+enum {
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_PERIOD     = 0x1,
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_MAX_COUNT  = 0x2,
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_OI            = 0x4,
+        MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_C_EQN         = 0x8,
+};
+
+struct mlx5_ifc_modify_field_select_bits {
+        u8         modify_field_select[0x20];
+};
+
+struct mlx5_ifc_field_select_r_roce_np_bits {
+        u8         field_select_r_roce_np[0x20];
+};
+
+struct mlx5_ifc_field_select_r_roce_rp_bits {
+        u8         field_select_r_roce_rp[0x20];
+};
+
+enum {
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPPP_MAX_RPS     = 0x4,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_TIME_RESET   = 0x8,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_BYTE_RESET   = 0x10,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_THRESHOLD    = 0x20,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_MAX_RATE     = 0x40,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_AI_RATE      = 0x80,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_HAI_RATE     = 0x100,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_GD           = 0x200,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_MIN_DEC_FAC  = 0x400,
+        MLX5_FIELD_SELECT_802_1QAU_RP_FIELD_SELECT_8021QAURP_RPG_MIN_RATE     = 0x800,
+};
+
+struct mlx5_ifc_field_select_802_1qau_rp_bits {
+        u8         field_select_8021qaurp[0x20];
+};
+
+struct mlx5_ifc_phys_layer_cntrs_bits {
+        u8         time_since_last_clear_high[0x20];
+
+        u8         time_since_last_clear_low[0x20];
+
+        u8         symbol_errors_high[0x20];
+
+        u8         symbol_errors_low[0x20];
+
+        u8         sync_headers_errors_high[0x20];
+
+        u8         sync_headers_errors_low[0x20];
+
+        u8         edpl_bip_errors_lane0_high[0x20];
+
+        u8         edpl_bip_errors_lane0_low[0x20];
+
+        u8         edpl_bip_errors_lane1_high[0x20];
+
+        u8         edpl_bip_errors_lane1_low[0x20];
+
+        u8         edpl_bip_errors_lane2_high[0x20];
+
+        u8         edpl_bip_errors_lane2_low[0x20];
+
+        u8         edpl_bip_errors_lane3_high[0x20];
+
+        u8         edpl_bip_errors_lane3_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane0_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane0_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane1_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane1_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane2_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane2_low[0x20];
+
+        u8         fc_fec_corrected_blocks_lane3_high[0x20];
+
+        u8         fc_fec_corrected_blocks_lane3_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane0_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane0_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane1_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane1_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane2_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane2_low[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane3_high[0x20];
+
+        u8         fc_fec_uncorrectable_blocks_lane3_low[0x20];
+
+        u8         rs_fec_corrected_blocks_high[0x20];
+
+        u8         rs_fec_corrected_blocks_low[0x20];
+
+        u8         rs_fec_uncorrectable_blocks_high[0x20];
+
+        u8         rs_fec_uncorrectable_blocks_low[0x20];
+
+        u8         rs_fec_no_errors_blocks_high[0x20];
+
+        u8         rs_fec_no_errors_blocks_low[0x20];
+
+        u8         rs_fec_single_error_blocks_high[0x20];
+
+        u8         rs_fec_single_error_blocks_low[0x20];
+
+        u8         rs_fec_corrected_symbols_total_high[0x20];
+
+        u8         rs_fec_corrected_symbols_total_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane0_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane0_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane1_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane1_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane2_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane2_low[0x20];
+
+        u8         rs_fec_corrected_symbols_lane3_high[0x20];
+
+        u8         rs_fec_corrected_symbols_lane3_low[0x20];
+
+        u8         link_down_events[0x20];
+
+        u8         successful_recovery_events[0x20];
+
+        u8         reserved_0[0x180];
+};
+
+struct mlx5_ifc_eth_per_traffic_grp_data_layout_bits {
+        u8         transmit_queue_high[0x20];
+
+        u8         transmit_queue_low[0x20];
+
+        u8         reserved_0[0x780];
+};
+
+struct mlx5_ifc_eth_per_prio_grp_data_layout_bits {
+        u8         rx_octets_high[0x20];
+
+        u8         rx_octets_low[0x20];
+
+        u8         reserved_0[0xc0];
+
+        u8         rx_frames_high[0x20];
+
+        u8         rx_frames_low[0x20];
+
+        u8         tx_octets_high[0x20];
+
+        u8         tx_octets_low[0x20];
+
+        u8         reserved_1[0xc0];
+
+        u8         tx_frames_high[0x20];
+
+        u8         tx_frames_low[0x20];
+
+        u8         rx_pause_high[0x20];
+
+        u8         rx_pause_low[0x20];
+
+        u8         rx_pause_duration_high[0x20];
+
+        u8         rx_pause_duration_low[0x20];
+
+        u8         tx_pause_high[0x20];
+
+        u8         tx_pause_low[0x20];
+
+        u8         tx_pause_duration_high[0x20];
+
+        u8         tx_pause_duration_low[0x20];
+
+        u8         rx_pause_transition_high[0x20];
+
+        u8         rx_pause_transition_low[0x20];
+
+        u8         reserved_2[0x400];
+};
+
+struct mlx5_ifc_eth_extended_cntrs_grp_data_layout_bits {
+        u8         port_transmit_wait_high[0x20];
+
+        u8         port_transmit_wait_low[0x20];
+
+        u8         reserved_0[0x780];
+};
+
+struct mlx5_ifc_eth_3635_cntrs_grp_data_layout_bits {
+        u8         dot3stats_alignment_errors_high[0x20];
+
+        u8         dot3stats_alignment_errors_low[0x20];
+
+        u8         dot3stats_fcs_errors_high[0x20];
+
+        u8         dot3stats_fcs_errors_low[0x20];
+
+        u8         dot3stats_single_collision_frames_high[0x20];
+
+        u8         dot3stats_single_collision_frames_low[0x20];
+
+        u8         dot3stats_multiple_collision_frames_high[0x20];
+
+        u8         dot3stats_multiple_collision_frames_low[0x20];
+
+        u8         dot3stats_sqe_test_errors_high[0x20];
+
+        u8         dot3stats_sqe_test_errors_low[0x20];
+
+        u8         dot3stats_deferred_transmissions_high[0x20];
+
+        u8         dot3stats_deferred_transmissions_low[0x20];
+
+        u8         dot3stats_late_collisions_high[0x20];
+
+        u8         dot3stats_late_collisions_low[0x20];
+
+        u8         dot3stats_excessive_collisions_high[0x20];
+
+        u8         dot3stats_excessive_collisions_low[0x20];
+
+        u8         dot3stats_internal_mac_transmit_errors_high[0x20];
+
+        u8         dot3stats_internal_mac_transmit_errors_low[0x20];
+
+        u8         dot3stats_carrier_sense_errors_high[0x20];
+
+        u8         dot3stats_carrier_sense_errors_low[0x20];
+
+        u8         dot3stats_frame_too_longs_high[0x20];
+
+        u8         dot3stats_frame_too_longs_low[0x20];
+
+        u8         dot3stats_internal_mac_receive_errors_high[0x20];
+
+        u8         dot3stats_internal_mac_receive_errors_low[0x20];
+
+        u8         dot3stats_symbol_errors_high[0x20];
+
+        u8         dot3stats_symbol_errors_low[0x20];
+
+        u8         dot3control_in_unknown_opcodes_high[0x20];
+
+        u8         dot3control_in_unknown_opcodes_low[0x20];
+
+        u8         dot3in_pause_frames_high[0x20];
+
+        u8         dot3in_pause_frames_low[0x20];
+
+        u8         dot3out_pause_frames_high[0x20];
+
+        u8         dot3out_pause_frames_low[0x20];
+
+        u8         reserved_0[0x3c0];
+};
+
+struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits {
+        u8         ether_stats_drop_events_high[0x20];
+
+        u8         ether_stats_drop_events_low[0x20];
+
+        u8         ether_stats_octets_high[0x20];
+
+        u8         ether_stats_octets_low[0x20];
+
+        u8         ether_stats_pkts_high[0x20];
+
+        u8         ether_stats_pkts_low[0x20];
+
+        u8         ether_stats_broadcast_pkts_high[0x20];
+
+        u8         ether_stats_broadcast_pkts_low[0x20];
+
+        u8         ether_stats_multicast_pkts_high[0x20];
+
+        u8         ether_stats_multicast_pkts_low[0x20];
+
+        u8         ether_stats_crc_align_errors_high[0x20];
+
+        u8         ether_stats_crc_align_errors_low[0x20];
+
+        u8         ether_stats_undersize_pkts_high[0x20];
+
+        u8         ether_stats_undersize_pkts_low[0x20];
+
+        u8         ether_stats_oversize_pkts_high[0x20];
+
+        u8         ether_stats_oversize_pkts_low[0x20];
+
+        u8         ether_stats_fragments_high[0x20];
+
+        u8         ether_stats_fragments_low[0x20];
+
+        u8         ether_stats_jabbers_high[0x20];
+
+        u8         ether_stats_jabbers_low[0x20];
+
+        u8         ether_stats_collisions_high[0x20];
+
+        u8         ether_stats_collisions_low[0x20];
+
+        u8         ether_stats_pkts64octets_high[0x20];
+
+        u8         ether_stats_pkts64octets_low[0x20];
+
+        u8         ether_stats_pkts65to127octets_high[0x20];
+
+        u8         ether_stats_pkts65to127octets_low[0x20];
+
+        u8         ether_stats_pkts128to255octets_high[0x20];
+
+        u8         ether_stats_pkts128to255octets_low[0x20];
+
+        u8         ether_stats_pkts256to511octets_high[0x20];
+
+        u8         ether_stats_pkts256to511octets_low[0x20];
+
+        u8         ether_stats_pkts512to1023octets_high[0x20];
+
+        u8         ether_stats_pkts512to1023octets_low[0x20];
+
+        u8         ether_stats_pkts1024to1518octets_high[0x20];
+
+        u8         ether_stats_pkts1024to1518octets_low[0x20];
+
+        u8         ether_stats_pkts1519to2047octets_high[0x20];
+
+        u8         ether_stats_pkts1519to2047octets_low[0x20];
+
+        u8         ether_stats_pkts2048to4095octets_high[0x20];
+
+        u8         ether_stats_pkts2048to4095octets_low[0x20];
+
+        u8         ether_stats_pkts4096to8191octets_high[0x20];
+
+        u8         ether_stats_pkts4096to8191octets_low[0x20];
+
+        u8         ether_stats_pkts8192to10239octets_high[0x20];
+
+        u8         ether_stats_pkts8192to10239octets_low[0x20];
+
+        u8         reserved_0[0x280];
+};
+
+struct mlx5_ifc_eth_2863_cntrs_grp_data_layout_bits {
+        u8         if_in_octets_high[0x20];
+
+        u8         if_in_octets_low[0x20];
+
+        u8         if_in_ucast_pkts_high[0x20];
+
+        u8         if_in_ucast_pkts_low[0x20];
+
+        u8         if_in_discards_high[0x20];
+
+        u8         if_in_discards_low[0x20];
+
+        u8         if_in_errors_high[0x20];
+
+        u8         if_in_errors_low[0x20];
+
+        u8         if_in_unknown_protos_high[0x20];
+
+        u8         if_in_unknown_protos_low[0x20];
+
+        u8         if_out_octets_high[0x20];
+
+        u8         if_out_octets_low[0x20];
+
+        u8         if_out_ucast_pkts_high[0x20];
+
+        u8         if_out_ucast_pkts_low[0x20];
+
+        u8         if_out_discards_high[0x20];
+
+        u8         if_out_discards_low[0x20];
+
+        u8         if_out_errors_high[0x20];
+
+        u8         if_out_errors_low[0x20];
+
+        u8         if_in_multicast_pkts_high[0x20];
+
+        u8         if_in_multicast_pkts_low[0x20];
+
+        u8         if_in_broadcast_pkts_high[0x20];
+
+        u8         if_in_broadcast_pkts_low[0x20];
+
+        u8         if_out_multicast_pkts_high[0x20];
+
+        u8         if_out_multicast_pkts_low[0x20];
+
+        u8         if_out_broadcast_pkts_high[0x20];
+
+        u8         if_out_broadcast_pkts_low[0x20];
+
+        u8         reserved_0[0x480];
+};
+
+struct mlx5_ifc_eth_802_3_cntrs_grp_data_layout_bits {
+        u8         a_frames_transmitted_ok_high[0x20];
+
+        u8         a_frames_transmitted_ok_low[0x20];
+
+        u8         a_frames_received_ok_high[0x20];
+
+        u8         a_frames_received_ok_low[0x20];
+
+        u8         a_frame_check_sequence_errors_high[0x20];
+
+        u8         a_frame_check_sequence_errors_low[0x20];
+
+        u8         a_alignment_errors_high[0x20];
+
+        u8         a_alignment_errors_low[0x20];
+
+        u8         a_octets_transmitted_ok_high[0x20];
+
+        u8         a_octets_transmitted_ok_low[0x20];
+
+        u8         a_octets_received_ok_high[0x20];
+
+        u8         a_octets_received_ok_low[0x20];
+
+        u8         a_multicast_frames_xmitted_ok_high[0x20];
+
+        u8         a_multicast_frames_xmitted_ok_low[0x20];
+
+        u8         a_broadcast_frames_xmitted_ok_high[0x20];
+
+        u8         a_broadcast_frames_xmitted_ok_low[0x20];
+
+        u8         a_multicast_frames_received_ok_high[0x20];
+
+        u8         a_multicast_frames_received_ok_low[0x20];
+
+        u8         a_broadcast_frames_received_ok_high[0x20];
+
+        u8         a_broadcast_frames_received_ok_low[0x20];
+
+        u8         a_in_range_length_errors_high[0x20];
+
+        u8         a_in_range_length_errors_low[0x20];
+
+        u8         a_out_of_range_length_field_high[0x20];
+
+        u8         a_out_of_range_length_field_low[0x20];
+
+        u8         a_frame_too_long_errors_high[0x20];
+
+        u8         a_frame_too_long_errors_low[0x20];
+
+        u8         a_symbol_error_during_carrier_high[0x20];
+
+        u8         a_symbol_error_during_carrier_low[0x20];
+
+        u8         a_mac_control_frames_transmitted_high[0x20];
+
+        u8         a_mac_control_frames_transmitted_low[0x20];
+
+        u8         a_mac_control_frames_received_high[0x20];
+
+        u8         a_mac_control_frames_received_low[0x20];
+
+        u8         a_unsupported_opcodes_received_high[0x20];
+
+        u8         a_unsupported_opcodes_received_low[0x20];
+
+        u8         a_pause_mac_ctrl_frames_received_high[0x20];
+
+        u8         a_pause_mac_ctrl_frames_received_low[0x20];
+
+        u8         a_pause_mac_ctrl_frames_transmitted_high[0x20];
+
+        u8         a_pause_mac_ctrl_frames_transmitted_low[0x20];
+
+        u8         reserved_0[0x300];
+};
+
+struct mlx5_ifc_cmd_inter_comp_event_bits {
+        u8         command_completion_vector[0x20];
+
+        u8         reserved_0[0xc0];
+};
+
+struct mlx5_ifc_stall_vl_event_bits {
+        u8         reserved_0[0x18];
+        u8         port_num[0x1];
+        u8         reserved_1[0x3];
+        u8         vl[0x4];
+
+        u8         reserved_2[0xa0];
+};
+
+struct mlx5_ifc_db_bf_congestion_event_bits {
+        u8         event_subtype[0x8];
+        u8         reserved_0[0x8];
+        u8         congestion_level[0x8];
+        u8         reserved_1[0x8];
+
+        u8         reserved_2[0xa0];
+};
+
+struct mlx5_ifc_gpio_event_bits {
+        u8         reserved_0[0x60];
+
+        u8         gpio_event_hi[0x20];
+
+        u8         gpio_event_lo[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_port_state_change_event_bits {
+        u8         reserved_0[0x40];
+
+        u8         port_num[0x4];
+        u8         reserved_1[0x1c];
+
+        u8         reserved_2[0x80];
+};
+
+struct mlx5_ifc_dropped_packet_logged_bits {
+        u8         reserved_0[0xe0];
+};
+
+enum {
+        MLX5_CQ_ERROR_SYNDROME_CQ_OVERRUN                 = 0x1,
+        MLX5_CQ_ERROR_SYNDROME_CQ_ACCESS_VIOLATION_ERROR  = 0x2,
+};
+
+struct mlx5_ifc_cq_error_bits {
+        u8         reserved_0[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_1[0x20];
+
+        u8         reserved_2[0x18];
+        u8         syndrome[0x8];
+
+        u8         reserved_3[0x80];
+};
+
+struct mlx5_ifc_rdma_page_fault_event_bits {
+        u8         bytes_committed[0x20];
+
+        u8         r_key[0x20];
+
+        u8         reserved_0[0x10];
+        u8         packet_len[0x10];
+
+        u8         rdma_op_len[0x20];
+
+        u8         rdma_va[0x40];
+
+        u8         reserved_1[0x5];
+        u8         rdma[0x1];
+        u8         write[0x1];
+        u8         requestor[0x1];
+        u8         qp_number[0x18];
+};
+
+struct mlx5_ifc_wqe_associated_page_fault_event_bits {
+        u8         bytes_committed[0x20];
+
+        u8         reserved_0[0x10];
+        u8         wqe_index[0x10];
+
+        u8         reserved_1[0x10];
+        u8         len[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x5];
+        u8         rdma[0x1];
+        u8         write_read[0x1];
+        u8         requestor[0x1];
+        u8         qpn[0x18];
+};
+
+struct mlx5_ifc_qp_events_bits {
+        u8         reserved_0[0xa0];
+
+        u8         type[0x8];
+        u8         reserved_1[0x18];
+
+        u8         reserved_2[0x8];
+        u8         qpn_rqn_sqn[0x18];
+};
+
+struct mlx5_ifc_dct_events_bits {
+        u8         reserved_0[0xc0];
+
+        u8         reserved_1[0x8];
+        u8         dct_number[0x18];
+};
+
+struct mlx5_ifc_comp_event_bits {
+        u8         reserved_0[0xc0];
+
+        u8         reserved_1[0x8];
+        u8         cq_number[0x18];
+};
+
+enum {
+        MLX5_QPC_STATE_RST        = 0x0,
+        MLX5_QPC_STATE_INIT       = 0x1,
+        MLX5_QPC_STATE_RTR        = 0x2,
+        MLX5_QPC_STATE_RTS        = 0x3,
+        MLX5_QPC_STATE_SQER       = 0x4,
+        MLX5_QPC_STATE_ERR        = 0x6,
+        MLX5_QPC_STATE_SQD        = 0x7,
+        MLX5_QPC_STATE_SUSPENDED  = 0x9,
+};
+
+enum {
+        MLX5_QPC_ST_RC            = 0x0,
+        MLX5_QPC_ST_UC            = 0x1,
+        MLX5_QPC_ST_UD            = 0x2,
+        MLX5_QPC_ST_XRC           = 0x3,
+        MLX5_QPC_ST_DCI           = 0x5,
+        MLX5_QPC_ST_QP0           = 0x7,
+        MLX5_QPC_ST_QP1           = 0x8,
+        MLX5_QPC_ST_RAW_DATAGRAM  = 0x9,
+        MLX5_QPC_ST_REG_UMR       = 0xc,
+};
+
+enum {
+        MLX5_QPC_PM_STATE_ARMED     = 0x0,
+        MLX5_QPC_PM_STATE_REARM     = 0x1,
+        MLX5_QPC_PM_STATE_RESERVED  = 0x2,
+        MLX5_QPC_PM_STATE_MIGRATED  = 0x3,
+};
+
+enum {
+        MLX5_QPC_END_PADDING_MODE_SCATTER_AS_IS                = 0x0,
+        MLX5_QPC_END_PADDING_MODE_PAD_TO_CACHE_LINE_ALIGNMENT  = 0x1,
+};
+
+enum {
+        MLX5_QPC_MTU_256_BYTES        = 0x1,
+        MLX5_QPC_MTU_512_BYTES        = 0x2,
+        MLX5_QPC_MTU_1K_BYTES         = 0x3,
+        MLX5_QPC_MTU_2K_BYTES         = 0x4,
+        MLX5_QPC_MTU_4K_BYTES         = 0x5,
+        MLX5_QPC_MTU_RAW_ETHERNET_QP  = 0x7,
+};
+
+enum {
+        MLX5_QPC_ATOMIC_MODE_IB_SPEC     = 0x1,
+        MLX5_QPC_ATOMIC_MODE_ONLY_8B     = 0x2,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_8B    = 0x3,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_16B   = 0x4,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_32B   = 0x5,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_64B   = 0x6,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_128B  = 0x7,
+        MLX5_QPC_ATOMIC_MODE_UP_TO_256B  = 0x8,
+};
+
+enum {
+        MLX5_QPC_CS_REQ_DISABLE    = 0x0,
+        MLX5_QPC_CS_REQ_UP_TO_32B  = 0x11,
+        MLX5_QPC_CS_REQ_UP_TO_64B  = 0x22,
+};
+
+enum {
+        MLX5_QPC_CS_RES_DISABLE    = 0x0,
+        MLX5_QPC_CS_RES_UP_TO_32B  = 0x1,
+        MLX5_QPC_CS_RES_UP_TO_64B  = 0x2,
+};
+
+struct mlx5_ifc_qpc_bits {
+        u8         state[0x4];
+        u8         reserved_0[0x4];
+        u8         st[0x8];
+        u8         reserved_1[0x3];
+        u8         pm_state[0x2];
+        u8         reserved_2[0x7];
+        u8         end_padding_mode[0x2];
+        u8         reserved_3[0x2];
+
+        u8         wq_signature[0x1];
+        u8         block_lb_mc[0x1];
+        u8         atomic_like_write_en[0x1];
+        u8         latency_sensitive[0x1];
+        u8         reserved_4[0x1];
+        u8         drain_sigerr[0x1];
+        u8         reserved_5[0x2];
+        u8         pd[0x18];
+
+        u8         mtu[0x3];
+        u8         log_msg_max[0x5];
+        u8         reserved_6[0x1];
+        u8         log_rq_size[0x4];
+        u8         log_rq_stride[0x3];
+        u8         no_sq[0x1];
+        u8         log_sq_size[0x4];
+        u8         reserved_7[0x6];
+        u8         rlky[0x1];
+        u8         reserved_8[0x4];
+
+        u8         counter_set_id[0x8];
+        u8         uar_page[0x18];
+
+        u8         reserved_9[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_10[0x3];
+        u8         log_page_size[0x5];
+        u8         remote_qpn[0x18];
+
+        struct mlx5_ifc_ads_bits primary_address_path;
+
+        struct mlx5_ifc_ads_bits secondary_address_path;
+
+        u8         log_ack_req_freq[0x4];
+        u8         reserved_11[0x4];
+        u8         log_sra_max[0x3];
+        u8         reserved_12[0x2];
+        u8         retry_count[0x3];
+        u8         rnr_retry[0x3];
+        u8         reserved_13[0x1];
+        u8         fre[0x1];
+        u8         cur_rnr_retry[0x3];
+        u8         cur_retry_count[0x3];
+        u8         reserved_14[0x5];
+
+        u8         reserved_15[0x20];
+
+        u8         reserved_16[0x8];
+        u8         next_send_psn[0x18];
+
+        u8         reserved_17[0x8];
+        u8         cqn_snd[0x18];
+
+        u8         reserved_18[0x40];
+
+        u8         reserved_19[0x8];
+        u8         last_acked_psn[0x18];
+
+        u8         reserved_20[0x8];
+        u8         ssn[0x18];
+
+        u8         reserved_21[0x8];
+        u8         log_rra_max[0x3];
+        u8         reserved_22[0x1];
+        u8         atomic_mode[0x4];
+        u8         rre[0x1];
+        u8         rwe[0x1];
+        u8         rae[0x1];
+        u8         reserved_23[0x1];
+        u8         page_offset[0x6];
+        u8         reserved_24[0x3];
+        u8         cd_slave_receive[0x1];
+        u8         cd_slave_send[0x1];
+        u8         cd_master[0x1];
+
+        u8         reserved_25[0x3];
+        u8         min_rnr_nak[0x5];
+        u8         next_rcv_psn[0x18];
+
+        u8         reserved_26[0x8];
+        u8         xrcd[0x18];
+
+        u8         reserved_27[0x8];
+        u8         cqn_rcv[0x18];
+
+        u8         dbr_addr[0x40];
+
+        u8         q_key[0x20];
+
+        u8         reserved_28[0x5];
+        u8         rq_type[0x3];
+        u8         srqn_rmpn[0x18];
+
+        u8         reserved_29[0x8];
+        u8         rmsn[0x18];
+
+        u8         hw_sq_wqebb_counter[0x10];
+        u8         sw_sq_wqebb_counter[0x10];
+
+        u8         hw_rq_counter[0x20];
+
+        u8         sw_rq_counter[0x20];
+
+        u8         reserved_30[0x20];
+
+        u8         reserved_31[0xf];
+        u8         cgs[0x1];
+        u8         cs_req[0x8];
+        u8         cs_res[0x8];
+
+        u8         dc_access_key[0x40];
+
+        u8         reserved_32[0xc0];
+};
+
+struct mlx5_ifc_roce_addr_layout_bits {
+        u8         source_l3_address[16][0x8];
+
+        u8         reserved_0[0x3];
+        u8         vlan_valid[0x1];
+        u8         vlan_id[0xc];
+        u8         source_mac_47_32[0x10];
+
+        u8         source_mac_31_0[0x20];
+
+        u8         reserved_1[0x14];
+        u8         roce_l3_type[0x4];
+        u8         roce_version[0x8];
+
+        u8         reserved_2[0x20];
+};
+
+union mlx5_ifc_hca_cap_union_bits {
+        struct mlx5_ifc_cmd_hca_cap_bits cmd_hca_cap;
+        struct mlx5_ifc_odp_cap_bits odp_cap;
+        struct mlx5_ifc_atomic_caps_bits atomic_caps;
+        struct mlx5_ifc_roce_cap_bits roce_cap;
+        struct mlx5_ifc_per_protocol_networking_offload_caps_bits per_protocol_networking_offload_caps;
+        struct mlx5_ifc_flow_table_nic_cap_bits flow_table_nic_cap;
+        u8         reserved_0[0x8000];
+};
+
+enum {
+        MLX5_FLOW_CONTEXT_ACTION_ALLOW     = 0x1,
+        MLX5_FLOW_CONTEXT_ACTION_DROP      = 0x2,
+        MLX5_FLOW_CONTEXT_ACTION_FWD_DEST  = 0x4,
+};
+
+struct mlx5_ifc_flow_context_bits {
+        u8         reserved_0[0x20];
+
+        u8         group_id[0x20];
+
+        u8         reserved_1[0x8];
+        u8         flow_tag[0x18];
+
+        u8         reserved_2[0x10];
+        u8         action[0x10];
+
+        u8         reserved_3[0x8];
+        u8         destination_list_size[0x18];
+
+        u8         reserved_4[0x160];
+
+        struct mlx5_ifc_fte_match_param_bits match_value;
+
+        u8         reserved_5[0x600];
+
+        struct mlx5_ifc_dest_format_struct_bits destination[0];
+};
+
+enum {
+        MLX5_XRC_SRQC_STATE_GOOD   = 0x0,
+        MLX5_XRC_SRQC_STATE_ERROR  = 0x1,
+};
+
+struct mlx5_ifc_xrc_srqc_bits {
+        u8         state[0x4];
+        u8         log_xrc_srq_size[0x4];
+        u8         reserved_0[0x18];
+
+        u8         wq_signature[0x1];
+        u8         cont_srq[0x1];
+        u8         reserved_1[0x1];
+        u8         rlky[0x1];
+        u8         basic_cyclic_rcv_wqe[0x1];
+        u8         log_rq_stride[0x3];
+        u8         xrcd[0x18];
+
+        u8         page_offset[0x6];
+        u8         reserved_2[0x2];
+        u8         cqn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         user_index_equal_xrc_srqn[0x1];
+        u8         reserved_4[0x1];
+        u8         log_page_size[0x6];
+        u8         user_index[0x18];
+
+        u8         reserved_5[0x20];
+
+        u8         reserved_6[0x8];
+        u8         pd[0x18];
+
+        u8         lwm[0x10];
+        u8         wqe_cnt[0x10];
+
+        u8         reserved_7[0x40];
+
+        u8         db_record_addr_h[0x20];
+
+        u8         db_record_addr_l[0x1e];
+        u8         reserved_8[0x2];
+
+        u8         reserved_9[0x80];
+};
+
+struct mlx5_ifc_traffic_counter_bits {
+        u8         packets[0x40];
+
+        u8         octets[0x40];
+};
+
+struct mlx5_ifc_tisc_bits {
+        u8         reserved_0[0xc];
+        u8         prio[0x4];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x100];
+
+        u8         reserved_3[0x8];
+        u8         transport_domain[0x18];
+
+        u8         reserved_4[0x3c0];
+};
+
+enum {
+        MLX5_TIRC_DISP_TYPE_DIRECT    = 0x0,
+        MLX5_TIRC_DISP_TYPE_INDIRECT  = 0x1,
+};
+
+enum {
+        MLX5_TIRC_LRO_ENABLE_MASK_IPV4_LRO  = 0x1,
+        MLX5_TIRC_LRO_ENABLE_MASK_IPV6_LRO  = 0x2,
+};
+
+enum {
+        MLX5_TIRC_RX_HASH_FN_HASH_NONE           = 0x0,
+        MLX5_TIRC_RX_HASH_FN_HASH_INVERTED_XOR8  = 0x1,
+        MLX5_TIRC_RX_HASH_FN_HASH_TOEPLITZ       = 0x2,
+};
+
+enum {
+        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_UNICAST_    = 0x1,
+        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_MULTICAST_  = 0x2,
+};
+
+struct mlx5_ifc_tirc_bits {
+        u8         reserved_0[0x20];
+
+        u8         disp_type[0x4];
+        u8         reserved_1[0x1c];
+
+        u8         reserved_2[0x40];
+
+        u8         reserved_3[0x4];
+        u8         lro_timeout_period_usecs[0x10];
+        u8         lro_enable_mask[0x4];
+        u8         lro_max_ip_payload_size[0x8];
+
+        u8         reserved_4[0x40];
+
+        u8         reserved_5[0x8];
+        u8         inline_rqn[0x18];
+
+        u8         rx_hash_symmetric[0x1];
+        u8         reserved_6[0x1];
+        u8         tunneled_offload_en[0x1];
+        u8         reserved_7[0x5];
+        u8         indirect_table[0x18];
+
+        u8         rx_hash_fn[0x4];
+        u8         reserved_8[0x2];
+        u8         self_lb_block[0x2];
+        u8         transport_domain[0x18];
+
+        u8         rx_hash_toeplitz_key[10][0x20];
+
+        struct mlx5_ifc_rx_hash_field_select_bits rx_hash_field_selector_outer;
+
+        struct mlx5_ifc_rx_hash_field_select_bits rx_hash_field_selector_inner;
+
+        u8         reserved_9[0x4c0];
+};
+
+enum {
+        MLX5_SRQC_STATE_GOOD   = 0x0,
+        MLX5_SRQC_STATE_ERROR  = 0x1,
+};
+
+struct mlx5_ifc_srqc_bits {
+        u8         state[0x4];
+        u8         log_srq_size[0x4];
+        u8         reserved_0[0x18];
+
+        u8         wq_signature[0x1];
+        u8         cont_srq[0x1];
+        u8         reserved_1[0x1];
+        u8         rlky[0x1];
+        u8         reserved_2[0x1];
+        u8         log_rq_stride[0x3];
+        u8         xrcd[0x18];
+
+        u8         page_offset[0x6];
+        u8         reserved_3[0x2];
+        u8         cqn[0x18];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x2];
+        u8         log_page_size[0x6];
+        u8         reserved_6[0x18];
+
+        u8         reserved_7[0x20];
+
+        u8         reserved_8[0x8];
+        u8         pd[0x18];
+
+        u8         lwm[0x10];
+        u8         wqe_cnt[0x10];
+
+        u8         reserved_9[0x40];
+
+        u8         dbr_addr[0x40];
+
+        u8         reserved_10[0x80];
+};
+
+enum {
+        MLX5_SQC_STATE_RST  = 0x0,
+        MLX5_SQC_STATE_RDY  = 0x1,
+        MLX5_SQC_STATE_ERR  = 0x3,
+};
+
+struct mlx5_ifc_sqc_bits {
+        u8         rlky[0x1];
+        u8         cd_master[0x1];
+        u8         fre[0x1];
+        u8         flush_in_error_en[0x1];
+        u8         reserved_0[0x4];
+        u8         state[0x4];
+        u8         reserved_1[0x14];
+
+        u8         reserved_2[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_3[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_4[0xa0];
+
+        u8         tis_lst_sz[0x10];
+        u8         reserved_5[0x10];
+
+        u8         reserved_6[0x40];
+
+        u8         reserved_7[0x8];
+        u8         tis_num_0[0x18];
+
+        struct mlx5_ifc_wq_bits wq;
+};
+
+struct mlx5_ifc_rqtc_bits {
+        u8         reserved_0[0xa0];
+
+        u8         reserved_1[0x10];
+        u8         rqt_max_size[0x10];
+
+        u8         reserved_2[0x10];
+        u8         rqt_actual_size[0x10];
+
+        u8         reserved_3[0x6a0];
+
+        struct mlx5_ifc_rq_num_bits rq_num[0];
+};
+
+enum {
+        MLX5_RQC_MEM_RQ_TYPE_MEMORY_RQ_INLINE  = 0x0,
+        MLX5_RQC_MEM_RQ_TYPE_MEMORY_RQ_RMP     = 0x1,
+};
+
+enum {
+        MLX5_RQC_STATE_RST  = 0x0,
+        MLX5_RQC_STATE_RDY  = 0x1,
+        MLX5_RQC_STATE_ERR  = 0x3,
+};
+
+struct mlx5_ifc_rqc_bits {
+        u8         rlky[0x1];
+        u8         reserved_0[0x2];
+        u8         vsd[0x1];
+        u8         mem_rq_type[0x4];
+        u8         state[0x4];
+        u8         reserved_1[0x1];
+        u8         flush_in_error_en[0x1];
+        u8         reserved_2[0x12];
+
+        u8         reserved_3[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_4[0x8];
+        u8         cqn[0x18];
+
+        u8         counter_set_id[0x8];
+        u8         reserved_5[0x18];
+
+        u8         reserved_6[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_7[0xe0];
+
+        struct mlx5_ifc_wq_bits wq;
+};
+
+enum {
+        MLX5_RMPC_STATE_RDY  = 0x1,
+        MLX5_RMPC_STATE_ERR  = 0x3,
+};
+
+struct mlx5_ifc_rmpc_bits {
+        u8         reserved_0[0x8];
+        u8         state[0x4];
+        u8         reserved_1[0x14];
+
+        u8         basic_cyclic_rcv_wqe[0x1];
+        u8         reserved_2[0x1f];
+
+        u8         reserved_3[0x140];
+
+        struct mlx5_ifc_wq_bits wq;
+};
+
+enum {
+        MLX5_NIC_VPORT_CONTEXT_ALLOWED_LIST_TYPE_CURRENT_UC_MAC_ADDRESS  = 0x0,
+};
+
+struct mlx5_ifc_nic_vport_context_bits {
+        u8         reserved_0[0x1f];
+        u8         roce_en[0x1];
+
+        u8         reserved_1[0x760];
+
+        u8         reserved_2[0x5];
+        u8         allowed_list_type[0x3];
+        u8         reserved_3[0xc];
+        u8         allowed_list_size[0xc];
+
+        struct mlx5_ifc_mac_address_layout_bits permanent_address;
+
+        u8         reserved_4[0x20];
+
+        u8         current_uc_mac_address[0][0x40];
+};
+
+enum {
+        MLX5_MKC_ACCESS_MODE_PA    = 0x0,
+        MLX5_MKC_ACCESS_MODE_MTT   = 0x1,
+        MLX5_MKC_ACCESS_MODE_KLMS  = 0x2,
+};
+
+struct mlx5_ifc_mkc_bits {
+        u8         reserved_0[0x1];
+        u8         free[0x1];
+        u8         reserved_1[0xd];
+        u8         small_fence_on_rdma_read_response[0x1];
+        u8         umr_en[0x1];
+        u8         a[0x1];
+        u8         rw[0x1];
+        u8         rr[0x1];
+        u8         lw[0x1];
+        u8         lr[0x1];
+        u8         access_mode[0x2];
+        u8         reserved_2[0x8];
+
+        u8         qpn[0x18];
+        u8         mkey_7_0[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         length64[0x1];
+        u8         bsf_en[0x1];
+        u8         sync_umr[0x1];
+        u8         reserved_4[0x2];
+        u8         expected_sigerr_count[0x1];
+        u8         reserved_5[0x1];
+        u8         en_rinval[0x1];
+        u8         pd[0x18];
+
+        u8         start_addr[0x40];
+
+        u8         len[0x40];
+
+        u8         bsf_octword_size[0x20];
+
+        u8         reserved_6[0x80];
+
+        u8         translations_octword_size[0x20];
+
+        u8         reserved_7[0x1b];
+        u8         log_page_size[0x5];
+
+        u8         reserved_8[0x20];
+};
+
+struct mlx5_ifc_pkey_bits {
+        u8         reserved_0[0x10];
+        u8         pkey[0x10];
+};
+
+struct mlx5_ifc_array128_auto_bits {
+        u8         array128_auto[16][0x8];
+};
+
+struct mlx5_ifc_hca_vport_context_bits {
+        u8         field_select[0x20];
+
+        u8         reserved_0[0xe0];
+
+        u8         sm_virt_aware[0x1];
+        u8         has_smi[0x1];
+        u8         has_raw[0x1];
+        u8         grh_required[0x1];
+        u8         reserved_1[0xc];
+        u8         port_physical_state[0x4];
+        u8         vport_state_policy[0x4];
+        u8         port_state[0x4];
+        u8         vport_state[0x4];
+
+        u8         reserved_2[0x20];
+
+        u8         system_image_guid[0x40];
+
+        u8         port_guid[0x40];
+
+        u8         node_guid[0x40];
+
+        u8         cap_mask1[0x20];
+
+        u8         cap_mask1_field_select[0x20];
+
+        u8         cap_mask2[0x20];
+
+        u8         cap_mask2_field_select[0x20];
+
+        u8         reserved_3[0x80];
+
+        u8         lid[0x10];
+        u8         reserved_4[0x4];
+        u8         init_type_reply[0x4];
+        u8         lmc[0x3];
+        u8         subnet_timeout[0x5];
+
+        u8         sm_lid[0x10];
+        u8         sm_sl[0x4];
+        u8         reserved_5[0xc];
+
+        u8         qkey_violation_counter[0x10];
+        u8         pkey_violation_counter[0x10];
+
+        u8         reserved_6[0xca0];
+};
+
+enum {
+        MLX5_EQC_STATUS_OK                = 0x0,
+        MLX5_EQC_STATUS_EQ_WRITE_FAILURE  = 0xa,
+};
+
+enum {
+        MLX5_EQC_ST_ARMED  = 0x9,
+        MLX5_EQC_ST_FIRED  = 0xa,
+};
+
+struct mlx5_ifc_eqc_bits {
+        u8         status[0x4];
+        u8         reserved_0[0x9];
+        u8         ec[0x1];
+        u8         oi[0x1];
+        u8         reserved_1[0x5];
+        u8         st[0x4];
+        u8         reserved_2[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         reserved_4[0x14];
+        u8         page_offset[0x6];
+        u8         reserved_5[0x6];
+
+        u8         reserved_6[0x3];
+        u8         log_eq_size[0x5];
+        u8         uar_page[0x18];
+
+        u8         reserved_7[0x20];
+
+        u8         reserved_8[0x18];
+        u8         intr[0x8];
+
+        u8         reserved_9[0x3];
+        u8         log_page_size[0x5];
+        u8         reserved_10[0x18];
+
+        u8         reserved_11[0x60];
+
+        u8         reserved_12[0x8];
+        u8         consumer_counter[0x18];
+
+        u8         reserved_13[0x8];
+        u8         producer_counter[0x18];
+
+        u8         reserved_14[0x80];
+};
+
+enum {
+        MLX5_DCTC_STATE_ACTIVE    = 0x0,
+        MLX5_DCTC_STATE_DRAINING  = 0x1,
+        MLX5_DCTC_STATE_DRAINED   = 0x2,
+};
+
+enum {
+        MLX5_DCTC_CS_RES_DISABLE    = 0x0,
+        MLX5_DCTC_CS_RES_NA         = 0x1,
+        MLX5_DCTC_CS_RES_UP_TO_64B  = 0x2,
+};
+
+enum {
+        MLX5_DCTC_MTU_256_BYTES  = 0x1,
+        MLX5_DCTC_MTU_512_BYTES  = 0x2,
+        MLX5_DCTC_MTU_1K_BYTES   = 0x3,
+        MLX5_DCTC_MTU_2K_BYTES   = 0x4,
+        MLX5_DCTC_MTU_4K_BYTES   = 0x5,
+};
+
+struct mlx5_ifc_dctc_bits {
+        u8         reserved_0[0x4];
+        u8         state[0x4];
+        u8         reserved_1[0x18];
+
+        u8         reserved_2[0x8];
+        u8         user_index[0x18];
+
+        u8         reserved_3[0x8];
+        u8         cqn[0x18];
+
+        u8         counter_set_id[0x8];
+        u8         atomic_mode[0x4];
+        u8         rre[0x1];
+        u8         rwe[0x1];
+        u8         rae[0x1];
+        u8         atomic_like_write_en[0x1];
+        u8         latency_sensitive[0x1];
+        u8         rlky[0x1];
+        u8         free_ar[0x1];
+        u8         reserved_4[0xd];
+
+        u8         reserved_5[0x8];
+        u8         cs_res[0x8];
+        u8         reserved_6[0x3];
+        u8         min_rnr_nak[0x5];
+        u8         reserved_7[0x8];
+
+        u8         reserved_8[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_9[0x8];
+        u8         pd[0x18];
+
+        u8         tclass[0x8];
+        u8         reserved_10[0x4];
+        u8         flow_label[0x14];
+
+        u8         dc_access_key[0x40];
+
+        u8         reserved_11[0x5];
+        u8         mtu[0x3];
+        u8         port[0x8];
+        u8         pkey_index[0x10];
+
+        u8         reserved_12[0x8];
+        u8         my_addr_index[0x8];
+        u8         reserved_13[0x8];
+        u8         hop_limit[0x8];
+
+        u8         dc_access_key_violation_count[0x20];
+
+        u8         reserved_14[0x14];
+        u8         dei_cfi[0x1];
+        u8         eth_prio[0x3];
+        u8         ecn[0x2];
+        u8         dscp[0x6];
+
+        u8         reserved_15[0x40];
+};
+
+enum {
+        MLX5_CQC_STATUS_OK             = 0x0,
+        MLX5_CQC_STATUS_CQ_OVERFLOW    = 0x9,
+        MLX5_CQC_STATUS_CQ_WRITE_FAIL  = 0xa,
+};
+
+enum {
+        MLX5_CQC_CQE_SZ_64_BYTES   = 0x0,
+        MLX5_CQC_CQE_SZ_128_BYTES  = 0x1,
+};
+
+enum {
+        MLX5_CQC_ST_SOLICITED_NOTIFICATION_REQUEST_ARMED  = 0x6,
+        MLX5_CQC_ST_NOTIFICATION_REQUEST_ARMED            = 0x9,
+        MLX5_CQC_ST_FIRED                                 = 0xa,
+};
+
+struct mlx5_ifc_cqc_bits {
+        u8         status[0x4];
+        u8         reserved_0[0x4];
+        u8         cqe_sz[0x3];
+        u8         cc[0x1];
+        u8         reserved_1[0x1];
+        u8         scqe_break_moderation_en[0x1];
+        u8         oi[0x1];
+        u8         reserved_2[0x2];
+        u8         cqe_zip_en[0x1];
+        u8         mini_cqe_res_format[0x2];
+        u8         st[0x4];
+        u8         reserved_3[0x8];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x14];
+        u8         page_offset[0x6];
+        u8         reserved_6[0x6];
+
+        u8         reserved_7[0x3];
+        u8         log_cq_size[0x5];
+        u8         uar_page[0x18];
+
+        u8         reserved_8[0x4];
+        u8         cq_period[0xc];
+        u8         cq_max_count[0x10];
+
+        u8         reserved_9[0x18];
+        u8         c_eqn[0x8];
+
+        u8         reserved_10[0x3];
+        u8         log_page_size[0x5];
+        u8         reserved_11[0x18];
+
+        u8         reserved_12[0x20];
+
+        u8         reserved_13[0x8];
+        u8         last_notified_index[0x18];
+
+        u8         reserved_14[0x8];
+        u8         last_solicit_index[0x18];
+
+        u8         reserved_15[0x8];
+        u8         consumer_counter[0x18];
+
+        u8         reserved_16[0x8];
+        u8         producer_counter[0x18];
+
+        u8         reserved_17[0x40];
+
+        u8         dbr_addr[0x40];
+};
+
+union mlx5_ifc_cong_control_roce_ecn_auto_bits {
+        struct mlx5_ifc_cong_control_802_1qau_rp_bits cong_control_802_1qau_rp;
+        struct mlx5_ifc_cong_control_r_roce_ecn_rp_bits cong_control_r_roce_ecn_rp;
+        struct mlx5_ifc_cong_control_r_roce_ecn_np_bits cong_control_r_roce_ecn_np;
+        u8         reserved_0[0x800];
+};
+
+struct mlx5_ifc_query_adapter_param_block_bits {
+        u8         reserved_0[0xc0];
+
+        u8         reserved_1[0x8];
+        u8         ieee_vendor_id[0x18];
+
+        u8         reserved_2[0x10];
+        u8         vsd_vendor_id[0x10];
+
+        u8         vsd[208][0x8];
+
+        u8         vsd_contd_psid[16][0x8];
+};
+
+union mlx5_ifc_modify_field_select_resize_field_select_auto_bits {
+        struct mlx5_ifc_modify_field_select_bits modify_field_select;
+        struct mlx5_ifc_resize_field_select_bits resize_field_select;
+        u8         reserved_0[0x20];
+};
+
+union mlx5_ifc_field_select_802_1_r_roce_auto_bits {
+        struct mlx5_ifc_field_select_802_1qau_rp_bits field_select_802_1qau_rp;
+        struct mlx5_ifc_field_select_r_roce_rp_bits field_select_r_roce_rp;
+        struct mlx5_ifc_field_select_r_roce_np_bits field_select_r_roce_np;
+        u8         reserved_0[0x20];
+};
+
+union mlx5_ifc_eth_cntrs_grp_data_layout_auto_bits {
+        struct mlx5_ifc_eth_802_3_cntrs_grp_data_layout_bits eth_802_3_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_2863_cntrs_grp_data_layout_bits eth_2863_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits eth_2819_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_3635_cntrs_grp_data_layout_bits eth_3635_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_extended_cntrs_grp_data_layout_bits eth_extended_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_per_prio_grp_data_layout_bits eth_per_prio_grp_data_layout;
+        struct mlx5_ifc_eth_per_traffic_grp_data_layout_bits eth_per_traffic_grp_data_layout;
+        struct mlx5_ifc_phys_layer_cntrs_bits phys_layer_cntrs;
+        u8         reserved_0[0x7c0];
+};
+
+union mlx5_ifc_event_auto_bits {
+        struct mlx5_ifc_comp_event_bits comp_event;
+        struct mlx5_ifc_dct_events_bits dct_events;
+        struct mlx5_ifc_qp_events_bits qp_events;
+        struct mlx5_ifc_wqe_associated_page_fault_event_bits wqe_associated_page_fault_event;
+        struct mlx5_ifc_rdma_page_fault_event_bits rdma_page_fault_event;
+        struct mlx5_ifc_cq_error_bits cq_error;
+        struct mlx5_ifc_dropped_packet_logged_bits dropped_packet_logged;
+        struct mlx5_ifc_port_state_change_event_bits port_state_change_event;
+        struct mlx5_ifc_gpio_event_bits gpio_event;
+        struct mlx5_ifc_db_bf_congestion_event_bits db_bf_congestion_event;
+        struct mlx5_ifc_stall_vl_event_bits stall_vl_event;
+        struct mlx5_ifc_cmd_inter_comp_event_bits cmd_inter_comp_event;
+        u8         reserved_0[0xe0];
+};
+
+struct mlx5_ifc_health_buffer_bits {
+        u8         reserved_0[0x100];
+
+        u8         assert_existptr[0x20];
+
+        u8         assert_callra[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         fw_version[0x20];
+
+        u8         hw_id[0x20];
+
+        u8         reserved_2[0x20];
+
+        u8         irisc_index[0x8];
+        u8         synd[0x8];
+        u8         ext_synd[0x10];
+};
+
+struct mlx5_ifc_register_loopback_control_bits {
+        u8         no_lb[0x1];
+        u8         reserved_0[0x7];
+        u8         port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_teardown_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_TEARDOWN_HCA_IN_PROFILE_GRACEFUL_CLOSE  = 0x0,
+        MLX5_TEARDOWN_HCA_IN_PROFILE_PANIC_CLOSE     = 0x1,
+};
+
+struct mlx5_ifc_teardown_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         profile[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_sqerr2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_sqerr2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_sqd2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_sqd2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_set_roce_address_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_roce_address_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         roce_address_index[0x10];
+        u8         reserved_2[0x10];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_roce_addr_layout_bits roce_address;
+};
+
+struct mlx5_ifc_set_mad_demux_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_SET_MAD_DEMUX_IN_DEMUX_MODE_PASS_ALL   = 0x0,
+        MLX5_SET_MAD_DEMUX_IN_DEMUX_MODE_SELECTIVE  = 0x2,
+};
+
+struct mlx5_ifc_set_mad_demux_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x6];
+        u8         demux_mode[0x2];
+        u8         reserved_4[0x18];
+};
+
+struct mlx5_ifc_set_l2_table_entry_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_l2_table_entry_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x8];
+        u8         table_index[0x18];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x13];
+        u8         vlan_valid[0x1];
+        u8         vlan[0xc];
+
+        struct mlx5_ifc_mac_address_layout_bits mac_address;
+
+        u8         reserved_6[0xc0];
+};
+
+struct mlx5_ifc_set_issi_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_issi_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         current_issi[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_set_hca_cap_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
 };
 
 struct mlx5_ifc_set_hca_cap_in_bits {
@@ -313,10 +2764,653 @@ struct mlx5_ifc_set_hca_cap_in_bits {
 
         u8         reserved_2[0x40];
 
-        struct mlx5_ifc_cmd_hca_cap_bits hca_capability_struct;
+        union mlx5_ifc_hca_cap_union_bits capability;
 };
 
-struct mlx5_ifc_query_hca_cap_in_bits {
+struct mlx5_ifc_set_fte_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_set_fte_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x40];
+
+        u8         flow_index[0x20];
+
+        u8         reserved_6[0xe0];
+
+        struct mlx5_ifc_flow_context_bits flow_context;
+};
+
+struct mlx5_ifc_rts2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rts2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_rtr2rts_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rtr2rts_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_rst2init_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rst2init_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_query_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_xrc_srqc_bits xrc_srq_context_entry;
+
+        u8         reserved_2[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+enum {
+        MLX5_QUERY_VPORT_STATE_OUT_STATE_DOWN  = 0x0,
+        MLX5_QUERY_VPORT_STATE_OUT_STATE_UP    = 0x1,
+};
+
+struct mlx5_ifc_query_vport_state_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         reserved_2[0x18];
+        u8         admin_state[0x4];
+        u8         state[0x4];
+};
+
+enum {
+        MLX5_QUERY_VPORT_STATE_IN_OP_MOD_VNIC_VPORT  = 0x0,
+};
+
+struct mlx5_ifc_query_vport_state_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_vport_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_traffic_counter_bits received_errors;
+
+        struct mlx5_ifc_traffic_counter_bits transmit_errors;
+
+        struct mlx5_ifc_traffic_counter_bits received_ib_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_ib_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits received_ib_multicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_ib_multicast;
+
+        struct mlx5_ifc_traffic_counter_bits received_eth_broadcast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_eth_broadcast;
+
+        struct mlx5_ifc_traffic_counter_bits received_eth_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_eth_unicast;
+
+        struct mlx5_ifc_traffic_counter_bits received_eth_multicast;
+
+        struct mlx5_ifc_traffic_counter_bits transmitted_eth_multicast;
+
+        u8         reserved_2[0xa00];
+};
+
+enum {
+        MLX5_QUERY_VPORT_COUNTER_IN_OP_MOD_VPORT_COUNTERS  = 0x0,
+};
+
+struct mlx5_ifc_query_vport_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x60];
+
+        u8         clear[0x1];
+        u8         reserved_4[0x1f];
+
+        u8         reserved_5[0x20];
+};
+
+struct mlx5_ifc_query_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_tisc_bits tis_context;
+};
+
+struct mlx5_ifc_query_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_tirc_bits tir_context;
+};
+
+struct mlx5_ifc_query_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_srqc_bits srq_context_entry;
+
+        u8         reserved_2[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_sqc_bits sq_context;
+};
+
+struct mlx5_ifc_query_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         sqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_special_contexts_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         resd_lkey[0x20];
+};
+
+struct mlx5_ifc_query_special_contexts_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_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_rqtc_bits rqt_context;
+};
+
+struct mlx5_ifc_query_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_rqc_bits rq_context;
+};
+
+struct mlx5_ifc_query_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_roce_address_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_roce_addr_layout_bits roce_address;
+};
+
+struct mlx5_ifc_query_roce_address_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         roce_address_index[0x10];
+        u8         reserved_2[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xc0];
+
+        struct mlx5_ifc_rmpc_bits rmp_context;
+};
+
+struct mlx5_ifc_query_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_2[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_3[0x80];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_q_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         rx_write_requests[0x20];
+
+        u8         reserved_2[0x20];
+
+        u8         rx_read_requests[0x20];
+
+        u8         reserved_3[0x20];
+
+        u8         rx_atomic_requests[0x20];
+
+        u8         reserved_4[0x20];
+
+        u8         rx_dct_connect[0x20];
+
+        u8         reserved_5[0x20];
+
+        u8         out_of_buffer[0x20];
+
+        u8         reserved_6[0x20];
+
+        u8         out_of_sequence[0x20];
+
+        u8         reserved_7[0x620];
+};
+
+struct mlx5_ifc_query_q_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x80];
+
+        u8         clear[0x1];
+        u8         reserved_3[0x1f];
+
+        u8         reserved_4[0x18];
+        u8         counter_set_id[0x8];
+};
+
+struct mlx5_ifc_query_pages_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x10];
+        u8         function_id[0x10];
+
+        u8         num_pages[0x20];
+};
+
+enum {
+        MLX5_QUERY_PAGES_IN_OP_MOD_BOOT_PAGES     = 0x1,
+        MLX5_QUERY_PAGES_IN_OP_MOD_INIT_PAGES     = 0x2,
+        MLX5_QUERY_PAGES_IN_OP_MOD_REGULAR_PAGES  = 0x3,
+};
+
+struct mlx5_ifc_query_pages_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_nic_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_nic_vport_context_bits nic_vport_context;
+};
+
+struct mlx5_ifc_query_nic_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x5];
+        u8         allowed_list_type[0x3];
+        u8         reserved_4[0x18];
+};
+
+struct mlx5_ifc_query_mkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_mkc_bits memory_key_mkey_entry;
+
+        u8         reserved_2[0x600];
+
+        u8         bsf0_klm0_pas_mtt0_1[16][0x8];
+
+        u8         bsf1_klm1_pas_mtt2_3[16][0x8];
+};
+
+struct mlx5_ifc_query_mkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         mkey_index[0x18];
+
+        u8         pg_access[0x1];
+        u8         reserved_3[0x1f];
+};
+
+struct mlx5_ifc_query_mad_demux_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         mad_dumux_parameters_block[0x20];
+};
+
+struct mlx5_ifc_query_mad_demux_in_bits {
         u8         opcode[0x10];
         u8         reserved_0[0x10];
 
@@ -326,6 +3420,146 @@ struct mlx5_ifc_query_hca_cap_in_bits {
         u8         reserved_2[0x40];
 };
 
+struct mlx5_ifc_query_l2_table_entry_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xa0];
+
+        u8         reserved_2[0x13];
+        u8         vlan_valid[0x1];
+        u8         vlan[0xc];
+
+        struct mlx5_ifc_mac_address_layout_bits mac_address;
+
+        u8         reserved_3[0xc0];
+};
+
+struct mlx5_ifc_query_l2_table_entry_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x8];
+        u8         table_index[0x18];
+
+        u8         reserved_4[0x140];
+};
+
+struct mlx5_ifc_query_issi_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x10];
+        u8         current_issi[0x10];
+
+        u8         reserved_2[0xa0];
+
+        u8         supported_issi_reserved[76][0x8];
+        u8         supported_issi_dw0[0x20];
+};
+
+struct mlx5_ifc_query_issi_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_vport_pkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_pkey_bits pkey[0];
+};
+
+struct mlx5_ifc_query_hca_vport_pkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x10];
+        u8         pkey_index[0x10];
+};
+
+struct mlx5_ifc_query_hca_vport_gid_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         gids_num[0x10];
+        u8         reserved_2[0x10];
+
+        struct mlx5_ifc_array128_auto_bits gid[0];
+};
+
+struct mlx5_ifc_query_hca_vport_gid_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x10];
+        u8         gid_index[0x10];
+};
+
+struct mlx5_ifc_query_hca_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_hca_vport_context_bits hca_vport_context;
+};
+
+struct mlx5_ifc_query_hca_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x20];
+};
+
 struct mlx5_ifc_query_hca_cap_out_bits {
         u8         status[0x8];
         u8         reserved_0[0x18];
@@ -334,16 +3568,3216 @@ struct mlx5_ifc_query_hca_cap_out_bits {
 
         u8         reserved_1[0x40];
 
-        u8         capability_struct[256][0x8];
+        union mlx5_ifc_hca_cap_union_bits capability;
 };
 
-struct mlx5_ifc_set_hca_cap_out_bits {
+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_flow_table_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x80];
+
+        u8         reserved_2[0x8];
+        u8         level[0x8];
+        u8         reserved_3[0x8];
+        u8         log_size[0x8];
+
+        u8         reserved_4[0x120];
+};
+
+struct mlx5_ifc_query_flow_table_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x140];
+};
+
+struct mlx5_ifc_query_fte_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x1c0];
+
+        struct mlx5_ifc_flow_context_bits flow_context;
+};
+
+struct mlx5_ifc_query_fte_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x40];
+
+        u8         flow_index[0x20];
+
+        u8         reserved_6[0xe0];
+};
+
+enum {
+        MLX5_QUERY_FLOW_GROUP_OUT_MATCH_CRITERIA_ENABLE_OUTER_HEADERS    = 0x0,
+        MLX5_QUERY_FLOW_GROUP_OUT_MATCH_CRITERIA_ENABLE_MISC_PARAMETERS  = 0x1,
+        MLX5_QUERY_FLOW_GROUP_OUT_MATCH_CRITERIA_ENABLE_INNER_HEADERS    = 0x2,
+};
+
+struct mlx5_ifc_query_flow_group_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0xa0];
+
+        u8         start_flow_index[0x20];
+
+        u8         reserved_2[0x20];
+
+        u8         end_flow_index[0x20];
+
+        u8         reserved_3[0xa0];
+
+        u8         reserved_4[0x18];
+        u8         match_criteria_enable[0x8];
+
+        struct mlx5_ifc_fte_match_param_bits match_criteria;
+
+        u8         reserved_5[0xe00];
+};
+
+struct mlx5_ifc_query_flow_group_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         group_id[0x20];
+
+        u8         reserved_5[0x120];
+};
+
+struct mlx5_ifc_query_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_eqc_bits eq_context_entry;
+
+        u8         reserved_2[0x40];
+
+        u8         event_bitmask[0x40];
+
+        u8         reserved_3[0x580];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_eq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_dctc_bits dct_context_entry;
+
+        u8         reserved_2[0x180];
+};
+
+struct mlx5_ifc_query_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cq_out_bits {
         u8         status[0x8];
         u8         reserved_0[0x18];
 
         u8         syndrome[0x20];
 
         u8         reserved_1[0x40];
+
+        struct mlx5_ifc_cqc_bits cq_context;
+
+        u8         reserved_2[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_query_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cong_status_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         enable[0x1];
+        u8         tag_enable[0x1];
+        u8         reserved_2[0x1e];
+};
+
+struct mlx5_ifc_query_cong_status_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         priority[0x4];
+        u8         cong_protocol[0x4];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cong_statistics_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         cur_flows[0x20];
+
+        u8         sum_flows[0x20];
+
+        u8         cnp_ignored_high[0x20];
+
+        u8         cnp_ignored_low[0x20];
+
+        u8         cnp_handled_high[0x20];
+
+        u8         cnp_handled_low[0x20];
+
+        u8         reserved_2[0x100];
+
+        u8         time_stamp_high[0x20];
+
+        u8         time_stamp_low[0x20];
+
+        u8         accumulators_period[0x20];
+
+        u8         ecn_marked_roce_packets_high[0x20];
+
+        u8         ecn_marked_roce_packets_low[0x20];
+
+        u8         cnps_sent_high[0x20];
+
+        u8         cnps_sent_low[0x20];
+
+        u8         reserved_3[0x560];
+};
+
+struct mlx5_ifc_query_cong_statistics_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         clear[0x1];
+        u8         reserved_2[0x1f];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_cong_params_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        union mlx5_ifc_cong_control_roce_ecn_auto_bits congestion_parameters;
+};
+
+struct mlx5_ifc_query_cong_params_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x1c];
+        u8         cong_protocol[0x4];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_query_adapter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        struct mlx5_ifc_query_adapter_param_block_bits query_adapter_struct;
+};
+
+struct mlx5_ifc_query_adapter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_qp_2rst_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_qp_2rst_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_qp_2err_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_qp_2err_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_page_fault_resume_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_page_fault_resume_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         error[0x1];
+        u8         reserved_2[0x4];
+        u8         rdma[0x1];
+        u8         read_write[0x1];
+        u8         req_res[0x1];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_nop_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_nop_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_modify_vport_state_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_vport_state_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x18];
+        u8         admin_state[0x4];
+        u8         reserved_4[0x4];
+};
+
+struct mlx5_ifc_modify_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_tisc_bits ctx;
+};
+
+struct mlx5_ifc_modify_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_tirc_bits ctx;
+};
+
+struct mlx5_ifc_modify_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         sq_state[0x4];
+        u8         reserved_2[0x4];
+        u8         sqn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_sqc_bits ctx;
+};
+
+struct mlx5_ifc_modify_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_rqtc_bits ctx;
+};
+
+struct mlx5_ifc_modify_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         rq_state[0x4];
+        u8         reserved_2[0x4];
+        u8         rqn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         modify_bitmask[0x40];
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_rqc_bits ctx;
+};
+
+struct mlx5_ifc_modify_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_rmp_bitmask_bits {
+        u8         reserved[0x20];
+
+        u8         reserved1[0x1f];
+        u8         lwm[0x1];
+};
+
+struct mlx5_ifc_modify_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         rmp_state[0x4];
+        u8         reserved_2[0x4];
+        u8         rmpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_rmp_bitmask_bits bitmask;
+
+        u8         reserved_4[0x40];
+
+        struct mlx5_ifc_rmpc_bits ctx;
+};
+
+struct mlx5_ifc_modify_nic_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_nic_vport_field_select_bits {
+        u8         reserved_0[0x1c];
+        u8         permanent_address[0x1];
+        u8         addresses_list[0x1];
+        u8         roce_en[0x1];
+        u8         reserved_1[0x1];
+};
+
+struct mlx5_ifc_modify_nic_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xf];
+        u8         vport_number[0x10];
+
+        struct mlx5_ifc_modify_nic_vport_field_select_bits field_select;
+
+        u8         reserved_3[0x780];
+
+        struct mlx5_ifc_nic_vport_context_bits nic_vport_context;
+};
+
+struct mlx5_ifc_modify_hca_vport_context_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_hca_vport_context_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         other_vport[0x1];
+        u8         reserved_2[0xb];
+        u8         port_num[0x4];
+        u8         vport_number[0x10];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_hca_vport_context_bits hca_vport_context;
+};
+
+struct mlx5_ifc_modify_cq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_MODIFY_CQ_IN_OP_MOD_MODIFY_CQ  = 0x0,
+        MLX5_MODIFY_CQ_IN_OP_MOD_RESIZE_CQ  = 0x1,
+};
+
+struct mlx5_ifc_modify_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         cqn[0x18];
+
+        union mlx5_ifc_modify_field_select_resize_field_select_auto_bits modify_field_select_resize_field_select;
+
+        struct mlx5_ifc_cqc_bits cq_context;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_modify_cong_status_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_cong_status_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         priority[0x4];
+        u8         cong_protocol[0x4];
+
+        u8         enable[0x1];
+        u8         tag_enable[0x1];
+        u8         reserved_3[0x1e];
+};
+
+struct mlx5_ifc_modify_cong_params_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_modify_cong_params_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x1c];
+        u8         cong_protocol[0x4];
+
+        union mlx5_ifc_field_select_802_1_r_roce_auto_bits field_select;
+
+        u8         reserved_3[0x80];
+
+        union mlx5_ifc_cong_control_roce_ecn_auto_bits congestion_parameters;
+};
+
+struct mlx5_ifc_manage_pages_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         output_num_entries[0x20];
+
+        u8         reserved_1[0x20];
+
+        u8         pas[0][0x40];
+};
+
+enum {
+        MLX5_MANAGE_PAGES_IN_OP_MOD_ALLOCATION_FAIL     = 0x0,
+        MLX5_MANAGE_PAGES_IN_OP_MOD_ALLOCATION_SUCCESS  = 0x1,
+        MLX5_MANAGE_PAGES_IN_OP_MOD_HCA_RETURN_PAGES    = 0x2,
+};
+
+struct mlx5_ifc_manage_pages_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         input_num_entries[0x20];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_mad_ifc_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         response_mad_packet[256][0x8];
+};
+
+struct mlx5_ifc_mad_ifc_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         remote_lid[0x10];
+        u8         reserved_2[0x8];
+        u8         port[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         mad[256][0x8];
+};
+
+struct mlx5_ifc_init_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_init_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_init2rtr_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_init2rtr_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_init2init_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_init2init_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_4[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_get_dropped_packet_log_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         packet_headers_log[128][0x8];
+
+        u8         packet_syndrome[64][0x8];
+};
+
+struct mlx5_ifc_get_dropped_packet_log_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_gen_eqe_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_3[0x20];
+
+        u8         eqe[64][0x8];
+};
+
+struct mlx5_ifc_gen_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_enable_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+};
+
+struct mlx5_ifc_enable_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_drain_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_drain_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_disable_hca_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x20];
+};
+
+struct mlx5_ifc_disable_hca_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         function_id[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_detach_from_mcg_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_detach_from_mcg_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         multicast_gid[16][0x8];
+};
+
+struct mlx5_ifc_destroy_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         sqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_psv_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_psv_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         psvn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_mkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_mkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         mkey_index[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_flow_table_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_flow_table_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x140];
+};
+
+struct mlx5_ifc_destroy_flow_group_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_flow_group_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         group_id[0x20];
+
+        u8         reserved_5[0x120];
+};
+
+struct mlx5_ifc_destroy_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_eq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_destroy_cq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_destroy_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_delete_vxlan_udp_dport_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_delete_vxlan_udp_dport_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x10];
+        u8         vxlan_udp_port[0x10];
+};
+
+struct mlx5_ifc_delete_l2_table_entry_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_delete_l2_table_entry_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x8];
+        u8         table_index[0x18];
+
+        u8         reserved_4[0x140];
+};
+
+struct mlx5_ifc_delete_fte_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_delete_fte_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x40];
+
+        u8         flow_index[0x20];
+
+        u8         reserved_6[0xe0];
+};
+
+struct mlx5_ifc_dealloc_xrcd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_xrcd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrcd[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_uar_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_uar_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         uar[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_transport_domain_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_transport_domain_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         transport_domain[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_q_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_q_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x18];
+        u8         counter_set_id[0x8];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_dealloc_pd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_dealloc_pd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         pd[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_create_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_xrc_srqc_bits xrc_srq_context_entry;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_tis_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         tisn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_tis_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_tisc_bits ctx;
+};
+
+struct mlx5_ifc_create_tir_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         tirn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_tir_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_tirc_bits ctx;
+};
+
+struct mlx5_ifc_create_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         srqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_srqc_bits srq_context_entry;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_sq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         sqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_sq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_sqc_bits ctx;
+};
+
+struct mlx5_ifc_create_rqt_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         rqtn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_rqt_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_rqtc_bits rqt_context;
+};
+
+struct mlx5_ifc_create_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         rqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_rqc_bits ctx;
+};
+
+struct mlx5_ifc_create_rmp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         rmpn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_rmp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0xc0];
+
+        struct mlx5_ifc_rmpc_bits ctx;
+};
+
+struct mlx5_ifc_create_qp_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_qp_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         opt_param_mask[0x20];
+
+        u8         reserved_3[0x20];
+
+        struct mlx5_ifc_qpc_bits qpc;
+
+        u8         reserved_4[0x80];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_psv_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         reserved_2[0x8];
+        u8         psv0_index[0x18];
+
+        u8         reserved_3[0x8];
+        u8         psv1_index[0x18];
+
+        u8         reserved_4[0x8];
+        u8         psv2_index[0x18];
+
+        u8         reserved_5[0x8];
+        u8         psv3_index[0x18];
+};
+
+struct mlx5_ifc_create_psv_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         num_psv[0x4];
+        u8         reserved_2[0x4];
+        u8         pd[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_create_mkey_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         mkey_index[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_mkey_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         pg_access[0x1];
+        u8         reserved_3[0x1f];
+
+        struct mlx5_ifc_mkc_bits memory_key_mkey_entry;
+
+        u8         reserved_4[0x80];
+
+        u8         translations_octword_actual_size[0x20];
+
+        u8         reserved_5[0x560];
+
+        u8         klm_pas_mtt[0][0x20];
+};
+
+struct mlx5_ifc_create_flow_table_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_flow_table_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x20];
+
+        u8         reserved_5[0x8];
+        u8         level[0x8];
+        u8         reserved_6[0x8];
+        u8         log_size[0x8];
+
+        u8         reserved_7[0x120];
+};
+
+struct mlx5_ifc_create_flow_group_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         group_id[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+enum {
+        MLX5_CREATE_FLOW_GROUP_IN_MATCH_CRITERIA_ENABLE_OUTER_HEADERS    = 0x0,
+        MLX5_CREATE_FLOW_GROUP_IN_MATCH_CRITERIA_ENABLE_MISC_PARAMETERS  = 0x1,
+        MLX5_CREATE_FLOW_GROUP_IN_MATCH_CRITERIA_ENABLE_INNER_HEADERS    = 0x2,
+};
+
+struct mlx5_ifc_create_flow_group_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        u8         table_type[0x8];
+        u8         reserved_3[0x18];
+
+        u8         reserved_4[0x8];
+        u8         table_id[0x18];
+
+        u8         reserved_5[0x20];
+
+        u8         start_flow_index[0x20];
+
+        u8         reserved_6[0x20];
+
+        u8         end_flow_index[0x20];
+
+        u8         reserved_7[0xa0];
+
+        u8         reserved_8[0x18];
+        u8         match_criteria_enable[0x8];
+
+        struct mlx5_ifc_fte_match_param_bits match_criteria;
+
+        u8         reserved_9[0xe00];
+};
+
+struct mlx5_ifc_create_eq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x18];
+        u8         eq_number[0x8];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_eq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_eqc_bits eq_context_entry;
+
+        u8         reserved_3[0x40];
+
+        u8         event_bitmask[0x40];
+
+        u8         reserved_4[0x580];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_create_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         dctn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_dctc_bits dct_context_entry;
+
+        u8         reserved_3[0x180];
+};
+
+struct mlx5_ifc_create_cq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         cqn[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_create_cq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+
+        struct mlx5_ifc_cqc_bits cq_context;
+
+        u8         reserved_3[0x600];
+
+        u8         pas[0][0x40];
+};
+
+struct mlx5_ifc_config_int_moderation_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x4];
+        u8         min_delay[0xc];
+        u8         int_vector[0x10];
+
+        u8         reserved_2[0x20];
+};
+
+enum {
+        MLX5_CONFIG_INT_MODERATION_IN_OP_MOD_WRITE  = 0x0,
+        MLX5_CONFIG_INT_MODERATION_IN_OP_MOD_READ   = 0x1,
+};
+
+struct mlx5_ifc_config_int_moderation_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x4];
+        u8         min_delay[0xc];
+        u8         int_vector[0x10];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_attach_to_mcg_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_attach_to_mcg_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         qpn[0x18];
+
+        u8         reserved_3[0x20];
+
+        u8         multicast_gid[16][0x8];
+};
+
+struct mlx5_ifc_arm_xrc_srq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_ARM_XRC_SRQ_IN_OP_MOD_XRC_SRQ  = 0x1,
+};
+
+struct mlx5_ifc_arm_xrc_srq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         xrc_srqn[0x18];
+
+        u8         reserved_3[0x10];
+        u8         lwm[0x10];
+};
+
+struct mlx5_ifc_arm_rq_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+enum {
+        MLX5_ARM_RQ_IN_OP_MOD_SRQ_  = 0x1,
+};
+
+struct mlx5_ifc_arm_rq_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         srq_number[0x18];
+
+        u8         reserved_3[0x10];
+        u8         lwm[0x10];
+};
+
+struct mlx5_ifc_arm_dct_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_arm_dct_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x8];
+        u8         dct_number[0x18];
+
+        u8         reserved_3[0x20];
+};
+
+struct mlx5_ifc_alloc_xrcd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         xrcd[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_xrcd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_uar_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         uar[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_uar_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_transport_domain_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         transport_domain[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_transport_domain_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_q_counter_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x18];
+        u8         counter_set_id[0x8];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_q_counter_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_alloc_pd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x8];
+        u8         pd[0x18];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_alloc_pd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_add_vxlan_udp_dport_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+};
+
+struct mlx5_ifc_add_vxlan_udp_dport_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x10];
+        u8         vxlan_udp_port[0x10];
+};
+
+struct mlx5_ifc_access_register_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         reserved_1[0x40];
+
+        u8         register_data[0][0x20];
+};
+
+enum {
+        MLX5_ACCESS_REGISTER_IN_OP_MOD_WRITE  = 0x0,
+        MLX5_ACCESS_REGISTER_IN_OP_MOD_READ   = 0x1,
+};
+
+struct mlx5_ifc_access_register_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         reserved_2[0x10];
+        u8         register_id[0x10];
+
+        u8         argument[0x20];
+
+        u8         register_data[0][0x20];
+};
+
+struct mlx5_ifc_sltp_reg_bits {
+        u8         status[0x4];
+        u8         version[0x4];
+        u8         local_port[0x8];
+        u8         pnat[0x2];
+        u8         reserved_0[0x2];
+        u8         lane[0x4];
+        u8         reserved_1[0x8];
+
+        u8         reserved_2[0x20];
+
+        u8         reserved_3[0x7];
+        u8         polarity[0x1];
+        u8         ob_tap0[0x8];
+        u8         ob_tap1[0x8];
+        u8         ob_tap2[0x8];
+
+        u8         reserved_4[0xc];
+        u8         ob_preemp_mode[0x4];
+        u8         ob_reg[0x8];
+        u8         ob_bias[0x8];
+
+        u8         reserved_5[0x20];
+};
+
+struct mlx5_ifc_slrg_reg_bits {
+        u8         status[0x4];
+        u8         version[0x4];
+        u8         local_port[0x8];
+        u8         pnat[0x2];
+        u8         reserved_0[0x2];
+        u8         lane[0x4];
+        u8         reserved_1[0x8];
+
+        u8         time_to_link_up[0x10];
+        u8         reserved_2[0xc];
+        u8         grade_lane_speed[0x4];
+
+        u8         grade_version[0x8];
+        u8         grade[0x18];
+
+        u8         reserved_3[0x4];
+        u8         height_grade_type[0x4];
+        u8         height_grade[0x18];
+
+        u8         height_dz[0x10];
+        u8         height_dv[0x10];
+
+        u8         reserved_4[0x10];
+        u8         height_sigma[0x10];
+
+        u8         reserved_5[0x20];
+
+        u8         reserved_6[0x4];
+        u8         phase_grade_type[0x4];
+        u8         phase_grade[0x18];
+
+        u8         reserved_7[0x8];
+        u8         phase_eo_pos[0x8];
+        u8         reserved_8[0x8];
+        u8         phase_eo_neg[0x8];
+
+        u8         ffe_set_tested[0x10];
+        u8         test_errors_per_lane[0x10];
+};
+
+struct mlx5_ifc_pvlc_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x1c];
+        u8         vl_hw_cap[0x4];
+
+        u8         reserved_3[0x1c];
+        u8         vl_admin[0x4];
+
+        u8         reserved_4[0x1c];
+        u8         vl_operational[0x4];
+};
+
+struct mlx5_ifc_pude_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         reserved_0[0x4];
+        u8         admin_status[0x4];
+        u8         reserved_1[0x4];
+        u8         oper_status[0x4];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_ptys_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0xd];
+        u8         proto_mask[0x3];
+
+        u8         reserved_2[0x40];
+
+        u8         eth_proto_capability[0x20];
+
+        u8         ib_link_width_capability[0x10];
+        u8         ib_proto_capability[0x10];
+
+        u8         reserved_3[0x20];
+
+        u8         eth_proto_admin[0x20];
+
+        u8         ib_link_width_admin[0x10];
+        u8         ib_proto_admin[0x10];
+
+        u8         reserved_4[0x20];
+
+        u8         eth_proto_oper[0x20];
+
+        u8         ib_link_width_oper[0x10];
+        u8         ib_proto_oper[0x10];
+
+        u8         reserved_5[0x20];
+
+        u8         eth_proto_lp_advertise[0x20];
+
+        u8         reserved_6[0x60];
+};
+
+struct mlx5_ifc_ptas_reg_bits {
+        u8         reserved_0[0x20];
+
+        u8         algorithm_options[0x10];
+        u8         reserved_1[0x4];
+        u8         repetitions_mode[0x4];
+        u8         num_of_repetitions[0x8];
+
+        u8         grade_version[0x8];
+        u8         height_grade_type[0x4];
+        u8         phase_grade_type[0x4];
+        u8         height_grade_weight[0x8];
+        u8         phase_grade_weight[0x8];
+
+        u8         gisim_measure_bits[0x10];
+        u8         adaptive_tap_measure_bits[0x10];
+
+        u8         ber_bath_high_error_threshold[0x10];
+        u8         ber_bath_mid_error_threshold[0x10];
+
+        u8         ber_bath_low_error_threshold[0x10];
+        u8         one_ratio_high_threshold[0x10];
+
+        u8         one_ratio_high_mid_threshold[0x10];
+        u8         one_ratio_low_mid_threshold[0x10];
+
+        u8         one_ratio_low_threshold[0x10];
+        u8         ndeo_error_threshold[0x10];
+
+        u8         mixer_offset_step_size[0x10];
+        u8         reserved_2[0x8];
+        u8         mix90_phase_for_voltage_bath[0x8];
+
+        u8         mixer_offset_start[0x10];
+        u8         mixer_offset_end[0x10];
+
+        u8         reserved_3[0x15];
+        u8         ber_test_time[0xb];
+};
+
+struct mlx5_ifc_pspa_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         sub_port[0x8];
+        u8         reserved_0[0x8];
+
+        u8         reserved_1[0x20];
+};
+
+struct mlx5_ifc_pqdr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x5];
+        u8         prio[0x3];
+        u8         reserved_2[0x6];
+        u8         mode[0x2];
+
+        u8         reserved_3[0x20];
+
+        u8         reserved_4[0x10];
+        u8         min_threshold[0x10];
+
+        u8         reserved_5[0x10];
+        u8         max_threshold[0x10];
+
+        u8         reserved_6[0x10];
+        u8         mark_probability_denominator[0x10];
+
+        u8         reserved_7[0x60];
+};
+
+struct mlx5_ifc_ppsc_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x60];
+
+        u8         reserved_3[0x1c];
+        u8         wrps_admin[0x4];
+
+        u8         reserved_4[0x1c];
+        u8         wrps_status[0x4];
+
+        u8         reserved_5[0x8];
+        u8         up_threshold[0x8];
+        u8         reserved_6[0x8];
+        u8         down_threshold[0x8];
+
+        u8         reserved_7[0x20];
+
+        u8         reserved_8[0x1c];
+        u8         srps_admin[0x4];
+
+        u8         reserved_9[0x1c];
+        u8         srps_status[0x4];
+
+        u8         reserved_10[0x40];
+};
+
+struct mlx5_ifc_pplr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x8];
+        u8         lb_cap[0x8];
+        u8         reserved_3[0x8];
+        u8         lb_en[0x8];
+};
+
+struct mlx5_ifc_pplm_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x20];
+
+        u8         port_profile_mode[0x8];
+        u8         static_port_profile[0x8];
+        u8         active_port_profile[0x8];
+        u8         reserved_3[0x8];
+
+        u8         retransmission_active[0x8];
+        u8         fec_mode_active[0x18];
+
+        u8         reserved_4[0x20];
+};
+
+struct mlx5_ifc_ppcnt_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         pnat[0x2];
+        u8         reserved_0[0x8];
+        u8         grp[0x6];
+
+        u8         clr[0x1];
+        u8         reserved_1[0x1c];
+        u8         prio_tc[0x3];
+
+        union mlx5_ifc_eth_cntrs_grp_data_layout_auto_bits counter_set;
+};
+
+struct mlx5_ifc_ppad_reg_bits {
+        u8         reserved_0[0x3];
+        u8         single_mac[0x1];
+        u8         reserved_1[0x4];
+        u8         local_port[0x8];
+        u8         mac_47_32[0x10];
+
+        u8         mac_31_0[0x20];
+
+        u8         reserved_2[0x40];
+};
+
+struct mlx5_ifc_pmtu_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         max_mtu[0x10];
+        u8         reserved_2[0x10];
+
+        u8         admin_mtu[0x10];
+        u8         reserved_3[0x10];
+
+        u8         oper_mtu[0x10];
+        u8         reserved_4[0x10];
+};
+
+struct mlx5_ifc_pmpr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         module[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0x18];
+        u8         attenuation_5g[0x8];
+
+        u8         reserved_3[0x18];
+        u8         attenuation_7g[0x8];
+
+        u8         reserved_4[0x18];
+        u8         attenuation_12g[0x8];
+};
+
+struct mlx5_ifc_pmpe_reg_bits {
+        u8         reserved_0[0x8];
+        u8         module[0x8];
+        u8         reserved_1[0xc];
+        u8         module_status[0x4];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_pmpc_reg_bits {
+        u8         module_state_updated[32][0x8];
+};
+
+struct mlx5_ifc_pmlpn_reg_bits {
+        u8         reserved_0[0x4];
+        u8         mlpn_status[0x4];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         e[0x1];
+        u8         reserved_2[0x1f];
+};
+
+struct mlx5_ifc_pmlp_reg_bits {
+        u8         rxtx[0x1];
+        u8         reserved_0[0x7];
+        u8         local_port[0x8];
+        u8         reserved_1[0x8];
+        u8         width[0x8];
+
+        u8         lane0_module_mapping[0x20];
+
+        u8         lane1_module_mapping[0x20];
+
+        u8         lane2_module_mapping[0x20];
+
+        u8         lane3_module_mapping[0x20];
+
+        u8         reserved_2[0x160];
+};
+
+struct mlx5_ifc_pmaos_reg_bits {
+        u8         reserved_0[0x8];
+        u8         module[0x8];
+        u8         reserved_1[0x4];
+        u8         admin_status[0x4];
+        u8         reserved_2[0x4];
+        u8         oper_status[0x4];
+
+        u8         ase[0x1];
+        u8         ee[0x1];
+        u8         reserved_3[0x1c];
+        u8         e[0x2];
+
+        u8         reserved_4[0x40];
+};
+
+struct mlx5_ifc_plpc_reg_bits {
+        u8         reserved_0[0x4];
+        u8         profile_id[0xc];
+        u8         reserved_1[0x4];
+        u8         proto_mask[0x4];
+        u8         reserved_2[0x8];
+
+        u8         reserved_3[0x10];
+        u8         lane_speed[0x10];
+
+        u8         reserved_4[0x17];
+        u8         lpbf[0x1];
+        u8         fec_mode_policy[0x8];
+
+        u8         retransmission_capability[0x8];
+        u8         fec_mode_capability[0x18];
+
+        u8         retransmission_support_admin[0x8];
+        u8         fec_mode_support_admin[0x18];
+
+        u8         retransmission_request_admin[0x8];
+        u8         fec_mode_request_admin[0x18];
+
+        u8         reserved_5[0x80];
+};
+
+struct mlx5_ifc_plib_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x8];
+        u8         ib_port[0x8];
+
+        u8         reserved_2[0x60];
+};
+
+struct mlx5_ifc_plbf_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0xd];
+        u8         lbf_mode[0x3];
+
+        u8         reserved_2[0x20];
+};
+
+struct mlx5_ifc_pipg_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         dic[0x1];
+        u8         reserved_2[0x19];
+        u8         ipg[0x4];
+        u8         reserved_3[0x2];
+};
+
+struct mlx5_ifc_pifr_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0xe0];
+
+        u8         port_filter[8][0x20];
+
+        u8         port_filter_update_en[8][0x20];
+};
+
+struct mlx5_ifc_pfcc_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         ppan[0x4];
+        u8         reserved_2[0x4];
+        u8         prio_mask_tx[0x8];
+        u8         reserved_3[0x8];
+        u8         prio_mask_rx[0x8];
+
+        u8         pptx[0x1];
+        u8         aptx[0x1];
+        u8         reserved_4[0x6];
+        u8         pfctx[0x8];
+        u8         reserved_5[0x10];
+
+        u8         pprx[0x1];
+        u8         aprx[0x1];
+        u8         reserved_6[0x6];
+        u8         pfcrx[0x8];
+        u8         reserved_7[0x10];
+
+        u8         reserved_8[0x80];
+};
+
+struct mlx5_ifc_pelc_reg_bits {
+        u8         op[0x4];
+        u8         reserved_0[0x4];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         op_admin[0x8];
+        u8         op_capability[0x8];
+        u8         op_request[0x8];
+        u8         op_active[0x8];
+
+        u8         admin[0x40];
+
+        u8         capability[0x40];
+
+        u8         request[0x40];
+
+        u8         active[0x40];
+
+        u8         reserved_2[0x80];
+};
+
+struct mlx5_ifc_peir_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         reserved_2[0xc];
+        u8         error_count[0x4];
+        u8         reserved_3[0x10];
+
+        u8         reserved_4[0xc];
+        u8         lane[0x4];
+        u8         reserved_5[0x8];
+        u8         error_type[0x8];
+};
+
+struct mlx5_ifc_pcap_reg_bits {
+        u8         reserved_0[0x8];
+        u8         local_port[0x8];
+        u8         reserved_1[0x10];
+
+        u8         port_capability_mask[4][0x20];
+};
+
+struct mlx5_ifc_paos_reg_bits {
+        u8         swid[0x8];
+        u8         local_port[0x8];
+        u8         reserved_0[0x4];
+        u8         admin_status[0x4];
+        u8         reserved_1[0x4];
+        u8         oper_status[0x4];
+
+        u8         ase[0x1];
+        u8         ee[0x1];
+        u8         reserved_2[0x1c];
+        u8         e[0x2];
+
+        u8         reserved_3[0x40];
+};
+
+struct mlx5_ifc_pamp_reg_bits {
+        u8         reserved_0[0x8];
+        u8         opamp_group[0x8];
+        u8         reserved_1[0xc];
+        u8         opamp_group_type[0x4];
+
+        u8         start_index[0x10];
+        u8         reserved_2[0x4];
+        u8         num_of_indices[0xc];
+
+        u8         index_data[18][0x10];
+};
+
+struct mlx5_ifc_lane_2_module_mapping_bits {
+        u8         reserved_0[0x6];
+        u8         rx_lane[0x2];
+        u8         reserved_1[0x6];
+        u8         tx_lane[0x2];
+        u8         reserved_2[0x8];
+        u8         module[0x8];
+};
+
+struct mlx5_ifc_bufferx_reg_bits {
+        u8         reserved_0[0x6];
+        u8         lossy[0x1];
+        u8         epsb[0x1];
+        u8         reserved_1[0xc];
+        u8         size[0xc];
+
+        u8         xoff_threshold[0x10];
+        u8         xon_threshold[0x10];
+};
+
+struct mlx5_ifc_set_node_in_bits {
+        u8         node_description[64][0x8];
+};
+
+struct mlx5_ifc_register_power_settings_bits {
+        u8         reserved_0[0x18];
+        u8         power_settings_level[0x8];
+
+        u8         reserved_1[0x60];
+};
+
+struct mlx5_ifc_register_host_endianness_bits {
+        u8         he[0x1];
+        u8         reserved_0[0x1f];
+
+        u8         reserved_1[0x60];
+};
+
+struct mlx5_ifc_umr_pointer_desc_argument_bits {
+        u8         reserved_0[0x20];
+
+        u8         mkey[0x20];
+
+        u8         addressh_63_32[0x20];
+
+        u8         addressl_31_0[0x20];
+};
+
+struct mlx5_ifc_ud_adrs_vector_bits {
+        u8         dc_key[0x40];
+
+        u8         ext[0x1];
+        u8         reserved_0[0x7];
+        u8         destination_qp_dct[0x18];
+
+        u8         static_rate[0x4];
+        u8         sl_eth_prio[0x4];
+        u8         fl[0x1];
+        u8         mlid[0x7];
+        u8         rlid_udp_sport[0x10];
+
+        u8         reserved_1[0x20];
+
+        u8         rmac_47_16[0x20];
+
+        u8         rmac_15_0[0x10];
+        u8         tclass[0x8];
+        u8         hop_limit[0x8];
+
+        u8         reserved_2[0x1];
+        u8         grh[0x1];
+        u8         reserved_3[0x2];
+        u8         src_addr_index[0x8];
+        u8         flow_label[0x14];
+
+        u8         rgid_rip[16][0x8];
+};
+
+struct mlx5_ifc_pages_req_event_bits {
+        u8         reserved_0[0x10];
+        u8         function_id[0x10];
+
+        u8         num_pages[0x20];
+
+        u8         reserved_1[0xa0];
+};
+
+struct mlx5_ifc_eqe_bits {
+        u8         reserved_0[0x8];
+        u8         event_type[0x8];
+        u8         reserved_1[0x8];
+        u8         event_sub_type[0x8];
+
+        u8         reserved_2[0xe0];
+
+        union mlx5_ifc_event_auto_bits event_data;
+
+        u8         reserved_3[0x10];
+        u8         signature[0x8];
+        u8         reserved_4[0x7];
+        u8         owner[0x1];
+};
+
+enum {
+        MLX5_CMD_QUEUE_ENTRY_TYPE_PCIE_CMD_IF_TRANSPORT  = 0x7,
+};
+
+struct mlx5_ifc_cmd_queue_entry_bits {
+        u8         type[0x8];
+        u8         reserved_0[0x18];
+
+        u8         input_length[0x20];
+
+        u8         input_mailbox_pointer_63_32[0x20];
+
+        u8         input_mailbox_pointer_31_9[0x17];
+        u8         reserved_1[0x9];
+
+        u8         command_input_inline_data[16][0x8];
+
+        u8         command_output_inline_data[16][0x8];
+
+        u8         output_mailbox_pointer_63_32[0x20];
+
+        u8         output_mailbox_pointer_31_9[0x17];
+        u8         reserved_2[0x9];
+
+        u8         output_length[0x20];
+
+        u8         token[0x8];
+        u8         signature[0x8];
+        u8         reserved_3[0x8];
+        u8         status[0x7];
+        u8         ownership[0x1];
+};
+
+struct mlx5_ifc_cmd_out_bits {
+        u8         status[0x8];
+        u8         reserved_0[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         command_output[0x20];
+};
+
+struct mlx5_ifc_cmd_in_bits {
+        u8         opcode[0x10];
+        u8         reserved_0[0x10];
+
+        u8         reserved_1[0x10];
+        u8         op_mod[0x10];
+
+        u8         command[0][0x20];
+};
+
+struct mlx5_ifc_cmd_if_box_bits {
+        u8         mailbox_data[512][0x8];
+
+        u8         reserved_0[0x180];
+
+        u8         next_pointer_63_32[0x20];
+
+        u8         next_pointer_31_10[0x16];
+        u8         reserved_1[0xa];
+
+        u8         block_number[0x20];
+
+        u8         reserved_2[0x8];
+        u8         token[0x8];
+        u8         ctrl_signature[0x8];
+        u8         signature[0x8];
+};
+
+struct mlx5_ifc_mtt_bits {
+        u8         ptag_63_32[0x20];
+
+        u8         ptag_31_8[0x18];
+        u8         reserved_0[0x6];
+        u8         wr_en[0x1];
+        u8         rd_en[0x1];
+};
+
+enum {
+        MLX5_INITIAL_SEG_NIC_INTERFACE_FULL_DRIVER  = 0x0,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_DISABLED     = 0x1,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_NO_DRAM_NIC  = 0x2,
+};
+
+enum {
+        MLX5_INITIAL_SEG_NIC_INTERFACE_SUPPORTED_FULL_DRIVER  = 0x0,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_SUPPORTED_DISABLED     = 0x1,
+        MLX5_INITIAL_SEG_NIC_INTERFACE_SUPPORTED_NO_DRAM_NIC  = 0x2,
+};
+
+enum {
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_FW_INTERNAL_ERR              = 0x1,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_DEAD_IRISC                   = 0x7,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_HW_FATAL_ERR                 = 0x8,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_FW_CRC_ERR                   = 0x9,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_ICM_FETCH_PCI_ERR            = 0xa,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_ICM_PAGE_ERR                 = 0xb,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_ASYNCHRONOUS_EQ_BUF_OVERRUN  = 0xc,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_EQ_IN_ERR                    = 0xd,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_EQ_INV                       = 0xe,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_FFSER_ERR                    = 0xf,
+        MLX5_INITIAL_SEG_HEALTH_SYNDROME_HIGH_TEMP_ERR                = 0x10,
+};
+
+struct mlx5_ifc_initial_seg_bits {
+        u8         fw_rev_minor[0x10];
+        u8         fw_rev_major[0x10];
+
+        u8         cmd_interface_rev[0x10];
+        u8         fw_rev_subminor[0x10];
+
+        u8         reserved_0[0x40];
+
+        u8         cmdq_phy_addr_63_32[0x20];
+
+        u8         cmdq_phy_addr_31_12[0x14];
+        u8         reserved_1[0x2];
+        u8         nic_interface[0x2];
+        u8         log_cmdq_size[0x4];
+        u8         log_cmdq_stride[0x4];
+
+        u8         command_doorbell_vector[0x20];
+
+        u8         reserved_2[0xf00];
+
+        u8         initializing[0x1];
+        u8         reserved_3[0x4];
+        u8         nic_interface_supported[0x3];
+        u8         reserved_4[0x18];
+
+        struct mlx5_ifc_health_buffer_bits health_buffer;
+
+        u8         no_dram_nic_offset[0x20];
+
+        u8         reserved_5[0x6e40];
+
+        u8         reserved_6[0x1f];
+        u8         clear_int[0x1];
+
+        u8         health_syndrome[0x8];
+        u8         health_counter[0x18];
+
+        u8         reserved_7[0x17fc0];
+};
+
+union mlx5_ifc_ports_control_registers_document_bits {
+        struct mlx5_ifc_bufferx_reg_bits bufferx_reg;
+        struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits eth_2819_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_2863_cntrs_grp_data_layout_bits eth_2863_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_3635_cntrs_grp_data_layout_bits eth_3635_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_802_3_cntrs_grp_data_layout_bits eth_802_3_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_extended_cntrs_grp_data_layout_bits eth_extended_cntrs_grp_data_layout;
+        struct mlx5_ifc_eth_per_prio_grp_data_layout_bits eth_per_prio_grp_data_layout;
+        struct mlx5_ifc_eth_per_traffic_grp_data_layout_bits eth_per_traffic_grp_data_layout;
+        struct mlx5_ifc_lane_2_module_mapping_bits lane_2_module_mapping;
+        struct mlx5_ifc_pamp_reg_bits pamp_reg;
+        struct mlx5_ifc_paos_reg_bits paos_reg;
+        struct mlx5_ifc_pcap_reg_bits pcap_reg;
+        struct mlx5_ifc_peir_reg_bits peir_reg;
+        struct mlx5_ifc_pelc_reg_bits pelc_reg;
+        struct mlx5_ifc_pfcc_reg_bits pfcc_reg;
+        struct mlx5_ifc_phys_layer_cntrs_bits phys_layer_cntrs;
+        struct mlx5_ifc_pifr_reg_bits pifr_reg;
+        struct mlx5_ifc_pipg_reg_bits pipg_reg;
+        struct mlx5_ifc_plbf_reg_bits plbf_reg;
+        struct mlx5_ifc_plib_reg_bits plib_reg;
+        struct mlx5_ifc_plpc_reg_bits plpc_reg;
+        struct mlx5_ifc_pmaos_reg_bits pmaos_reg;
+        struct mlx5_ifc_pmlp_reg_bits pmlp_reg;
+        struct mlx5_ifc_pmlpn_reg_bits pmlpn_reg;
+        struct mlx5_ifc_pmpc_reg_bits pmpc_reg;
+        struct mlx5_ifc_pmpe_reg_bits pmpe_reg;
+        struct mlx5_ifc_pmpr_reg_bits pmpr_reg;
+        struct mlx5_ifc_pmtu_reg_bits pmtu_reg;
+        struct mlx5_ifc_ppad_reg_bits ppad_reg;
+        struct mlx5_ifc_ppcnt_reg_bits ppcnt_reg;
+        struct mlx5_ifc_pplm_reg_bits pplm_reg;
+        struct mlx5_ifc_pplr_reg_bits pplr_reg;
+        struct mlx5_ifc_ppsc_reg_bits ppsc_reg;
+        struct mlx5_ifc_pqdr_reg_bits pqdr_reg;
+        struct mlx5_ifc_pspa_reg_bits pspa_reg;
+        struct mlx5_ifc_ptas_reg_bits ptas_reg;
+        struct mlx5_ifc_ptys_reg_bits ptys_reg;
+        struct mlx5_ifc_pude_reg_bits pude_reg;
+        struct mlx5_ifc_pvlc_reg_bits pvlc_reg;
+        struct mlx5_ifc_slrg_reg_bits slrg_reg;
+        struct mlx5_ifc_sltp_reg_bits sltp_reg;
+        u8         reserved_0[0x60e0];
+};
+
+union mlx5_ifc_debug_enhancements_document_bits {
+        struct mlx5_ifc_health_buffer_bits health_buffer;
+        u8         reserved_0[0x200];
+};
+
+union mlx5_ifc_uplink_pci_interface_document_bits {
+        struct mlx5_ifc_initial_seg_bits initial_seg;
+        u8         reserved_0[0x20060];
 };
 
 #endif /* MLX5_IFC_H */
diff --git a/include/linux/mlx5/qp.h b/include/linux/mlx5/qp.h
index 310b5f7fd6ae..f079fb1a31f7 100644
--- a/include/linux/mlx5/qp.h
+++ b/include/linux/mlx5/qp.h
@@ -134,13 +134,21 @@ enum {
 
 enum {
         MLX5_WQE_CTRL_CQ_UPDATE         = 2 << 2,
+        MLX5_WQE_CTRL_CQ_UPDATE_AND_EQE = 3 << 2,
         MLX5_WQE_CTRL_SOLICITED         = 1 << 1,
 };
 
 enum {
+        MLX5_SEND_WQE_DS        = 16,
         MLX5_SEND_WQE_BB        = 64,
 };
 
+#define MLX5_SEND_WQEBB_NUM_DS  (MLX5_SEND_WQE_BB / MLX5_SEND_WQE_DS)
+
+enum {
+        MLX5_SEND_WQE_MAX_WQEBBS        = 16,
+};
+
 enum {
         MLX5_WQE_FMR_PERM_LOCAL_READ    = 1 << 27,
         MLX5_WQE_FMR_PERM_LOCAL_WRITE   = 1 << 28,
@@ -200,6 +208,23 @@ struct mlx5_wqe_ctrl_seg {
 #define MLX5_WQE_CTRL_WQE_INDEX_MASK 0x00ffff00
 #define MLX5_WQE_CTRL_WQE_INDEX_SHIFT 8
 
+enum {
+        MLX5_ETH_WQE_L3_INNER_CSUM      = 1 << 4,
+        MLX5_ETH_WQE_L4_INNER_CSUM      = 1 << 5,
+        MLX5_ETH_WQE_L3_CSUM            = 1 << 6,
+        MLX5_ETH_WQE_L4_CSUM            = 1 << 7,
+};
+
+struct mlx5_wqe_eth_seg {
+        u8              rsvd0[4];
+        u8              cs_flags;
+        u8              rsvd1;
+        __be16          mss;
+        __be32          rsvd2;
+        __be16          inline_hdr_sz;
+        u8              inline_hdr_start[2];
+};
+
 struct mlx5_wqe_xrc_seg {
         __be32                  xrc_srqn;
         u8                      rsvd[12];
diff --git a/include/linux/mlx5/vport.h b/include/linux/mlx5/vport.h
new file mode 100644
index 000000000000..967e0fd06e89
--- /dev/null
+++ b/include/linux/mlx5/vport.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  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_VPORT_H__
+#define __MLX5_VPORT_H__
+
+#include <linux/mlx5/driver.h>
+
+u8 mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod);
+void mlx5_query_nic_vport_mac_address(struct mlx5_core_dev *mdev, u8 *addr);
+int mlx5_query_hca_vport_gid(struct mlx5_core_dev *dev, u8 other_vport,
+                             u8 port_num, u16  vf_num, u16 gid_index,
+                             union ib_gid *gid);
+int mlx5_query_hca_vport_pkey(struct mlx5_core_dev *dev, u8 other_vport,
+                              u8 port_num, u16 vf_num, u16 pkey_index,
+                              u16 *pkey);
+int mlx5_query_hca_vport_context(struct mlx5_core_dev *dev,
+                                 u8 other_vport, u8 port_num,
+                                 u16 vf_num,
+                                 struct mlx5_hca_vport_context *rep);
+int mlx5_query_hca_vport_system_image_guid(struct mlx5_core_dev *dev,
+                                           u64 *sys_image_guid);
+int mlx5_query_hca_vport_node_guid(struct mlx5_core_dev *dev,
+                                   u64 *node_guid);
+
+#endif /* __MLX5_VPORT_H__ */
diff --git a/include/linux/mm-arch-hooks.h b/include/linux/mm-arch-hooks.h
new file mode 100644
index 000000000000..4efc3f56e6df
--- /dev/null
+++ b/include/linux/mm-arch-hooks.h
@@ -0,0 +1,25 @@
+/*
+ * Generic mm no-op hooks.
+ *
+ * Copyright (C) 2015, IBM Corporation
+ * Author: Laurent Dufour <ldufour@linux.vnet.ibm.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_MM_ARCH_HOOKS_H
+#define _LINUX_MM_ARCH_HOOKS_H
+
+#include <asm/mm-arch-hooks.h>
+
+#ifndef arch_remap
+static inline void arch_remap(struct mm_struct *mm,
+                              unsigned long old_start, unsigned long old_end,
+                              unsigned long new_start, unsigned long new_end)
+{
+}
+#define arch_remap arch_remap
+#endif
+
+#endif /* _LINUX_MM_ARCH_HOOKS_H */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 0755b9fd03a7..2e872f92dbac 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -27,6 +27,7 @@ struct anon_vma_chain;
 struct file_ra_state;
 struct user_struct;
 struct writeback_control;
+struct bdi_writeback;
 
 #ifndef CONFIG_NEED_MULTIPLE_NODES      /* Don't use mapnrs, do it properly */
 extern unsigned long max_mapnr;
@@ -499,7 +500,7 @@ static inline int page_count(struct page *page)
 
 static inline bool __compound_tail_refcounted(struct page *page)
 {
-        return !PageSlab(page) && !PageHeadHuge(page);
+        return PageAnon(page) && !PageSlab(page) && !PageHeadHuge(page);
 }
 
 /*
@@ -1211,10 +1212,13 @@ int __set_page_dirty_nobuffers(struct page *page);
 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_cleaned(struct page *page, struct address_space *mapping);
+void account_page_dirtied(struct page *page, struct address_space *mapping,
+                          struct mem_cgroup *memcg);
+void account_page_cleaned(struct page *page, struct address_space *mapping,
+                          struct mem_cgroup *memcg, struct bdi_writeback *wb);
 int set_page_dirty(struct page *page);
 int set_page_dirty_lock(struct page *page);
+void cancel_dirty_page(struct page *page);
 int clear_page_dirty_for_io(struct page *page);
 
 int get_cmdline(struct task_struct *task, char *buffer, int buflen);
@@ -1631,6 +1635,8 @@ extern void free_highmem_page(struct page *page);
 extern void adjust_managed_page_count(struct page *page, long count);
 extern void mem_init_print_info(const char *str);
 
+extern void reserve_bootmem_region(unsigned long start, unsigned long end);
+
 /* Free the reserved page into the buddy system, so it gets managed. */
 static inline void __free_reserved_page(struct page *page)
 {
@@ -1720,7 +1726,8 @@ extern void sparse_memory_present_with_active_regions(int nid);
 
 #if !defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP) && \
     !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID)
-static inline int __early_pfn_to_nid(unsigned long pfn)
+static inline int __early_pfn_to_nid(unsigned long pfn,
+                                        struct mminit_pfnnid_cache *state)
 {
         return 0;
 }
@@ -1728,7 +1735,8 @@ static inline int __early_pfn_to_nid(unsigned long pfn)
 /* please see mm/page_alloc.c */
 extern int __meminit early_pfn_to_nid(unsigned long pfn);
 /* there is a per-arch backend function. */
-extern int __meminit __early_pfn_to_nid(unsigned long pfn);
+extern int __meminit __early_pfn_to_nid(unsigned long pfn,
+                                        struct mminit_pfnnid_cache *state);
 #endif
 
 extern void set_dma_reserve(unsigned long new_dma_reserve);
@@ -2146,12 +2154,47 @@ enum mf_flags {
 extern int memory_failure(unsigned long pfn, int trapno, int flags);
 extern void memory_failure_queue(unsigned long pfn, int trapno, int flags);
 extern int unpoison_memory(unsigned long pfn);
+extern int get_hwpoison_page(struct page *page);
 extern int sysctl_memory_failure_early_kill;
 extern int sysctl_memory_failure_recovery;
 extern void shake_page(struct page *p, int access);
 extern atomic_long_t num_poisoned_pages;
 extern int soft_offline_page(struct page *page, int flags);
 
+
+/*
+ * Error handlers for various types of pages.
+ */
+enum mf_result {
+        MF_IGNORED,     /* Error: cannot be handled */
+        MF_FAILED,      /* Error: handling failed */
+        MF_DELAYED,     /* Will be handled later */
+        MF_RECOVERED,   /* Successfully recovered */
+};
+
+enum mf_action_page_type {
+        MF_MSG_KERNEL,
+        MF_MSG_KERNEL_HIGH_ORDER,
+        MF_MSG_SLAB,
+        MF_MSG_DIFFERENT_COMPOUND,
+        MF_MSG_POISONED_HUGE,
+        MF_MSG_HUGE,
+        MF_MSG_FREE_HUGE,
+        MF_MSG_UNMAP_FAILED,
+        MF_MSG_DIRTY_SWAPCACHE,
+        MF_MSG_CLEAN_SWAPCACHE,
+        MF_MSG_DIRTY_MLOCKED_LRU,
+        MF_MSG_CLEAN_MLOCKED_LRU,
+        MF_MSG_DIRTY_UNEVICTABLE_LRU,
+        MF_MSG_CLEAN_UNEVICTABLE_LRU,
+        MF_MSG_DIRTY_LRU,
+        MF_MSG_CLEAN_LRU,
+        MF_MSG_TRUNCATED_LRU,
+        MF_MSG_BUDDY,
+        MF_MSG_BUDDY_2ND,
+        MF_MSG_UNKNOWN,
+};
+
 #if defined(CONFIG_TRANSPARENT_HUGEPAGE) || defined(CONFIG_HUGETLBFS)
 extern void clear_huge_page(struct page *page,
                             unsigned long addr,
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 8d37e26a1007..0038ac7466fd 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -226,6 +226,24 @@ struct page_frag {
 #endif
 };
 
+#define PAGE_FRAG_CACHE_MAX_SIZE        __ALIGN_MASK(32768, ~PAGE_MASK)
+#define PAGE_FRAG_CACHE_MAX_ORDER       get_order(PAGE_FRAG_CACHE_MAX_SIZE)
+
+struct page_frag_cache {
+        void * va;
+#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
+        __u16 offset;
+        __u16 size;
+#else
+        __u32 offset;
+#endif
+        /* we maintain a pagecount bias, so that we dont dirty cache line
+         * containing page->_count every time we allocate a fragment.
+         */
+        unsigned int            pagecnt_bias;
+        bool pfmemalloc;
+};
+
 typedef unsigned long __nocast vm_flags_t;
 
 /*
diff --git a/include/linux/mmiotrace.h b/include/linux/mmiotrace.h
index c5d52780d6a0..3ba327af055c 100644
--- a/include/linux/mmiotrace.h
+++ b/include/linux/mmiotrace.h
@@ -106,6 +106,6 @@ extern void enable_mmiotrace(void);
 extern void disable_mmiotrace(void);
 extern void mmio_trace_rw(struct mmiotrace_rw *rw);
 extern void mmio_trace_mapping(struct mmiotrace_map *map);
-extern int mmio_trace_printk(const char *fmt, va_list args);
+extern __printf(1, 0) int mmio_trace_printk(const char *fmt, va_list args);
 
 #endif /* _LINUX_MMIOTRACE_H */
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index 95243d28a0ee..61cd67f4d788 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -324,25 +324,25 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
         ___pte;                                                         \
 })
 
-#define pmdp_clear_flush_notify(__vma, __haddr, __pmd)                  \
+#define pmdp_huge_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);               \
+        ___pmd = pmdp_huge_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)                 \
+#define pmdp_huge_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);              \
+        ___pmd = pmdp_huge_get_and_clear(__mm, __haddr, __pmd);         \
         mmu_notifier_invalidate_range(__mm, ___haddr,                   \
                                       ___haddr + HPAGE_PMD_SIZE);       \
                                                                         \
@@ -428,8 +428,8 @@ 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 pmdp_huge_clear_flush_notify pmdp_huge_clear_flush
+#define pmdp_huge_get_and_clear_notify pmdp_huge_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 54d74f6eb233..754c25966a0a 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -762,6 +762,14 @@ typedef struct pglist_data {
         /* Number of pages migrated during the rate limiting time interval */
         unsigned long numabalancing_migrate_nr_pages;
 #endif
+
+#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
+        /*
+         * If memory initialisation on large machines is deferred then this
+         * is the first PFN that needs to be initialised.
+         */
+        unsigned long first_deferred_pfn;
+#endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
 } pg_data_t;
 
 #define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
@@ -1216,11 +1224,16 @@ void sparse_init(void);
 #define sparse_index_init(_sec, _nid)  do {} while (0)
 #endif /* CONFIG_SPARSEMEM */
 
-#ifdef CONFIG_NODES_SPAN_OTHER_NODES
-bool early_pfn_in_nid(unsigned long pfn, int nid);
-#else
-#define early_pfn_in_nid(pfn, nid)      (1)
-#endif
+/*
+ * During memory init memblocks map pfns to nids. The search is expensive and
+ * this caches recent lookups. The implementation of __early_pfn_to_nid
+ * may treat start/end as pfns or sections.
+ */
+struct mminit_pfnnid_cache {
+        unsigned long last_start;
+        unsigned long last_end;
+        int last_nid;
+};
 
 #ifndef early_pfn_valid
 #define early_pfn_valid(pfn)    (1)
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 3bfd56778c29..34f25b7bf642 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -189,6 +189,8 @@ struct css_device_id {
 struct acpi_device_id {
         __u8 id[ACPI_ID_LEN];
         kernel_ulong_t driver_data;
+        __u32 cls;
+        __u32 cls_msk;
 };
 
 #define PNP_ID_LEN      8
@@ -599,9 +601,22 @@ struct ipack_device_id {
 
 #define MEI_CL_MODULE_PREFIX "mei:"
 #define MEI_CL_NAME_SIZE 32
+#define MEI_CL_UUID_FMT "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
+#define MEI_CL_UUID_ARGS(_u) \
+        _u[0], _u[1], _u[2], _u[3], _u[4], _u[5], _u[6], _u[7], \
+        _u[8], _u[9], _u[10], _u[11], _u[12], _u[13], _u[14], _u[15]
 
+/**
+ * struct mei_cl_device_id - MEI client device identifier
+ * @name: helper name
+ * @uuid: client uuid
+ * @driver_info: information used by the driver.
+ *
+ * identifies mei client device by uuid and name
+ */
 struct mei_cl_device_id {
         char name[MEI_CL_NAME_SIZE];
+        uuid_le uuid;
         kernel_ulong_t driver_info;
 };
 
@@ -629,4 +644,10 @@ struct mcb_device_id {
         kernel_ulong_t driver_data;
 };
 
+struct ulpi_device_id {
+        __u16 vendor;
+        __u16 product;
+        kernel_ulong_t driver_data;
+};
+
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/module.h b/include/linux/module.h
index 1e5436042eb0..3a19c79918e0 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -11,12 +11,14 @@
 #include <linux/compiler.h>
 #include <linux/cache.h>
 #include <linux/kmod.h>
+#include <linux/init.h>
 #include <linux/elf.h>
 #include <linux/stringify.h>
 #include <linux/kobject.h>
 #include <linux/moduleparam.h>
 #include <linux/jump_label.h>
 #include <linux/export.h>
+#include <linux/rbtree_latch.h>
 
 #include <linux/percpu.h>
 #include <asm/module.h>
@@ -70,6 +72,89 @@ extern struct module_attribute module_uevent;
 extern int init_module(void);
 extern void cleanup_module(void);
 
+#ifndef MODULE
+/**
+ * module_init() - driver initialization entry point
+ * @x: function to be run at kernel boot time or module insertion
+ *
+ * module_init() will either be called during do_initcalls() (if
+ * builtin) or at module insertion time (if a module).  There can only
+ * be one per module.
+ */
+#define module_init(x)  __initcall(x);
+
+/**
+ * module_exit() - driver exit entry point
+ * @x: function to be run when driver is removed
+ *
+ * module_exit() will wrap the driver clean-up code
+ * with cleanup_module() when used with rmmod when
+ * the driver is a module.  If the driver is statically
+ * compiled into the kernel, module_exit() has no effect.
+ * There can only be one per module.
+ */
+#define module_exit(x)  __exitcall(x);
+
+#else /* MODULE */
+
+/*
+ * In most cases loadable modules do not need custom
+ * initcall levels. There are still some valid cases where
+ * a driver may be needed early if built in, and does not
+ * matter when built as a loadable module. Like bus
+ * snooping debug drivers.
+ */
+#define early_initcall(fn)              module_init(fn)
+#define core_initcall(fn)               module_init(fn)
+#define core_initcall_sync(fn)          module_init(fn)
+#define postcore_initcall(fn)           module_init(fn)
+#define postcore_initcall_sync(fn)      module_init(fn)
+#define arch_initcall(fn)               module_init(fn)
+#define subsys_initcall(fn)             module_init(fn)
+#define subsys_initcall_sync(fn)        module_init(fn)
+#define fs_initcall(fn)                 module_init(fn)
+#define fs_initcall_sync(fn)            module_init(fn)
+#define rootfs_initcall(fn)             module_init(fn)
+#define device_initcall(fn)             module_init(fn)
+#define device_initcall_sync(fn)        module_init(fn)
+#define late_initcall(fn)               module_init(fn)
+#define late_initcall_sync(fn)          module_init(fn)
+
+#define console_initcall(fn)            module_init(fn)
+#define security_initcall(fn)           module_init(fn)
+
+/* Each module must use one module_init(). */
+#define module_init(initfn)                                     \
+        static inline initcall_t __inittest(void)               \
+        { return initfn; }                                      \
+        int init_module(void) __attribute__((alias(#initfn)));
+
+/* This is only required if you want to be unloadable. */
+#define module_exit(exitfn)                                     \
+        static inline exitcall_t __exittest(void)               \
+        { return exitfn; }                                      \
+        void cleanup_module(void) __attribute__((alias(#exitfn)));
+
+#endif
+
+/* This means "can be init if no module support, otherwise module load
+   may call it." */
+#ifdef CONFIG_MODULES
+#define __init_or_module
+#define __initdata_or_module
+#define __initconst_or_module
+#define __INIT_OR_MODULE        .text
+#define __INITDATA_OR_MODULE    .data
+#define __INITRODATA_OR_MODULE  .section ".rodata","a",%progbits
+#else
+#define __init_or_module __init
+#define __initdata_or_module __initdata
+#define __initconst_or_module __initconst
+#define __INIT_OR_MODULE __INIT
+#define __INITDATA_OR_MODULE __INITDATA
+#define __INITRODATA_OR_MODULE __INITRODATA
+#endif /*CONFIG_MODULES*/
+
 /* Archs provide a method of finding the correct exception table. */
 struct exception_table_entry;
 
@@ -210,6 +295,13 @@ enum module_state {
         MODULE_STATE_UNFORMED,  /* Still setting it up. */
 };
 
+struct module;
+
+struct mod_tree_node {
+        struct module *mod;
+        struct latch_tree_node node;
+};
+
 struct module {
         enum module_state state;
 
@@ -232,6 +324,9 @@ struct module {
         unsigned int num_syms;
 
         /* Kernel parameters. */
+#ifdef CONFIG_SYSFS
+        struct mutex param_lock;
+#endif
         struct kernel_param *kp;
         unsigned int num_kp;
 
@@ -257,6 +352,8 @@ struct module {
         bool sig_ok;
 #endif
 
+        bool async_probe_requested;
+
         /* symbols that will be GPL-only in the near future. */
         const struct kernel_symbol *gpl_future_syms;
         const unsigned long *gpl_future_crcs;
@@ -269,8 +366,15 @@ struct module {
         /* Startup function. */
         int (*init)(void);
 
-        /* If this is non-NULL, vfree after init() returns */
-        void *module_init;
+        /*
+         * If this is non-NULL, vfree() after init() returns.
+         *
+         * Cacheline align here, such that:
+         *   module_init, module_core, init_size, core_size,
+         *   init_text_size, core_text_size and mtn_core::{mod,node[0]}
+         * are on the same cacheline.
+         */
+        void *module_init       ____cacheline_aligned;
 
         /* Here is the actual code + data, vfree'd on unload. */
         void *module_core;
@@ -281,6 +385,16 @@ struct module {
         /* The size of the executable code in each section.  */
         unsigned int init_text_size, core_text_size;
 
+#ifdef CONFIG_MODULES_TREE_LOOKUP
+        /*
+         * We want mtn_core::{mod,node[0]} to be in the same cacheline as the
+         * above entries such that a regular lookup will only touch one
+         * cacheline.
+         */
+        struct mod_tree_node    mtn_core;
+        struct mod_tree_node    mtn_init;
+#endif
+
         /* Size of RO sections of the module (text+rodata) */
         unsigned int init_ro_size, core_ro_size;
 
@@ -336,7 +450,7 @@ struct module {
         const char **trace_bprintk_fmt_start;
 #endif
 #ifdef CONFIG_EVENT_TRACING
-        struct ftrace_event_call **trace_events;
+        struct trace_event_call **trace_events;
         unsigned int num_trace_events;
         struct trace_enum_map **trace_enums;
         unsigned int num_trace_enums;
@@ -367,7 +481,7 @@ struct module {
         ctor_fn_t *ctors;
         unsigned int num_ctors;
 #endif
-};
+} ____cacheline_aligned;
 #ifndef MODULE_ARCH_INIT
 #define MODULE_ARCH_INIT {}
 #endif
@@ -421,14 +535,22 @@ struct symsearch {
         bool unused;
 };
 
-/* Search for an exported symbol by name. */
+/*
+ * Search for an exported symbol by name.
+ *
+ * Must be called with module_mutex held or preemption disabled.
+ */
 const struct kernel_symbol *find_symbol(const char *name,
                                         struct module **owner,
                                         const unsigned long **crc,
                                         bool gplok,
                                         bool warn);
 
-/* Walk the exported symbol table */
+/*
+ * Walk the exported symbol table
+ *
+ * Must be called with module_mutex held or preemption disabled.
+ */
 bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
                                     struct module *owner,
                                     void *data), void *data);
@@ -508,6 +630,11 @@ int unregister_module_notifier(struct notifier_block *nb);
 
 extern void print_modules(void);
 
+static inline bool module_requested_async_probing(struct module *module)
+{
+        return module && module->async_probe_requested;
+}
+
 #else /* !CONFIG_MODULES... */
 
 /* Given an address, look for it in the exception tables. */
@@ -618,6 +745,12 @@ static inline int unregister_module_notifier(struct notifier_block *nb)
 static inline void print_modules(void)
 {
 }
+
+static inline bool module_requested_async_probing(struct module *module)
+{
+        return false;
+}
+
 #endif /* CONFIG_MODULES */
 
 #ifdef CONFIG_SYSFS
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index 1c9effa25e26..c12f2147c350 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -67,8 +67,9 @@ enum {
 
 struct kernel_param {
         const char *name;
+        struct module *mod;
         const struct kernel_param_ops *ops;
-        u16 perm;
+        const u16 perm;
         s8 level;
         u8 flags;
         union {
@@ -108,7 +109,7 @@ struct kparam_array
  *
  * @perm is 0 if the the variable is not to appear in sysfs, or 0444
  * for world-readable, 0644 for root-writable, etc.  Note that if it
- * is writable, you may need to use kparam_block_sysfs_write() around
+ * is writable, you may need to use kernel_param_lock() around
  * accesses (esp. charp, which can be kfreed when it changes).
  *
  * The @type is simply pasted to refer to a param_ops_##type and a
@@ -216,16 +217,16 @@ struct kparam_array
    parameters. */
 #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 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, flags, { arg } }
+        = { __param_str_##name, THIS_MODULE, ops,                       \
+            VERIFY_OCTAL_PERMISSIONS(perm), 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 =             \
+        static const struct kernel_param_ops __param_ops_##name =               \
                 { .flags = 0, (void *)set, (void *)get };               \
         __module_param_call(MODULE_PARAM_PREFIX,                        \
                             name, &__param_ops_##name, arg,             \
@@ -238,58 +239,14 @@ __check_old_set_param(int (*oldset)(const char *, struct kernel_param *))
         return 0;
 }
 
-/**
- * kparam_block_sysfs_write - make sure a parameter isn't written via sysfs.
- * @name: the name of the parameter
- *
- * There's no point blocking write on a paramter that isn't writable via sysfs!
- */
-#define kparam_block_sysfs_write(name)                  \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0222));  \
-                __kernel_param_lock();                  \
-        } while (0)
-
-/**
- * kparam_unblock_sysfs_write - allows sysfs to write to a parameter again.
- * @name: the name of the parameter
- */
-#define kparam_unblock_sysfs_write(name)                \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0222));  \
-                __kernel_param_unlock();                \
-        } while (0)
-
-/**
- * kparam_block_sysfs_read - make sure a parameter isn't read via sysfs.
- * @name: the name of the parameter
- *
- * This also blocks sysfs writes.
- */
-#define kparam_block_sysfs_read(name)                   \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0444));  \
-                __kernel_param_lock();                  \
-        } while (0)
-
-/**
- * kparam_unblock_sysfs_read - allows sysfs to read a parameter again.
- * @name: the name of the parameter
- */
-#define kparam_unblock_sysfs_read(name)                 \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0444));  \
-                __kernel_param_unlock();                \
-        } while (0)
-
 #ifdef CONFIG_SYSFS
-extern void __kernel_param_lock(void);
-extern void __kernel_param_unlock(void);
+extern void kernel_param_lock(struct module *mod);
+extern void kernel_param_unlock(struct module *mod);
 #else
-static inline void __kernel_param_lock(void)
+static inline void kernel_param_lock(struct module *mod)
 {
 }
-static inline void __kernel_param_unlock(void)
+static inline void kernel_param_unlock(struct module *mod)
 {
 }
 #endif
@@ -310,6 +267,15 @@ 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, 0)
+
+/**
+ * core_param_unsafe - same as core_param but taints kernel
+ */
+#define core_param_unsafe(name, var, type, perm)                \
+        param_check_##type(name, &(var));                               \
+        __module_param_call("", name, &param_ops_##type, &var, perm,    \
+                            -1, KERNEL_PARAM_FL_UNSAFE)
+
 #endif /* !MODULE */
 
 /**
@@ -357,8 +323,9 @@ extern char *parse_args(const char *name,
                       unsigned num,
                       s16 level_min,
                       s16 level_max,
+                      void *arg,
                       int (*unknown)(char *param, char *val,
-                              const char *doing));
+                                     const char *doing, void *arg));
 
 /* Called by module remove. */
 #ifdef CONFIG_SYSFS
@@ -376,64 +343,70 @@ static inline void destroy_params(const struct kernel_param *params,
 #define __param_check(name, p, type) \
         static inline type __always_unused *__check_##name(void) { return(p); }
 
-extern struct kernel_param_ops param_ops_byte;
+extern const struct kernel_param_ops param_ops_byte;
 extern int param_set_byte(const char *val, const struct kernel_param *kp);
 extern int param_get_byte(char *buffer, const struct kernel_param *kp);
 #define param_check_byte(name, p) __param_check(name, p, unsigned char)
 
-extern struct kernel_param_ops param_ops_short;
+extern const struct kernel_param_ops param_ops_short;
 extern int param_set_short(const char *val, const struct kernel_param *kp);
 extern int param_get_short(char *buffer, const struct kernel_param *kp);
 #define param_check_short(name, p) __param_check(name, p, short)
 
-extern struct kernel_param_ops param_ops_ushort;
+extern const struct kernel_param_ops param_ops_ushort;
 extern int param_set_ushort(const char *val, const struct kernel_param *kp);
 extern int param_get_ushort(char *buffer, const struct kernel_param *kp);
 #define param_check_ushort(name, p) __param_check(name, p, unsigned short)
 
-extern struct kernel_param_ops param_ops_int;
+extern const struct kernel_param_ops param_ops_int;
 extern int param_set_int(const char *val, const struct kernel_param *kp);
 extern int param_get_int(char *buffer, const struct kernel_param *kp);
 #define param_check_int(name, p) __param_check(name, p, int)
 
-extern struct kernel_param_ops param_ops_uint;
+extern const struct kernel_param_ops param_ops_uint;
 extern int param_set_uint(const char *val, const struct kernel_param *kp);
 extern int param_get_uint(char *buffer, const struct kernel_param *kp);
 #define param_check_uint(name, p) __param_check(name, p, unsigned int)
 
-extern struct kernel_param_ops param_ops_long;
+extern const struct kernel_param_ops param_ops_long;
 extern int param_set_long(const char *val, const struct kernel_param *kp);
 extern int param_get_long(char *buffer, const struct kernel_param *kp);
 #define param_check_long(name, p) __param_check(name, p, long)
 
-extern struct kernel_param_ops param_ops_ulong;
+extern const struct kernel_param_ops param_ops_ulong;
 extern int param_set_ulong(const char *val, const struct kernel_param *kp);
 extern int param_get_ulong(char *buffer, const struct kernel_param *kp);
 #define param_check_ulong(name, p) __param_check(name, p, unsigned long)
 
-extern struct kernel_param_ops param_ops_ullong;
+extern const struct kernel_param_ops param_ops_ullong;
 extern int param_set_ullong(const char *val, const struct kernel_param *kp);
 extern int param_get_ullong(char *buffer, const struct kernel_param *kp);
 #define param_check_ullong(name, p) __param_check(name, p, unsigned long long)
 
-extern struct kernel_param_ops param_ops_charp;
+extern const struct kernel_param_ops param_ops_charp;
 extern int param_set_charp(const char *val, const struct kernel_param *kp);
 extern int param_get_charp(char *buffer, const struct kernel_param *kp);
 #define param_check_charp(name, p) __param_check(name, p, char *)
 
 /* We used to allow int as well as bool.  We're taking that away! */
-extern struct kernel_param_ops param_ops_bool;
+extern const struct kernel_param_ops param_ops_bool;
 extern int param_set_bool(const char *val, const struct kernel_param *kp);
 extern int param_get_bool(char *buffer, const struct kernel_param *kp);
 #define param_check_bool(name, p) __param_check(name, p, bool)
 
-extern struct kernel_param_ops param_ops_invbool;
+extern const struct kernel_param_ops param_ops_bool_enable_only;
+extern int param_set_bool_enable_only(const char *val,
+                                      const struct kernel_param *kp);
+/* getter is the same as for the regular bool */
+#define param_check_bool_enable_only param_check_bool
+
+extern const struct kernel_param_ops param_ops_invbool;
 extern int param_set_invbool(const char *val, const struct kernel_param *kp);
 extern int param_get_invbool(char *buffer, const struct kernel_param *kp);
 #define param_check_invbool(name, p) __param_check(name, p, bool)
 
 /* An int, which can only be set like a bool (though it shows as an int). */
-extern struct kernel_param_ops param_ops_bint;
+extern const struct kernel_param_ops param_ops_bint;
 extern int param_set_bint(const char *val, const struct kernel_param *kp);
 #define param_get_bint param_get_int
 #define param_check_bint param_check_int
@@ -477,9 +450,9 @@ extern int param_set_bint(const char *val, const struct kernel_param *kp);
                             perm, -1, 0);                               \
         __MODULE_PARM_TYPE(name, "array of " #type)
 
-extern struct kernel_param_ops param_array_ops;
+extern const struct kernel_param_ops param_array_ops;
 
-extern struct kernel_param_ops param_ops_string;
+extern const struct kernel_param_ops param_ops_string;
 extern int param_set_copystring(const char *val, const struct kernel_param *);
 extern int param_get_string(char *buffer, const struct kernel_param *kp);
 
diff --git a/include/linux/mtd/cfi.h b/include/linux/mtd/cfi.h
index 299d7d31fe53..9b57a9b1b081 100644
--- a/include/linux/mtd/cfi.h
+++ b/include/linux/mtd/cfi.h
@@ -296,183 +296,19 @@ struct cfi_private {
         struct flchip chips[0];  /* per-chip data structure for each chip */
 };
 
-/*
- * Returns the command address according to the given geometry.
- */
-static inline uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs,
-                                struct map_info *map, struct cfi_private *cfi)
-{
-        unsigned bankwidth = map_bankwidth(map);
-        unsigned interleave = cfi_interleave(cfi);
-        unsigned type = cfi->device_type;
-        uint32_t addr;
-        
-        addr = (cmd_ofs * type) * interleave;
-
-        /* Modify the unlock address if we are in compatibility mode.
-         * For 16bit devices on 8 bit busses
-         * and 32bit devices on 16 bit busses
-         * set the low bit of the alternating bit sequence of the address.
-         */
-        if (((type * interleave) > bankwidth) && ((cmd_ofs & 0xff) == 0xaa))
-                addr |= (type >> 1)*interleave;
-
-        return  addr;
-}
-
-/*
- * Transforms the CFI command for the given geometry (bus width & interleave).
- * It looks too long to be inline, but in the common case it should almost all
- * get optimised away.
- */
-static inline map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cfi_private *cfi)
-{
-        map_word val = { {0} };
-        int wordwidth, words_per_bus, chip_mode, chips_per_word;
-        unsigned long onecmd;
-        int i;
-
-        /* We do it this way to give the compiler a fighting chance
-           of optimising away all the crap for 'bankwidth' larger than
-           an unsigned long, in the common case where that support is
-           disabled */
-        if (map_bankwidth_is_large(map)) {
-                wordwidth = sizeof(unsigned long);
-                words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
-        } else {
-                wordwidth = map_bankwidth(map);
-                words_per_bus = 1;
-        }
-
-        chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
-        chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
-
-        /* First, determine what the bit-pattern should be for a single
-           device, according to chip mode and endianness... */
-        switch (chip_mode) {
-        default: BUG();
-        case 1:
-                onecmd = cmd;
-                break;
-        case 2:
-                onecmd = cpu_to_cfi16(map, cmd);
-                break;
-        case 4:
-                onecmd = cpu_to_cfi32(map, cmd);
-                break;
-        }
-
-        /* Now replicate it across the size of an unsigned long, or
-           just to the bus width as appropriate */
-        switch (chips_per_word) {
-        default: BUG();
-#if BITS_PER_LONG >= 64
-        case 8:
-                onecmd |= (onecmd << (chip_mode * 32));
-#endif
-        case 4:
-                onecmd |= (onecmd << (chip_mode * 16));
-        case 2:
-                onecmd |= (onecmd << (chip_mode * 8));
-        case 1:
-                ;
-        }
+uint32_t cfi_build_cmd_addr(uint32_t cmd_ofs,
+                                struct map_info *map, struct cfi_private *cfi);
 
-        /* And finally, for the multi-word case, replicate it
-           in all words in the structure */
-        for (i=0; i < words_per_bus; i++) {
-                val.x[i] = onecmd;
-        }
-
-        return val;
-}
+map_word cfi_build_cmd(u_long cmd, struct map_info *map, struct cfi_private *cfi);
 #define CMD(x)  cfi_build_cmd((x), map, cfi)
 
-
-static inline unsigned long cfi_merge_status(map_word val, struct map_info *map,
-                                           struct cfi_private *cfi)
-{
-        int wordwidth, words_per_bus, chip_mode, chips_per_word;
-        unsigned long onestat, res = 0;
-        int i;
-
-        /* We do it this way to give the compiler a fighting chance
-           of optimising away all the crap for 'bankwidth' larger than
-           an unsigned long, in the common case where that support is
-           disabled */
-        if (map_bankwidth_is_large(map)) {
-                wordwidth = sizeof(unsigned long);
-                words_per_bus = (map_bankwidth(map)) / wordwidth; // i.e. normally 1
-        } else {
-                wordwidth = map_bankwidth(map);
-                words_per_bus = 1;
-        }
-
-        chip_mode = map_bankwidth(map) / cfi_interleave(cfi);
-        chips_per_word = wordwidth * cfi_interleave(cfi) / map_bankwidth(map);
-
-        onestat = val.x[0];
-        /* Or all status words together */
-        for (i=1; i < words_per_bus; i++) {
-                onestat |= val.x[i];
-        }
-
-        res = onestat;
-        switch(chips_per_word) {
-        default: BUG();
-#if BITS_PER_LONG >= 64
-        case 8:
-                res |= (onestat >> (chip_mode * 32));
-#endif
-        case 4:
-                res |= (onestat >> (chip_mode * 16));
-        case 2:
-                res |= (onestat >> (chip_mode * 8));
-        case 1:
-                ;
-        }
-
-        /* Last, determine what the bit-pattern should be for a single
-           device, according to chip mode and endianness... */
-        switch (chip_mode) {
-        case 1:
-                break;
-        case 2:
-                res = cfi16_to_cpu(map, res);
-                break;
-        case 4:
-                res = cfi32_to_cpu(map, res);
-                break;
-        default: BUG();
-        }
-        return res;
-}
-
+unsigned long cfi_merge_status(map_word val, struct map_info *map,
+                                           struct cfi_private *cfi);
 #define MERGESTATUS(x) cfi_merge_status((x), map, cfi)
 
-
-/*
- * Sends a CFI command to a bank of flash for the given geometry.
- *
- * Returns the offset in flash where the command was written.
- * If prev_val is non-null, it will be set to the value at the command address,
- * before the command was written.
- */
-static inline uint32_t cfi_send_gen_cmd(u_char cmd, uint32_t cmd_addr, uint32_t base,
+uint32_t cfi_send_gen_cmd(u_char cmd, uint32_t cmd_addr, uint32_t base,
                                 struct map_info *map, struct cfi_private *cfi,
-                                int type, map_word *prev_val)
-{
-        map_word val;
-        uint32_t addr = base + cfi_build_cmd_addr(cmd_addr, map, cfi);
-        val = cfi_build_cmd(cmd, map, cfi);
-
-        if (prev_val)
-                *prev_val = map_read(map, addr);
-
-        map_write(map, val, addr);
-
-        return addr - base;
-}
+                                int type, map_word *prev_val);
 
 static inline uint8_t cfi_read_query(struct map_info *map, uint32_t addr)
 {
@@ -506,15 +342,7 @@ static inline uint16_t cfi_read_query16(struct map_info *map, uint32_t addr)
         }
 }
 
-static inline void cfi_udelay(int us)
-{
-        if (us >= 1000) {
-                msleep((us+999)/1000);
-        } else {
-                udelay(us);
-                cond_resched();
-        }
-}
+void cfi_udelay(int us);
 
 int __xipram cfi_qry_present(struct map_info *map, __u32 base,
                              struct cfi_private *cfi);
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 3d4ea7eb2b68..272f42952f34 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -26,6 +26,8 @@
 
 struct mtd_info;
 struct nand_flash_dev;
+struct device_node;
+
 /* Scan and identify a NAND device */
 extern int nand_scan(struct mtd_info *mtd, int max_chips);
 /*
@@ -176,17 +178,17 @@ typedef enum {
 /* Chip may not exist, so silence any errors in scan */
 #define NAND_SCAN_SILENT_NODEV  0x00040000
 /*
- * This option could be defined by controller drivers to protect against
- * kmap'ed, vmalloc'ed highmem buffers being passed from upper layers
- */
-#define NAND_USE_BOUNCE_BUFFER  0x00080000
-/*
  * Autodetect nand buswidth with readid/onfi.
  * This suppose the driver will configure the hardware in 8 bits mode
  * when calling nand_scan_ident, and update its configuration
  * before calling nand_scan_tail.
  */
 #define NAND_BUSWIDTH_AUTO      0x00080000
+/*
+ * This option could be defined by controller drivers to protect against
+ * kmap'ed, vmalloc'ed highmem buffers being passed from upper layers
+ */
+#define NAND_USE_BOUNCE_BUFFER  0x00100000
 
 /* Options set by nand scan */
 /* Nand scan has allocated controller struct */
@@ -542,6 +544,7 @@ struct nand_buffers {
  *                      flash device
  * @IO_ADDR_W:          [BOARDSPECIFIC] address to write the 8 I/O lines of the
  *                      flash device.
+ * @dn:                 [BOARDSPECIFIC] device node describing this instance
  * @read_byte:          [REPLACEABLE] read one byte from the chip
  * @read_word:          [REPLACEABLE] read one word from the chip
  * @write_byte:         [REPLACEABLE] write a single byte to the chip on the
@@ -644,6 +647,8 @@ struct nand_chip {
         void __iomem *IO_ADDR_R;
         void __iomem *IO_ADDR_W;
 
+        struct device_node *dn;
+
         uint8_t (*read_byte)(struct mtd_info *mtd);
         u16 (*read_word)(struct mtd_info *mtd);
         void (*write_byte)(struct mtd_info *mtd, uint8_t byte);
@@ -833,7 +838,6 @@ struct nand_manufacturers {
 extern struct nand_flash_dev nand_flash_ids[];
 extern struct nand_manufacturers nand_manuf_ids[];
 
-extern int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd);
 extern int nand_default_bbt(struct mtd_info *mtd);
 extern int nand_markbad_bbt(struct mtd_info *mtd, loff_t offs);
 extern int nand_isreserved_bbt(struct mtd_info *mtd, loff_t offs);
diff --git a/include/linux/nd.h b/include/linux/nd.h
new file mode 100644
index 000000000000..507e47c86737
--- /dev/null
+++ b/include/linux/nd.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * 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_ND_H__
+#define __LINUX_ND_H__
+#include <linux/fs.h>
+#include <linux/ndctl.h>
+#include <linux/device.h>
+
+struct nd_device_driver {
+        struct device_driver drv;
+        unsigned long type;
+        int (*probe)(struct device *dev);
+        int (*remove)(struct device *dev);
+};
+
+static inline struct nd_device_driver *to_nd_device_driver(
+                struct device_driver *drv)
+{
+        return container_of(drv, struct nd_device_driver, drv);
+};
+
+/**
+ * struct nd_namespace_common - core infrastructure of a namespace
+ * @force_raw: ignore other personalities for the namespace (e.g. btt)
+ * @dev: device model node
+ * @claim: when set a another personality has taken ownership of the namespace
+ * @rw_bytes: access the raw namespace capacity with byte-aligned transfers
+ */
+struct nd_namespace_common {
+        int force_raw;
+        struct device dev;
+        struct device *claim;
+        int (*rw_bytes)(struct nd_namespace_common *, resource_size_t offset,
+                        void *buf, size_t size, int rw);
+};
+
+static inline struct nd_namespace_common *to_ndns(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_common, dev);
+}
+
+/**
+ * struct nd_namespace_io - infrastructure for loading an nd_pmem instance
+ * @dev: namespace device created by the nd region driver
+ * @res: struct resource conversion of a NFIT SPA table
+ */
+struct nd_namespace_io {
+        struct nd_namespace_common common;
+        struct resource res;
+};
+
+/**
+ * struct nd_namespace_pmem - namespace device for dimm-backed interleaved memory
+ * @nsio: device and system physical address range to drive
+ * @alt_name: namespace name supplied in the dimm label
+ * @uuid: namespace name supplied in the dimm label
+ */
+struct nd_namespace_pmem {
+        struct nd_namespace_io nsio;
+        char *alt_name;
+        u8 *uuid;
+};
+
+/**
+ * struct nd_namespace_blk - namespace for dimm-bounded persistent memory
+ * @alt_name: namespace name supplied in the dimm label
+ * @uuid: namespace name supplied in the dimm label
+ * @id: ida allocated id
+ * @lbasize: blk namespaces have a native sector size when btt not present
+ * @num_resources: number of dpa extents to claim
+ * @res: discontiguous dpa extents for given dimm
+ */
+struct nd_namespace_blk {
+        struct nd_namespace_common common;
+        char *alt_name;
+        u8 *uuid;
+        int id;
+        unsigned long lbasize;
+        int num_resources;
+        struct resource **res;
+};
+
+static inline struct nd_namespace_io *to_nd_namespace_io(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_io, common.dev);
+}
+
+static inline struct nd_namespace_pmem *to_nd_namespace_pmem(struct device *dev)
+{
+        struct nd_namespace_io *nsio = to_nd_namespace_io(dev);
+
+        return container_of(nsio, struct nd_namespace_pmem, nsio);
+}
+
+static inline struct nd_namespace_blk *to_nd_namespace_blk(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_blk, common.dev);
+}
+
+/**
+ * nvdimm_read_bytes() - synchronously read bytes from an nvdimm namespace
+ * @ndns: device to read
+ * @offset: namespace-relative starting offset
+ * @buf: buffer to fill
+ * @size: transfer length
+ *
+ * @buf is up-to-date upon return from this routine.
+ */
+static inline int nvdimm_read_bytes(struct nd_namespace_common *ndns,
+                resource_size_t offset, void *buf, size_t size)
+{
+        return ndns->rw_bytes(ndns, offset, buf, size, READ);
+}
+
+/**
+ * nvdimm_write_bytes() - synchronously write bytes to an nvdimm namespace
+ * @ndns: device to read
+ * @offset: namespace-relative starting offset
+ * @buf: buffer to drain
+ * @size: transfer length
+ *
+ * NVDIMM Namepaces disks do not implement sectors internally.  Depending on
+ * the @ndns, the contents of @buf may be in cpu cache, platform buffers,
+ * or on backing memory media upon return from this routine.  Flushing
+ * to media is handled internal to the @ndns driver, if at all.
+ */
+static inline int nvdimm_write_bytes(struct nd_namespace_common *ndns,
+                resource_size_t offset, void *buf, size_t size)
+{
+        return ndns->rw_bytes(ndns, offset, buf, size, WRITE);
+}
+
+#define MODULE_ALIAS_ND_DEVICE(type) \
+        MODULE_ALIAS("nd:t" __stringify(type) "*")
+#define ND_DEVICE_MODALIAS_FMT "nd:t%d"
+
+int __must_check __nd_driver_register(struct nd_device_driver *nd_drv,
+                struct module *module, const char *mod_name);
+#define nd_driver_register(driver) \
+        __nd_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
+#endif /* __LINUX_ND_H__ */
diff --git a/include/linux/net.h b/include/linux/net.h
index 738ea48be889..04aa06852771 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -38,7 +38,6 @@ struct net;
 #define SOCK_NOSPACE            2
 #define SOCK_PASSCRED           3
 #define SOCK_PASSSEC            4
-#define SOCK_EXTERNALLY_ALLOCATED 5
 
 #ifndef ARCH_HAS_SOCKET_TYPES
 /**
@@ -208,7 +207,7 @@ void sock_unregister(int family);
 int __sock_create(struct net *net, int family, int type, int proto,
                   struct socket **res, int kern);
 int sock_create(int family, int type, int proto, struct socket **res);
-int sock_create_kern(int family, int type, int proto, struct socket **res);
+int sock_create_kern(struct net *net, int family, int type, int proto, struct socket **res);
 int sock_create_lite(int family, int type, int proto, struct socket **res);
 void sock_release(struct socket *sock);
 int sock_sendmsg(struct socket *sock, struct msghdr *msg);
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index 7d59dc6ab789..9672781c593d 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -66,7 +66,6 @@ enum {
         NETIF_F_HW_VLAN_STAG_FILTER_BIT,/* Receive filtering on VLAN STAGs */
         NETIF_F_HW_L2FW_DOFFLOAD_BIT,   /* Allow L2 Forwarding in Hardware */
         NETIF_F_BUSY_POLL_BIT,          /* Busy poll */
-        NETIF_F_HW_SWITCH_OFFLOAD_BIT,  /* HW switch offload */
 
         /*
          * Add your fresh new feature above and remember to update
@@ -125,7 +124,6 @@ enum {
 #define NETIF_F_HW_VLAN_STAG_TX __NETIF_F(HW_VLAN_STAG_TX)
 #define NETIF_F_HW_L2FW_DOFFLOAD        __NETIF_F(HW_L2FW_DOFFLOAD)
 #define NETIF_F_BUSY_POLL       __NETIF_F(BUSY_POLL)
-#define NETIF_F_HW_SWITCH_OFFLOAD       __NETIF_F(HW_SWITCH_OFFLOAD)
 
 /* Features valid for ethtool to change */
 /* = all defined minus driver/device-class-related */
@@ -161,8 +159,7 @@ enum {
  */
 #define NETIF_F_ONE_FOR_ALL     (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
                                  NETIF_F_SG | NETIF_F_HIGHDMA |         \
-                                 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED | \
-                                 NETIF_F_HW_SWITCH_OFFLOAD)
+                                 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
 
 /*
  * If one device doesn't support one of these features, then disable it
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 05b9a694e213..e20979dfd6a9 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1100,6 +1100,10 @@ struct net_device_ops {
                                                      struct ifla_vf_info *ivf);
         int                     (*ndo_set_vf_link_state)(struct net_device *dev,
                                                          int vf, int link_state);
+        int                     (*ndo_get_vf_stats)(struct net_device *dev,
+                                                    int vf,
+                                                    struct ifla_vf_stats
+                                                    *vf_stats);
         int                     (*ndo_set_vf_port)(struct net_device *dev,
                                                    int vf,
                                                    struct nlattr *port[]);
@@ -1564,7 +1568,7 @@ struct net_device {
         const struct net_device_ops *netdev_ops;
         const struct ethtool_ops *ethtool_ops;
 #ifdef CONFIG_NET_SWITCHDEV
-        const struct swdev_ops *swdev_ops;
+        const struct switchdev_ops *switchdev_ops;
 #endif
 
         const struct header_ops *header_ops;
@@ -1652,7 +1656,14 @@ struct net_device {
         rx_handler_func_t __rcu *rx_handler;
         void __rcu              *rx_handler_data;
 
+#ifdef CONFIG_NET_CLS_ACT
+        struct tcf_proto __rcu  *ingress_cl_list;
+#endif
         struct netdev_queue __rcu *ingress_queue;
+#ifdef CONFIG_NETFILTER_INGRESS
+        struct list_head        nf_hooks_ingress;
+#endif
+
         unsigned char           broadcast[MAX_ADDR_LEN];
 #ifdef CONFIG_RFS_ACCEL
         struct cpu_rmap         *rx_cpu_rmap;
@@ -1990,6 +2001,7 @@ struct offload_callbacks {
 
 struct packet_offload {
         __be16                   type;  /* This is really htons(ether_type). */
+        u16                      priority;
         struct offload_callbacks callbacks;
         struct list_head         list;
 };
@@ -2552,10 +2564,6 @@ static inline void netif_tx_wake_all_queues(struct net_device *dev)
 
 static inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
 {
-        if (WARN_ON(!dev_queue)) {
-                pr_info("netif_stop_queue() cannot be called before register_netdev()\n");
-                return;
-        }
         set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
 }
 
@@ -2571,15 +2579,7 @@ static inline void netif_stop_queue(struct net_device *dev)
         netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
 }
 
-static inline void netif_tx_stop_all_queues(struct net_device *dev)
-{
-        unsigned int i;
-
-        for (i = 0; i < dev->num_tx_queues; i++) {
-                struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
-                netif_tx_stop_queue(txq);
-        }
-}
+void netif_tx_stop_all_queues(struct net_device *dev);
 
 static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
 {
@@ -2840,6 +2840,9 @@ static inline int netif_set_xps_queue(struct net_device *dev,
 }
 #endif
 
+u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
+                  unsigned int num_tx_queues);
+
 /*
  * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
  * as a distribution range limit for the returned value.
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 63560d0a8dfe..00050dfd9f23 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -10,7 +10,8 @@
 #include <linux/wait.h>
 #include <linux/list.h>
 #include <linux/static_key.h>
-#include <uapi/linux/netfilter.h>
+#include <linux/netfilter_defs.h>
+
 #ifdef CONFIG_NETFILTER
 static inline int NF_DROP_GETERR(int verdict)
 {
@@ -38,9 +39,6 @@ static inline void nf_inet_addr_mask(const union nf_inet_addr *a1,
 
 int netfilter_init(void);
 
-/* Largest hook number + 1 */
-#define NF_MAX_HOOKS 8
-
 struct sk_buff;
 
 struct nf_hook_ops;
@@ -54,10 +52,12 @@ struct nf_hook_state {
         struct net_device *in;
         struct net_device *out;
         struct sock *sk;
+        struct list_head *hook_list;
         int (*okfn)(struct sock *, struct sk_buff *);
 };
 
 static inline void nf_hook_state_init(struct nf_hook_state *p,
+                                      struct list_head *hook_list,
                                       unsigned int hook,
                                       int thresh, u_int8_t pf,
                                       struct net_device *indev,
@@ -71,6 +71,7 @@ static inline void nf_hook_state_init(struct nf_hook_state *p,
         p->in = indev;
         p->out = outdev;
         p->sk = sk;
+        p->hook_list = hook_list;
         p->okfn = okfn;
 }
 
@@ -79,16 +80,17 @@ typedef unsigned int nf_hookfn(const struct nf_hook_ops *ops,
                                const struct nf_hook_state *state);
 
 struct nf_hook_ops {
-        struct list_head list;
+        struct list_head        list;
 
         /* User fills in from here down. */
-        nf_hookfn       *hook;
-        struct module   *owner;
-        void            *priv;
-        u_int8_t        pf;
-        unsigned int    hooknum;
+        nf_hookfn               *hook;
+        struct net_device       *dev;
+        struct module           *owner;
+        void                    *priv;
+        u_int8_t                pf;
+        unsigned int            hooknum;
         /* Hooks are ordered in ascending priority. */
-        int             priority;
+        int                     priority;
 };
 
 struct nf_sockopt_ops {
@@ -131,26 +133,33 @@ extern struct list_head nf_hooks[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
 #ifdef HAVE_JUMP_LABEL
 extern struct static_key nf_hooks_needed[NFPROTO_NUMPROTO][NF_MAX_HOOKS];
 
-static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
+static inline bool nf_hook_list_active(struct list_head *nf_hook_list,
+                                       u_int8_t pf, unsigned int hook)
 {
         if (__builtin_constant_p(pf) &&
             __builtin_constant_p(hook))
                 return static_key_false(&nf_hooks_needed[pf][hook]);
 
-        return !list_empty(&nf_hooks[pf][hook]);
+        return !list_empty(nf_hook_list);
 }
 #else
-static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
+static inline bool nf_hook_list_active(struct list_head *nf_hook_list,
+                                       u_int8_t pf, unsigned int hook)
 {
-        return !list_empty(&nf_hooks[pf][hook]);
+        return !list_empty(nf_hook_list);
 }
 #endif
 
+static inline bool nf_hooks_active(u_int8_t pf, unsigned int hook)
+{
+        return nf_hook_list_active(&nf_hooks[pf][hook], pf, hook);
+}
+
 int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state);
 
 /**
  *      nf_hook_thresh - call a netfilter hook
- *      
+ *
  *      Returns 1 if the hook has allowed the packet to pass.  The function
  *      okfn must be invoked by the caller in this case.  Any other return
  *      value indicates the packet has been consumed by the hook.
@@ -166,8 +175,8 @@ static inline int nf_hook_thresh(u_int8_t pf, unsigned int hook,
         if (nf_hooks_active(pf, hook)) {
                 struct nf_hook_state state;
 
-                nf_hook_state_init(&state, hook, thresh, pf,
-                                   indev, outdev, sk, okfn);
+                nf_hook_state_init(&state, &nf_hooks[pf][hook], hook, thresh,
+                                   pf, indev, outdev, sk, okfn);
                 return nf_hook_slow(skb, &state);
         }
         return 1;
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
index 34b172301558..48bb01edcf30 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -108,8 +108,13 @@ struct ip_set_counter {
         atomic64_t packets;
 };
 
+struct ip_set_comment_rcu {
+        struct rcu_head rcu;
+        char str[0];
+};
+
 struct ip_set_comment {
-        char *str;
+        struct ip_set_comment_rcu __rcu *c;
 };
 
 struct ip_set_skbinfo {
@@ -122,13 +127,13 @@ struct ip_set_skbinfo {
 struct ip_set;
 
 #define ext_timeout(e, s)       \
-(unsigned long *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_TIMEOUT])
+((unsigned long *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_TIMEOUT]))
 #define ext_counter(e, s)       \
-(struct ip_set_counter *)(((void *)(e)) + (s)->offset[IPSET_EXT_ID_COUNTER])
+((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])
+((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])
+((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,
@@ -176,6 +181,9 @@ struct ip_set_type_variant {
         /* List elements */
         int (*list)(const struct ip_set *set, struct sk_buff *skb,
                     struct netlink_callback *cb);
+        /* Keep listing private when resizing runs parallel */
+        void (*uref)(struct ip_set *set, struct netlink_callback *cb,
+                     bool start);
 
         /* Return true if "b" set is the same as "a"
          * according to the create set parameters */
@@ -223,7 +231,7 @@ struct ip_set {
         /* The name of the set */
         char name[IPSET_MAXNAMELEN];
         /* Lock protecting the set data */
-        rwlock_t lock;
+        spinlock_t lock;
         /* References to the set */
         u32 ref;
         /* The core set type */
@@ -341,12 +349,11 @@ ip_set_put_skbinfo(struct sk_buff *skb, struct ip_set_skbinfo *skbinfo)
                               cpu_to_be64((u64)skbinfo->skbmark << 32 |
                                           skbinfo->skbmarkmask))) ||
                (skbinfo->skbprio &&
-                nla_put_net32(skb, IPSET_ATTR_SKBPRIO,
+                nla_put_net32(skb, IPSET_ATTR_SKBPRIO,
                               cpu_to_be32(skbinfo->skbprio))) ||
                (skbinfo->skbqueue &&
-                nla_put_net16(skb, IPSET_ATTR_SKBQUEUE,
+                nla_put_net16(skb, IPSET_ATTR_SKBQUEUE,
                              cpu_to_be16(skbinfo->skbqueue)));
-
 }
 
 static inline void
@@ -380,12 +387,12 @@ ip_set_init_counter(struct ip_set_counter *counter,
 
 /* Netlink CB args */
 enum {
-        IPSET_CB_NET = 0,
-        IPSET_CB_DUMP,
-        IPSET_CB_INDEX,
-        IPSET_CB_ARG0,
+        IPSET_CB_NET = 0,       /* net namespace */
+        IPSET_CB_DUMP,          /* dump single set/all sets */
+        IPSET_CB_INDEX,         /* set index */
+        IPSET_CB_PRIVATE,       /* set private data */
+        IPSET_CB_ARG0,          /* type specific */
         IPSET_CB_ARG1,
-        IPSET_CB_ARG2,
 };
 
 /* register and unregister set references */
@@ -533,29 +540,9 @@ bitmap_bytes(u32 a, u32 b)
 #include <linux/netfilter/ipset/ip_set_timeout.h>
 #include <linux/netfilter/ipset/ip_set_comment.h>
 
-static inline int
+int
 ip_set_put_extensions(struct sk_buff *skb, const struct ip_set *set,
-                      const void *e, bool active)
-{
-        if (SET_WITH_TIMEOUT(set)) {
-                unsigned long *timeout = ext_timeout(e, set);
-
-                if (nla_put_net32(skb, IPSET_ATTR_TIMEOUT,
-                        htonl(active ? ip_set_timeout_get(timeout)
-                                : *timeout)))
-                        return -EMSGSIZE;
-        }
-        if (SET_WITH_COUNTER(set) &&
-            ip_set_put_counter(skb, ext_counter(e, set)))
-                return -EMSGSIZE;
-        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;
-}
+                      const void *e, bool active);
 
 #define IP_SET_INIT_KEXT(skb, opt, set)                 \
         { .bytes = (skb)->len, .packets = 1,            \
@@ -565,8 +552,6 @@ ip_set_put_extensions(struct sk_buff *skb, const struct ip_set *set,
         { .bytes = ULLONG_MAX, .packets = ULLONG_MAX,   \
           .timeout = (set)->timeout }
 
-#define IP_SET_INIT_CIDR(a, b) ((a) ? (a) : (b))
-
 #define IPSET_CONCAT(a, b)              a##b
 #define IPSET_TOKEN(a, b)               IPSET_CONCAT(a, b)
 
diff --git a/include/linux/netfilter/ipset/ip_set_comment.h b/include/linux/netfilter/ipset/ip_set_comment.h
index 21217ea008d7..8d0248525957 100644
--- a/include/linux/netfilter/ipset/ip_set_comment.h
+++ b/include/linux/netfilter/ipset/ip_set_comment.h
@@ -16,41 +16,57 @@ ip_set_comment_uget(struct nlattr *tb)
         return nla_data(tb);
 }
 
+/* Called from uadd only, protected by the set spinlock.
+ * The kadt functions don't use the comment extensions in any way.
+ */
 static inline void
 ip_set_init_comment(struct ip_set_comment *comment,
                     const struct ip_set_ext *ext)
 {
+        struct ip_set_comment_rcu *c = rcu_dereference_protected(comment->c, 1);
         size_t len = ext->comment ? strlen(ext->comment) : 0;
 
-        if (unlikely(comment->str)) {
-                kfree(comment->str);
-                comment->str = NULL;
+        if (unlikely(c)) {
+                kfree_rcu(c, rcu);
+                rcu_assign_pointer(comment->c, NULL);
         }
         if (!len)
                 return;
         if (unlikely(len > IPSET_MAX_COMMENT_SIZE))
                 len = IPSET_MAX_COMMENT_SIZE;
-        comment->str = kzalloc(len + 1, GFP_ATOMIC);
-        if (unlikely(!comment->str))
+        c = kzalloc(sizeof(*c) + len + 1, GFP_ATOMIC);
+        if (unlikely(!c))
                 return;
-        strlcpy(comment->str, ext->comment, len + 1);
+        strlcpy(c->str, ext->comment, len + 1);
+        rcu_assign_pointer(comment->c, c);
 }
 
+/* Used only when dumping a set, protected by rcu_read_lock_bh() */
 static inline int
 ip_set_put_comment(struct sk_buff *skb, struct ip_set_comment *comment)
 {
-        if (!comment->str)
+        struct ip_set_comment_rcu *c = rcu_dereference_bh(comment->c);
+
+        if (!c)
                 return 0;
-        return nla_put_string(skb, IPSET_ATTR_COMMENT, comment->str);
+        return nla_put_string(skb, IPSET_ATTR_COMMENT, c->str);
 }
 
+/* Called from uadd/udel, flush or the garbage collectors protected
+ * by the set spinlock.
+ * Called when the set is destroyed and when there can't be any user
+ * of the set data anymore.
+ */
 static inline void
 ip_set_comment_free(struct ip_set_comment *comment)
 {
-        if (unlikely(!comment->str))
+        struct ip_set_comment_rcu *c;
+
+        c = rcu_dereference_protected(comment->c, 1);
+        if (unlikely(!c))
                 return;
-        kfree(comment->str);
-        comment->str = NULL;
+        kfree_rcu(c, rcu);
+        rcu_assign_pointer(comment->c, NULL);
 }
 
 #endif
diff --git a/include/linux/netfilter/ipset/ip_set_timeout.h b/include/linux/netfilter/ipset/ip_set_timeout.h
index 83c2f9e0886c..1d6a935c1ac5 100644
--- a/include/linux/netfilter/ipset/ip_set_timeout.h
+++ b/include/linux/netfilter/ipset/ip_set_timeout.h
@@ -40,38 +40,33 @@ ip_set_timeout_uget(struct nlattr *tb)
 }
 
 static inline bool
-ip_set_timeout_test(unsigned long timeout)
+ip_set_timeout_expired(unsigned long *t)
 {
-        return timeout == IPSET_ELEM_PERMANENT ||
-               time_is_after_jiffies(timeout);
-}
-
-static inline bool
-ip_set_timeout_expired(unsigned long *timeout)
-{
-        return *timeout != IPSET_ELEM_PERMANENT &&
-               time_is_before_jiffies(*timeout);
+        return *t != IPSET_ELEM_PERMANENT && time_is_before_jiffies(*t);
 }
 
 static inline void
-ip_set_timeout_set(unsigned long *timeout, u32 t)
+ip_set_timeout_set(unsigned long *timeout, u32 value)
 {
-        if (!t) {
+        unsigned long t;
+
+        if (!value) {
                 *timeout = IPSET_ELEM_PERMANENT;
                 return;
         }
 
-        *timeout = msecs_to_jiffies(t * 1000) + jiffies;
-        if (*timeout == IPSET_ELEM_PERMANENT)
+        t = msecs_to_jiffies(value * MSEC_PER_SEC) + jiffies;
+        if (t == IPSET_ELEM_PERMANENT)
                 /* Bingo! :-) */
-                (*timeout)--;
+                t--;
+        *timeout = t;
 }
 
 static inline u32
 ip_set_timeout_get(unsigned long *timeout)
 {
         return *timeout == IPSET_ELEM_PERMANENT ? 0 :
-                jiffies_to_msecs(*timeout - jiffies)/1000;
+                jiffies_to_msecs(*timeout - jiffies)/MSEC_PER_SEC;
 }
 
 #endif  /* __KERNEL__ */
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index a3e215bb0241..286098a5667f 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -62,6 +62,7 @@ struct xt_mtchk_param {
         void *matchinfo;
         unsigned int hook_mask;
         u_int8_t family;
+        bool nft_compat;
 };
 
 /**
@@ -92,6 +93,7 @@ struct xt_tgchk_param {
         void *targinfo;
         unsigned int hook_mask;
         u_int8_t family;
+        bool nft_compat;
 };
 
 /* Target destructor parameters */
@@ -222,13 +224,10 @@ struct xt_table_info {
         unsigned int stacksize;
         unsigned int __percpu *stackptr;
         void ***jumpstack;
-        /* ipt_entry tables: one per CPU */
-        /* Note : this field MUST be the last one, see XT_TABLE_INFO_SZ */
-        void *entries[1];
+
+        unsigned char entries[0] __aligned(8);
 };
 
-#define XT_TABLE_INFO_SZ (offsetof(struct xt_table_info, entries) \
-                          + nr_cpu_ids * sizeof(char *))
 int xt_register_target(struct xt_target *target);
 void xt_unregister_target(struct xt_target *target);
 int xt_register_targets(struct xt_target *target, unsigned int n);
@@ -351,6 +350,57 @@ static inline unsigned long ifname_compare_aligned(const char *_a,
         return ret;
 }
 
+
+/* On SMP, ip(6)t_entry->counters.pcnt holds address of the
+ * real (percpu) counter.  On !SMP, its just the packet count,
+ * so nothing needs to be done there.
+ *
+ * xt_percpu_counter_alloc returns the address of the percpu
+ * counter, or 0 on !SMP. We force an alignment of 16 bytes
+ * so that bytes/packets share a common cache line.
+ *
+ * Hence caller must use IS_ERR_VALUE to check for error, this
+ * allows us to return 0 for single core systems without forcing
+ * callers to deal with SMP vs. NONSMP issues.
+ */
+static inline u64 xt_percpu_counter_alloc(void)
+{
+        if (nr_cpu_ids > 1) {
+                void __percpu *res = __alloc_percpu(sizeof(struct xt_counters),
+                                                    sizeof(struct xt_counters));
+
+                if (res == NULL)
+                        return (u64) -ENOMEM;
+
+                return (u64) (__force unsigned long) res;
+        }
+
+        return 0;
+}
+static inline void xt_percpu_counter_free(u64 pcnt)
+{
+        if (nr_cpu_ids > 1)
+                free_percpu((void __percpu *) (unsigned long) pcnt);
+}
+
+static inline struct xt_counters *
+xt_get_this_cpu_counter(struct xt_counters *cnt)
+{
+        if (nr_cpu_ids > 1)
+                return this_cpu_ptr((void __percpu *) (unsigned long) cnt->pcnt);
+
+        return cnt;
+}
+
+static inline struct xt_counters *
+xt_get_per_cpu_counter(struct xt_counters *cnt, unsigned int cpu)
+{
+        if (nr_cpu_ids > 1)
+                return per_cpu_ptr((void __percpu *) (unsigned long) cnt->pcnt, cpu);
+
+        return cnt;
+}
+
 struct nf_hook_ops *xt_hook_link(const struct xt_table *, nf_hookfn *);
 void xt_hook_unlink(const struct xt_table *, struct nf_hook_ops *);
 
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
index f2fdb5a52070..6d80fc686323 100644
--- a/include/linux/netfilter_bridge.h
+++ b/include/linux/netfilter_bridge.h
@@ -20,13 +20,6 @@ enum nf_br_hook_priorities {
 #define BRNF_BRIDGED_DNAT               0x02
 #define BRNF_NF_BRIDGE_PREROUTING       0x08
 
-static inline unsigned int nf_bridge_mtu_reduction(const struct sk_buff *skb)
-{
-        if (skb->nf_bridge->orig_proto == BRNF_PROTO_PPPOE)
-                return PPPOE_SES_HLEN;
-        return 0;
-}
-
 int br_handle_frame_finish(struct sock *sk, struct sk_buff *skb);
 
 static inline void br_drop_fake_rtable(struct sk_buff *skb)
diff --git a/include/linux/netfilter_bridge/ebtables.h b/include/linux/netfilter_bridge/ebtables.h
index f1bd3962e6b6..8ca6d6464ea3 100644
--- a/include/linux/netfilter_bridge/ebtables.h
+++ b/include/linux/netfilter_bridge/ebtables.h
@@ -6,7 +6,7 @@
  *
  *  ebtables.c,v 2.0, April, 2002
  *
- *  This code is stongly inspired on the iptables code which is
+ *  This code is strongly inspired by the iptables code which is
  *  Copyright (C) 1999 Paul `Rusty' Russell & Michael J. Neuling
  */
 #ifndef __LINUX_BRIDGE_EFF_H
diff --git a/include/linux/netfilter_defs.h b/include/linux/netfilter_defs.h
new file mode 100644
index 000000000000..d3a7f8597e82
--- /dev/null
+++ b/include/linux/netfilter_defs.h
@@ -0,0 +1,9 @@
+#ifndef __LINUX_NETFILTER_CORE_H_
+#define __LINUX_NETFILTER_CORE_H_
+
+#include <uapi/linux/netfilter.h>
+
+/* Largest hook number + 1, see uapi/linux/netfilter_decnet.h */
+#define NF_MAX_HOOKS 8
+
+#endif
diff --git a/include/linux/netfilter_ingress.h b/include/linux/netfilter_ingress.h
new file mode 100644
index 000000000000..cb0727fe2b3d
--- /dev/null
+++ b/include/linux/netfilter_ingress.h
@@ -0,0 +1,41 @@
+#ifndef _NETFILTER_INGRESS_H_
+#define _NETFILTER_INGRESS_H_
+
+#include <linux/netfilter.h>
+#include <linux/netdevice.h>
+
+#ifdef CONFIG_NETFILTER_INGRESS
+static inline int nf_hook_ingress_active(struct sk_buff *skb)
+{
+        return nf_hook_list_active(&skb->dev->nf_hooks_ingress,
+                                   NFPROTO_NETDEV, NF_NETDEV_INGRESS);
+}
+
+static inline int nf_hook_ingress(struct sk_buff *skb)
+{
+        struct nf_hook_state state;
+
+        nf_hook_state_init(&state, &skb->dev->nf_hooks_ingress,
+                           NF_NETDEV_INGRESS, INT_MIN, NFPROTO_NETDEV, NULL,
+                           skb->dev, NULL, NULL);
+        return nf_hook_slow(skb, &state);
+}
+
+static inline void nf_hook_ingress_init(struct net_device *dev)
+{
+        INIT_LIST_HEAD(&dev->nf_hooks_ingress);
+}
+#else /* CONFIG_NETFILTER_INGRESS */
+static inline int nf_hook_ingress_active(struct sk_buff *skb)
+{
+        return 0;
+}
+
+static inline int nf_hook_ingress(struct sk_buff *skb)
+{
+        return 0;
+}
+
+static inline void nf_hook_ingress_init(struct net_device *dev) {}
+#endif /* CONFIG_NETFILTER_INGRESS */
+#endif /* _NETFILTER_INGRESS_H_ */
diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h
index 64dad1cc1a4b..8b7d28f3aada 100644
--- a/include/linux/netfilter_ipv6.h
+++ b/include/linux/netfilter_ipv6.h
@@ -25,6 +25,9 @@ void ipv6_netfilter_fini(void);
 struct nf_ipv6_ops {
         int (*chk_addr)(struct net *net, const struct in6_addr *addr,
                         const struct net_device *dev, int strict);
+        void (*route_input)(struct sk_buff *skb);
+        int (*fragment)(struct sock *sk, struct sk_buff *skb,
+                        int (*output)(struct sock *, struct sk_buff *));
 };
 
 extern const struct nf_ipv6_ops __rcu *nf_ipv6_ops;
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 6835c1279df7..9120edb650a0 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -28,6 +28,8 @@ struct netlink_skb_parms {
         __u32                   dst_group;
         __u32                   flags;
         struct sock             *sk;
+        bool                    nsid_is_set;
+        int                     nsid;
 };
 
 #define NETLINK_CB(skb)         (*(struct netlink_skb_parms*)&((skb)->cb))
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 32201c269890..b8e72aad919c 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -500,6 +500,7 @@ enum {
         NFSPROC4_CLNT_SEEK,
         NFSPROC4_CLNT_ALLOCATE,
         NFSPROC4_CLNT_DEALLOCATE,
+        NFSPROC4_CLNT_LAYOUTSTATS,
 };
 
 /* nfs41 types */
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index b95f914ce083..874b77228fb9 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -219,6 +219,7 @@ struct nfs_inode {
 #define NFS_INO_COMMIT          (7)             /* inode is committing unstable writes */
 #define NFS_INO_LAYOUTCOMMIT    (9)             /* layoutcommit required */
 #define NFS_INO_LAYOUTCOMMITTING (10)           /* layoutcommit inflight */
+#define NFS_INO_LAYOUTSTATS     (11)            /* layoutstats inflight */
 
 static inline struct nfs_inode *NFS_I(const struct inode *inode)
 {
@@ -291,9 +292,12 @@ static inline void nfs_mark_for_revalidate(struct inode *inode)
         struct nfs_inode *nfsi = NFS_I(inode);
 
         spin_lock(&inode->i_lock);
-        nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS;
+        nfsi->cache_validity |= NFS_INO_INVALID_ATTR |
+                                NFS_INO_REVAL_PAGECACHE |
+                                NFS_INO_INVALID_ACCESS |
+                                NFS_INO_INVALID_ACL;
         if (S_ISDIR(inode->i_mode))
-                nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_DATA;
+                nfsi->cache_validity |= NFS_INO_INVALID_DATA;
         spin_unlock(&inode->i_lock);
 }
 
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 5e1273d4de14..20bc8e51b161 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -220,7 +220,7 @@ struct nfs_server {
 #define NFS_CAP_SYMLINKS        (1U << 2)
 #define NFS_CAP_ACLS            (1U << 3)
 #define NFS_CAP_ATOMIC_OPEN     (1U << 4)
-#define NFS_CAP_CHANGE_ATTR     (1U << 5)
+/* #define NFS_CAP_CHANGE_ATTR  (1U << 5) */
 #define NFS_CAP_FILEID          (1U << 6)
 #define NFS_CAP_MODE            (1U << 7)
 #define NFS_CAP_NLINK           (1U << 8)
@@ -237,5 +237,6 @@ struct nfs_server {
 #define NFS_CAP_SEEK            (1U << 19)
 #define NFS_CAP_ALLOCATE        (1U << 20)
 #define NFS_CAP_DEALLOCATE      (1U << 21)
+#define NFS_CAP_LAYOUTSTATS     (1U << 22)
 
 #endif
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 3eb072dbce83..f2f650f136ee 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -67,7 +67,6 @@ struct nfs_rw_ops {
         const fmode_t rw_mode;
         struct nfs_pgio_header *(*rw_alloc_header)(void);
         void (*rw_free_header)(struct nfs_pgio_header *);
-        void (*rw_release)(struct nfs_pgio_header *);
         int  (*rw_done)(struct rpc_task *, struct nfs_pgio_header *,
                         struct inode *);
         void (*rw_result)(struct rpc_task *, struct nfs_pgio_header *);
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 93ab6071bbe9..7bbe50504211 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -316,6 +316,49 @@ struct nfs4_layoutreturn {
         int rpc_status;
 };
 
+#define PNFS_LAYOUTSTATS_MAXSIZE 256
+
+struct nfs42_layoutstat_args;
+struct nfs42_layoutstat_devinfo;
+typedef void (*layoutstats_encode_t)(struct xdr_stream *,
+                struct nfs42_layoutstat_args *,
+                struct nfs42_layoutstat_devinfo *);
+
+/* Per file per deviceid layoutstats */
+struct nfs42_layoutstat_devinfo {
+        struct nfs4_deviceid dev_id;
+        __u64 offset;
+        __u64 length;
+        __u64 read_count;
+        __u64 read_bytes;
+        __u64 write_count;
+        __u64 write_bytes;
+        __u32 layout_type;
+        layoutstats_encode_t layoutstats_encode;
+        void *layout_private;
+};
+
+struct nfs42_layoutstat_args {
+        struct nfs4_sequence_args seq_args;
+        struct nfs_fh *fh;
+        struct inode *inode;
+        nfs4_stateid stateid;
+        int num_dev;
+        struct nfs42_layoutstat_devinfo *devinfo;
+};
+
+struct nfs42_layoutstat_res {
+        struct nfs4_sequence_res seq_res;
+        int num_dev;
+        int rpc_status;
+};
+
+struct nfs42_layoutstat_data {
+        struct inode *inode;
+        struct nfs42_layoutstat_args args;
+        struct nfs42_layoutstat_res res;
+};
+
 struct stateowner_id {
         __u64   create_time;
         __u32   uniquifier;
@@ -984,17 +1027,14 @@ struct nfs4_readlink_res {
         struct nfs4_sequence_res        seq_res;
 };
 
-#define NFS4_SETCLIENTID_NAMELEN        (127)
 struct nfs4_setclientid {
         const nfs4_verifier *           sc_verifier;
-        unsigned int                    sc_name_len;
-        char                            sc_name[NFS4_SETCLIENTID_NAMELEN + 1];
         u32                             sc_prog;
         unsigned int                    sc_netid_len;
         char                            sc_netid[RPCBIND_MAXNETIDLEN + 1];
         unsigned int                    sc_uaddr_len;
         char                            sc_uaddr[RPCBIND_MAXUADDRLEN + 1];
-        u32                             sc_cb_ident;
+        struct nfs_client               *sc_clnt;
         struct rpc_cred                 *sc_cred;
 };
 
@@ -1142,12 +1182,9 @@ struct nfs41_state_protection {
         struct nfs4_op_map allow;
 };
 
-#define NFS4_EXCHANGE_ID_LEN    (48)
 struct nfs41_exchange_id_args {
         struct nfs_client               *client;
         nfs4_verifier                   *verifier;
-        unsigned int                    id_len;
-        char                            id[NFS4_EXCHANGE_ID_LEN];
         u32                             flags;
         struct nfs41_state_protection   state_protect;
 };
diff --git a/include/linux/nmi.h b/include/linux/nmi.h
index 3d46fb4708e0..f94da0e65dea 100644
--- a/include/linux/nmi.h
+++ b/include/linux/nmi.h
@@ -67,6 +67,7 @@ extern int nmi_watchdog_enabled;
 extern int soft_watchdog_enabled;
 extern int watchdog_user_enabled;
 extern int watchdog_thresh;
+extern unsigned long *watchdog_cpumask_bits;
 extern int sysctl_softlockup_all_cpu_backtrace;
 struct ctl_table;
 extern int proc_watchdog(struct ctl_table *, int ,
@@ -77,6 +78,8 @@ extern int proc_soft_watchdog(struct ctl_table *, int ,
                               void __user *, size_t *, loff_t *);
 extern int proc_watchdog_thresh(struct ctl_table *, int ,
                                 void __user *, size_t *, loff_t *);
+extern int proc_watchdog_cpumask(struct ctl_table *, int,
+                                 void __user *, size_t *, loff_t *);
 #endif
 
 #ifdef CONFIG_HAVE_ACPI_APEI_NMI
diff --git a/include/linux/ntb.h b/include/linux/ntb.h
index 9ac1a62fc6f5..b02f72bb8e32 100644
--- a/include/linux/ntb.h
+++ b/include/linux/ntb.h
@@ -4,15 +4,20 @@
  *
  *   GPL LICENSE SUMMARY
  *
- *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
  *
  *   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.
  *
+ *   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.
+ *
  *   BSD LICENSE
  *
- *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
  *
  *   Redistribution and use in source and binary forms, with or without
  *   modification, are permitted provided that the following conditions
@@ -40,49 +45,940 @@
  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
- * Intel PCIe NTB Linux driver
+ * PCIe NTB Linux driver
  *
  * Contact Information:
- * Jon Mason <jon.mason@intel.com>
+ * Allen Hubbe <Allen.Hubbe@emc.com>
  */
 
-struct ntb_transport_qp;
+#ifndef _NTB_H_
+#define _NTB_H_
 
-struct ntb_client {
-        struct device_driver driver;
-        int (*probe)(struct pci_dev *pdev);
-        void (*remove)(struct pci_dev *pdev);
+#include <linux/completion.h>
+#include <linux/device.h>
+
+struct ntb_client;
+struct ntb_dev;
+struct pci_dev;
+
+/**
+ * enum ntb_topo - NTB connection topology
+ * @NTB_TOPO_NONE:      Topology is unknown or invalid.
+ * @NTB_TOPO_PRI:       On primary side of local ntb.
+ * @NTB_TOPO_SEC:       On secondary side of remote ntb.
+ * @NTB_TOPO_B2B_USD:   On primary side of local ntb upstream of remote ntb.
+ * @NTB_TOPO_B2B_DSD:   On primary side of local ntb downstream of remote ntb.
+ */
+enum ntb_topo {
+        NTB_TOPO_NONE = -1,
+        NTB_TOPO_PRI,
+        NTB_TOPO_SEC,
+        NTB_TOPO_B2B_USD,
+        NTB_TOPO_B2B_DSD,
+};
+
+static inline int ntb_topo_is_b2b(enum ntb_topo topo)
+{
+        switch ((int)topo) {
+        case NTB_TOPO_B2B_USD:
+        case NTB_TOPO_B2B_DSD:
+                return 1;
+        }
+        return 0;
+}
+
+static inline char *ntb_topo_string(enum ntb_topo topo)
+{
+        switch (topo) {
+        case NTB_TOPO_NONE:     return "NTB_TOPO_NONE";
+        case NTB_TOPO_PRI:      return "NTB_TOPO_PRI";
+        case NTB_TOPO_SEC:      return "NTB_TOPO_SEC";
+        case NTB_TOPO_B2B_USD:  return "NTB_TOPO_B2B_USD";
+        case NTB_TOPO_B2B_DSD:  return "NTB_TOPO_B2B_DSD";
+        }
+        return "NTB_TOPO_INVALID";
+}
+
+/**
+ * enum ntb_speed - NTB link training speed
+ * @NTB_SPEED_AUTO:     Request the max supported speed.
+ * @NTB_SPEED_NONE:     Link is not trained to any speed.
+ * @NTB_SPEED_GEN1:     Link is trained to gen1 speed.
+ * @NTB_SPEED_GEN2:     Link is trained to gen2 speed.
+ * @NTB_SPEED_GEN3:     Link is trained to gen3 speed.
+ */
+enum ntb_speed {
+        NTB_SPEED_AUTO = -1,
+        NTB_SPEED_NONE = 0,
+        NTB_SPEED_GEN1 = 1,
+        NTB_SPEED_GEN2 = 2,
+        NTB_SPEED_GEN3 = 3,
+};
+
+/**
+ * enum ntb_width - NTB link training width
+ * @NTB_WIDTH_AUTO:     Request the max supported width.
+ * @NTB_WIDTH_NONE:     Link is not trained to any width.
+ * @NTB_WIDTH_1:        Link is trained to 1 lane width.
+ * @NTB_WIDTH_2:        Link is trained to 2 lane width.
+ * @NTB_WIDTH_4:        Link is trained to 4 lane width.
+ * @NTB_WIDTH_8:        Link is trained to 8 lane width.
+ * @NTB_WIDTH_12:       Link is trained to 12 lane width.
+ * @NTB_WIDTH_16:       Link is trained to 16 lane width.
+ * @NTB_WIDTH_32:       Link is trained to 32 lane width.
+ */
+enum ntb_width {
+        NTB_WIDTH_AUTO = -1,
+        NTB_WIDTH_NONE = 0,
+        NTB_WIDTH_1 = 1,
+        NTB_WIDTH_2 = 2,
+        NTB_WIDTH_4 = 4,
+        NTB_WIDTH_8 = 8,
+        NTB_WIDTH_12 = 12,
+        NTB_WIDTH_16 = 16,
+        NTB_WIDTH_32 = 32,
+};
+
+/**
+ * struct ntb_client_ops - ntb client operations
+ * @probe:              Notify client of a new device.
+ * @remove:             Notify client to remove a device.
+ */
+struct ntb_client_ops {
+        int (*probe)(struct ntb_client *client, struct ntb_dev *ntb);
+        void (*remove)(struct ntb_client *client, struct ntb_dev *ntb);
+};
+
+static inline int ntb_client_ops_is_valid(const struct ntb_client_ops *ops)
+{
+        /* commented callbacks are not required: */
+        return
+                ops->probe                      &&
+                ops->remove                     &&
+                1;
+}
+
+/**
+ * struct ntb_ctx_ops - ntb driver context operations
+ * @link_event:         See ntb_link_event().
+ * @db_event:           See ntb_db_event().
+ */
+struct ntb_ctx_ops {
+        void (*link_event)(void *ctx);
+        void (*db_event)(void *ctx, int db_vector);
+};
+
+static inline int ntb_ctx_ops_is_valid(const struct ntb_ctx_ops *ops)
+{
+        /* commented callbacks are not required: */
+        return
+                /* ops->link_event              && */
+                /* ops->db_event                && */
+                1;
+}
+
+/**
+ * struct ntb_ctx_ops - ntb device operations
+ * @mw_count:           See ntb_mw_count().
+ * @mw_get_range:       See ntb_mw_get_range().
+ * @mw_set_trans:       See ntb_mw_set_trans().
+ * @mw_clear_trans:     See ntb_mw_clear_trans().
+ * @link_is_up:         See ntb_link_is_up().
+ * @link_enable:        See ntb_link_enable().
+ * @link_disable:       See ntb_link_disable().
+ * @db_is_unsafe:       See ntb_db_is_unsafe().
+ * @db_valid_mask:      See ntb_db_valid_mask().
+ * @db_vector_count:    See ntb_db_vector_count().
+ * @db_vector_mask:     See ntb_db_vector_mask().
+ * @db_read:            See ntb_db_read().
+ * @db_set:             See ntb_db_set().
+ * @db_clear:           See ntb_db_clear().
+ * @db_read_mask:       See ntb_db_read_mask().
+ * @db_set_mask:        See ntb_db_set_mask().
+ * @db_clear_mask:      See ntb_db_clear_mask().
+ * @peer_db_addr:       See ntb_peer_db_addr().
+ * @peer_db_read:       See ntb_peer_db_read().
+ * @peer_db_set:        See ntb_peer_db_set().
+ * @peer_db_clear:      See ntb_peer_db_clear().
+ * @peer_db_read_mask:  See ntb_peer_db_read_mask().
+ * @peer_db_set_mask:   See ntb_peer_db_set_mask().
+ * @peer_db_clear_mask: See ntb_peer_db_clear_mask().
+ * @spad_is_unsafe:     See ntb_spad_is_unsafe().
+ * @spad_count:         See ntb_spad_count().
+ * @spad_read:          See ntb_spad_read().
+ * @spad_write:         See ntb_spad_write().
+ * @peer_spad_addr:     See ntb_peer_spad_addr().
+ * @peer_spad_read:     See ntb_peer_spad_read().
+ * @peer_spad_write:    See ntb_peer_spad_write().
+ */
+struct ntb_dev_ops {
+        int (*mw_count)(struct ntb_dev *ntb);
+        int (*mw_get_range)(struct ntb_dev *ntb, int idx,
+                            phys_addr_t *base, resource_size_t *size,
+                        resource_size_t *align, resource_size_t *align_size);
+        int (*mw_set_trans)(struct ntb_dev *ntb, int idx,
+                            dma_addr_t addr, resource_size_t size);
+        int (*mw_clear_trans)(struct ntb_dev *ntb, int idx);
+
+        int (*link_is_up)(struct ntb_dev *ntb,
+                          enum ntb_speed *speed, enum ntb_width *width);
+        int (*link_enable)(struct ntb_dev *ntb,
+                           enum ntb_speed max_speed, enum ntb_width max_width);
+        int (*link_disable)(struct ntb_dev *ntb);
+
+        int (*db_is_unsafe)(struct ntb_dev *ntb);
+        u64 (*db_valid_mask)(struct ntb_dev *ntb);
+        int (*db_vector_count)(struct ntb_dev *ntb);
+        u64 (*db_vector_mask)(struct ntb_dev *ntb, int db_vector);
+
+        u64 (*db_read)(struct ntb_dev *ntb);
+        int (*db_set)(struct ntb_dev *ntb, u64 db_bits);
+        int (*db_clear)(struct ntb_dev *ntb, u64 db_bits);
+
+        u64 (*db_read_mask)(struct ntb_dev *ntb);
+        int (*db_set_mask)(struct ntb_dev *ntb, u64 db_bits);
+        int (*db_clear_mask)(struct ntb_dev *ntb, u64 db_bits);
+
+        int (*peer_db_addr)(struct ntb_dev *ntb,
+                            phys_addr_t *db_addr, resource_size_t *db_size);
+        u64 (*peer_db_read)(struct ntb_dev *ntb);
+        int (*peer_db_set)(struct ntb_dev *ntb, u64 db_bits);
+        int (*peer_db_clear)(struct ntb_dev *ntb, u64 db_bits);
+
+        u64 (*peer_db_read_mask)(struct ntb_dev *ntb);
+        int (*peer_db_set_mask)(struct ntb_dev *ntb, u64 db_bits);
+        int (*peer_db_clear_mask)(struct ntb_dev *ntb, u64 db_bits);
+
+        int (*spad_is_unsafe)(struct ntb_dev *ntb);
+        int (*spad_count)(struct ntb_dev *ntb);
+
+        u32 (*spad_read)(struct ntb_dev *ntb, int idx);
+        int (*spad_write)(struct ntb_dev *ntb, int idx, u32 val);
+
+        int (*peer_spad_addr)(struct ntb_dev *ntb, int idx,
+                              phys_addr_t *spad_addr);
+        u32 (*peer_spad_read)(struct ntb_dev *ntb, int idx);
+        int (*peer_spad_write)(struct ntb_dev *ntb, int idx, u32 val);
 };
 
-enum {
-        NTB_LINK_DOWN = 0,
-        NTB_LINK_UP,
+static inline int ntb_dev_ops_is_valid(const struct ntb_dev_ops *ops)
+{
+        /* commented callbacks are not required: */
+        return
+                ops->mw_count                           &&
+                ops->mw_get_range                       &&
+                ops->mw_set_trans                       &&
+                /* ops->mw_clear_trans                  && */
+                ops->link_is_up                         &&
+                ops->link_enable                        &&
+                ops->link_disable                       &&
+                /* ops->db_is_unsafe                    && */
+                ops->db_valid_mask                      &&
+
+                /* both set, or both unset */
+                (!ops->db_vector_count == !ops->db_vector_mask) &&
+
+                ops->db_read                            &&
+                /* ops->db_set                          && */
+                ops->db_clear                           &&
+                /* ops->db_read_mask                    && */
+                ops->db_set_mask                        &&
+                ops->db_clear_mask                      &&
+                ops->peer_db_addr                       &&
+                /* ops->peer_db_read                    && */
+                ops->peer_db_set                        &&
+                /* ops->peer_db_clear                   && */
+                /* ops->peer_db_read_mask               && */
+                /* ops->peer_db_set_mask                && */
+                /* ops->peer_db_clear_mask              && */
+                /* ops->spad_is_unsafe                  && */
+                ops->spad_count                         &&
+                ops->spad_read                          &&
+                ops->spad_write                         &&
+                ops->peer_spad_addr                     &&
+                /* ops->peer_spad_read                  && */
+                ops->peer_spad_write                    &&
+                1;
+}
+
+/**
+ * struct ntb_client - client interested in ntb devices
+ * @drv:                Linux driver object.
+ * @ops:                See &ntb_client_ops.
+ */
+struct ntb_client {
+        struct device_driver            drv;
+        const struct ntb_client_ops     ops;
 };
 
-int ntb_register_client(struct ntb_client *drvr);
-void ntb_unregister_client(struct ntb_client *drvr);
-int ntb_register_client_dev(char *device_name);
-void ntb_unregister_client_dev(char *device_name);
-
-struct ntb_queue_handlers {
-        void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
-                           void *data, int len);
-        void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
-                           void *data, int len);
-        void (*event_handler)(void *data, int status);
+#define drv_ntb_client(__drv) container_of((__drv), struct ntb_client, drv)
+
+/**
+ * struct ntb_device - ntb device
+ * @dev:                Linux device object.
+ * @pdev:               Pci device entry of the ntb.
+ * @topo:               Detected topology of the ntb.
+ * @ops:                See &ntb_dev_ops.
+ * @ctx:                See &ntb_ctx_ops.
+ * @ctx_ops:            See &ntb_ctx_ops.
+ */
+struct ntb_dev {
+        struct device                   dev;
+        struct pci_dev                  *pdev;
+        enum ntb_topo                   topo;
+        const struct ntb_dev_ops        *ops;
+        void                            *ctx;
+        const struct ntb_ctx_ops        *ctx_ops;
+
+        /* private: */
+
+        /* synchronize setting, clearing, and calling ctx_ops */
+        spinlock_t                      ctx_lock;
+        /* block unregister until device is fully released */
+        struct completion               released;
 };
 
-unsigned char ntb_transport_qp_num(struct ntb_transport_qp *qp);
-unsigned int ntb_transport_max_size(struct ntb_transport_qp *qp);
-struct ntb_transport_qp *
-ntb_transport_create_queue(void *data, struct pci_dev *pdev,
-                           const struct ntb_queue_handlers *handlers);
-void ntb_transport_free_queue(struct ntb_transport_qp *qp);
-int ntb_transport_rx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
-                             unsigned int len);
-int ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
-                             unsigned int len);
-void *ntb_transport_rx_remove(struct ntb_transport_qp *qp, unsigned int *len);
-void ntb_transport_link_up(struct ntb_transport_qp *qp);
-void ntb_transport_link_down(struct ntb_transport_qp *qp);
-bool ntb_transport_link_query(struct ntb_transport_qp *qp);
+#define dev_ntb(__dev) container_of((__dev), struct ntb_dev, dev)
+
+/**
+ * ntb_register_client() - register a client for interest in ntb devices
+ * @client:     Client context.
+ *
+ * The client will be added to the list of clients interested in ntb devices.
+ * The client will be notified of any ntb devices that are not already
+ * associated with a client, or if ntb devices are registered later.
+ *
+ * Return: Zero if the client is registered, otherwise an error number.
+ */
+#define ntb_register_client(client) \
+        __ntb_register_client((client), THIS_MODULE, KBUILD_MODNAME)
+
+int __ntb_register_client(struct ntb_client *client, struct module *mod,
+                          const char *mod_name);
+
+/**
+ * ntb_unregister_client() - unregister a client for interest in ntb devices
+ * @client:     Client context.
+ *
+ * The client will be removed from the list of clients interested in ntb
+ * devices.  If any ntb devices are associated with the client, the client will
+ * be notified to remove those devices.
+ */
+void ntb_unregister_client(struct ntb_client *client);
+
+#define module_ntb_client(__ntb_client) \
+        module_driver(__ntb_client, ntb_register_client, \
+                        ntb_unregister_client)
+
+/**
+ * ntb_register_device() - register a ntb device
+ * @ntb:        NTB device context.
+ *
+ * The device will be added to the list of ntb devices.  If any clients are
+ * interested in ntb devices, each client will be notified of the ntb device,
+ * until at most one client accepts the device.
+ *
+ * Return: Zero if the device is registered, otherwise an error number.
+ */
+int ntb_register_device(struct ntb_dev *ntb);
+
+/**
+ * ntb_register_device() - unregister a ntb device
+ * @ntb:        NTB device context.
+ *
+ * The device will be removed from the list of ntb devices.  If the ntb device
+ * is associated with a client, the client will be notified to remove the
+ * device.
+ */
+void ntb_unregister_device(struct ntb_dev *ntb);
+
+/**
+ * ntb_set_ctx() - associate a driver context with an ntb device
+ * @ntb:        NTB device context.
+ * @ctx:        Driver context.
+ * @ctx_ops:    Driver context operations.
+ *
+ * Associate a driver context and operations with a ntb device.  The context is
+ * provided by the client driver, and the driver may associate a different
+ * context with each ntb device.
+ *
+ * Return: Zero if the context is associated, otherwise an error number.
+ */
+int ntb_set_ctx(struct ntb_dev *ntb, void *ctx,
+                const struct ntb_ctx_ops *ctx_ops);
+
+/**
+ * ntb_clear_ctx() - disassociate any driver context from an ntb device
+ * @ntb:        NTB device context.
+ *
+ * Clear any association that may exist between a driver context and the ntb
+ * device.
+ */
+void ntb_clear_ctx(struct ntb_dev *ntb);
+
+/**
+ * ntb_link_event() - notify driver context of a change in link status
+ * @ntb:        NTB device context.
+ *
+ * Notify the driver context that the link status may have changed.  The driver
+ * should call ntb_link_is_up() to get the current status.
+ */
+void ntb_link_event(struct ntb_dev *ntb);
+
+/**
+ * ntb_db_event() - notify driver context of a doorbell event
+ * @ntb:        NTB device context.
+ * @vector:     Interrupt vector number.
+ *
+ * Notify the driver context of a doorbell event.  If hardware supports
+ * multiple interrupt vectors for doorbells, the vector number indicates which
+ * vector received the interrupt.  The vector number is relative to the first
+ * vector used for doorbells, starting at zero, and must be less than
+ ** ntb_db_vector_count().  The driver may call ntb_db_read() to check which
+ * doorbell bits need service, and ntb_db_vector_mask() to determine which of
+ * those bits are associated with the vector number.
+ */
+void ntb_db_event(struct ntb_dev *ntb, int vector);
+
+/**
+ * ntb_mw_count() - get the number of memory windows
+ * @ntb:        NTB device context.
+ *
+ * Hardware and topology may support a different number of memory windows.
+ *
+ * Return: the number of memory windows.
+ */
+static inline int ntb_mw_count(struct ntb_dev *ntb)
+{
+        return ntb->ops->mw_count(ntb);
+}
+
+/**
+ * ntb_mw_get_range() - get the range of a memory window
+ * @ntb:        NTB device context.
+ * @idx:        Memory window number.
+ * @base:       OUT - the base address for mapping the memory window
+ * @size:       OUT - the size for mapping the memory window
+ * @align:      OUT - the base alignment for translating the memory window
+ * @align_size: OUT - the size alignment for translating the memory window
+ *
+ * Get the range of a memory window.  NULL may be given for any output
+ * parameter if the value is not needed.  The base and size may be used for
+ * mapping the memory window, to access the peer memory.  The alignment and
+ * size may be used for translating the memory window, for the peer to access
+ * memory on the local system.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_mw_get_range(struct ntb_dev *ntb, int idx,
+                                   phys_addr_t *base, resource_size_t *size,
+                resource_size_t *align, resource_size_t *align_size)
+{
+        return ntb->ops->mw_get_range(ntb, idx, base, size,
+                        align, align_size);
+}
+
+/**
+ * ntb_mw_set_trans() - set the translation of a memory window
+ * @ntb:        NTB device context.
+ * @idx:        Memory window number.
+ * @addr:       The dma address local memory to expose to the peer.
+ * @size:       The size of the local memory to expose to the peer.
+ *
+ * Set the translation of a memory window.  The peer may access local memory
+ * through the window starting at the address, up to the size.  The address
+ * must be aligned to the alignment specified by ntb_mw_get_range().  The size
+ * must be aligned to the size alignment specified by ntb_mw_get_range().
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_mw_set_trans(struct ntb_dev *ntb, int idx,
+                                   dma_addr_t addr, resource_size_t size)
+{
+        return ntb->ops->mw_set_trans(ntb, idx, addr, size);
+}
+
+/**
+ * ntb_mw_clear_trans() - clear the translation of a memory window
+ * @ntb:        NTB device context.
+ * @idx:        Memory window number.
+ *
+ * Clear the translation of a memory window.  The peer may no longer access
+ * local memory through the window.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_mw_clear_trans(struct ntb_dev *ntb, int idx)
+{
+        if (!ntb->ops->mw_clear_trans)
+                return ntb->ops->mw_set_trans(ntb, idx, 0, 0);
+
+        return ntb->ops->mw_clear_trans(ntb, idx);
+}
+
+/**
+ * ntb_link_is_up() - get the current ntb link state
+ * @ntb:        NTB device context.
+ * @speed:      OUT - The link speed expressed as PCIe generation number.
+ * @width:      OUT - The link width expressed as the number of PCIe lanes.
+ *
+ * Set the translation of a memory window.  The peer may access local memory
+ * through the window starting at the address, up to the size.  The address
+ * must be aligned to the alignment specified by ntb_mw_get_range().  The size
+ * must be aligned to the size alignment specified by ntb_mw_get_range().
+ *
+ * Return: One if the link is up, zero if the link is down, otherwise a
+ *              negative value indicating the error number.
+ */
+static inline int ntb_link_is_up(struct ntb_dev *ntb,
+                                 enum ntb_speed *speed, enum ntb_width *width)
+{
+        return ntb->ops->link_is_up(ntb, speed, width);
+}
+
+/**
+ * ntb_link_enable() - enable the link on the secondary side of the ntb
+ * @ntb:        NTB device context.
+ * @max_speed:  The maximum link speed expressed as PCIe generation number.
+ * @max_width:  The maximum link width expressed as the number of PCIe lanes.
+ *
+ * Enable the link on the secondary side of the ntb.  This can only be done
+ * from the primary side of the ntb in primary or b2b topology.  The ntb device
+ * should train the link to its maximum speed and width, or the requested speed
+ * and width, whichever is smaller, if supported.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_link_enable(struct ntb_dev *ntb,
+                                  enum ntb_speed max_speed,
+                                  enum ntb_width max_width)
+{
+        return ntb->ops->link_enable(ntb, max_speed, max_width);
+}
+
+/**
+ * ntb_link_disable() - disable the link on the secondary side of the ntb
+ * @ntb:        NTB device context.
+ *
+ * Disable the link on the secondary side of the ntb.  This can only be
+ * done from the primary side of the ntb in primary or b2b topology.  The ntb
+ * device should disable the link.  Returning from this call must indicate that
+ * a barrier has passed, though with no more writes may pass in either
+ * direction across the link, except if this call returns an error number.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_link_disable(struct ntb_dev *ntb)
+{
+        return ntb->ops->link_disable(ntb);
+}
+
+/**
+ * ntb_db_is_unsafe() - check if it is safe to use hardware doorbell
+ * @ntb:        NTB device context.
+ *
+ * It is possible for some ntb hardware to be affected by errata.  Hardware
+ * drivers can advise clients to avoid using doorbells.  Clients may ignore
+ * this advice, though caution is recommended.
+ *
+ * Return: Zero if it is safe to use doorbells, or One if it is not safe.
+ */
+static inline int ntb_db_is_unsafe(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_is_unsafe)
+                return 0;
+
+        return ntb->ops->db_is_unsafe(ntb);
+}
+
+/**
+ * ntb_db_valid_mask() - get a mask of doorbell bits supported by the ntb
+ * @ntb:        NTB device context.
+ *
+ * Hardware may support different number or arrangement of doorbell bits.
+ *
+ * Return: A mask of doorbell bits supported by the ntb.
+ */
+static inline u64 ntb_db_valid_mask(struct ntb_dev *ntb)
+{
+        return ntb->ops->db_valid_mask(ntb);
+}
+
+/**
+ * ntb_db_vector_count() - get the number of doorbell interrupt vectors
+ * @ntb:        NTB device context.
+ *
+ * Hardware may support different number of interrupt vectors.
+ *
+ * Return: The number of doorbell interrupt vectors.
+ */
+static inline int ntb_db_vector_count(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_vector_count)
+                return 1;
+
+        return ntb->ops->db_vector_count(ntb);
+}
+
+/**
+ * ntb_db_vector_mask() - get a mask of doorbell bits serviced by a vector
+ * @ntb:        NTB device context.
+ * @vector:     Doorbell vector number.
+ *
+ * Each interrupt vector may have a different number or arrangement of bits.
+ *
+ * Return: A mask of doorbell bits serviced by a vector.
+ */
+static inline u64 ntb_db_vector_mask(struct ntb_dev *ntb, int vector)
+{
+        if (!ntb->ops->db_vector_mask)
+                return ntb_db_valid_mask(ntb);
+
+        return ntb->ops->db_vector_mask(ntb, vector);
+}
+
+/**
+ * ntb_db_read() - read the local doorbell register
+ * @ntb:        NTB device context.
+ *
+ * Read the local doorbell register, and return the bits that are set.
+ *
+ * Return: The bits currently set in the local doorbell register.
+ */
+static inline u64 ntb_db_read(struct ntb_dev *ntb)
+{
+        return ntb->ops->db_read(ntb);
+}
+
+/**
+ * ntb_db_set() - set bits in the local doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to set.
+ *
+ * Set bits in the local doorbell register, which may generate a local doorbell
+ * interrupt.  Bits that were already set must remain set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_set(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_set)
+                return -EINVAL;
+
+        return ntb->ops->db_set(ntb, db_bits);
+}
+
+/**
+ * ntb_db_clear() - clear bits in the local doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the local doorbell register, arming the bits for the next
+ * doorbell.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_clear(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->db_clear(ntb, db_bits);
+}
+
+/**
+ * ntb_db_read_mask() - read the local doorbell mask
+ * @ntb:        NTB device context.
+ *
+ * Read the local doorbell mask register, and return the bits that are set.
+ *
+ * This is unusual, though hardware is likely to support it.
+ *
+ * Return: The bits currently set in the local doorbell mask register.
+ */
+static inline u64 ntb_db_read_mask(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_read_mask)
+                return 0;
+
+        return ntb->ops->db_read_mask(ntb);
+}
+
+/**
+ * ntb_db_set_mask() - set bits in the local doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell mask bits to set.
+ *
+ * Set bits in the local doorbell mask register, preventing doorbell interrupts
+ * from being generated for those doorbell bits.  Bits that were already set
+ * must remain set.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_set_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->db_set_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_db_clear_mask() - clear bits in the local doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the local doorbell mask register, allowing doorbell interrupts
+ * from being generated for those doorbell bits.  If a doorbell bit is already
+ * set at the time the mask is cleared, and the corresponding mask bit is
+ * changed from set to clear, then the ntb driver must ensure that
+ * ntb_db_event() is called.  If the hardware does not generate the interrupt
+ * on clearing the mask bit, then the driver must call ntb_db_event() anyway.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_db_clear_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->db_clear_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_addr() - address and size of the peer doorbell register
+ * @ntb:        NTB device context.
+ * @db_addr:    OUT - The address of the peer doorbell register.
+ * @db_size:    OUT - The number of bytes to write the peer doorbell register.
+ *
+ * Return the address of the peer doorbell register.  This may be used, for
+ * example, by drivers that offload memory copy operations to a dma engine.
+ * The drivers may wish to ring the peer doorbell at the completion of memory
+ * copy operations.  For efficiency, and to simplify ordering of operations
+ * between the dma memory copies and the ringing doorbell, the driver may
+ * append one additional dma memory copy with the doorbell register as the
+ * destination, after the memory copy operations.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_addr(struct ntb_dev *ntb,
+                                   phys_addr_t *db_addr,
+                                   resource_size_t *db_size)
+{
+        return ntb->ops->peer_db_addr(ntb, db_addr, db_size);
+}
+
+/**
+ * ntb_peer_db_read() - read the peer doorbell register
+ * @ntb:        NTB device context.
+ *
+ * Read the peer doorbell register, and return the bits that are set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: The bits currently set in the peer doorbell register.
+ */
+static inline u64 ntb_peer_db_read(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->peer_db_read)
+                return 0;
+
+        return ntb->ops->peer_db_read(ntb);
+}
+
+/**
+ * ntb_peer_db_set() - set bits in the peer doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to set.
+ *
+ * Set bits in the peer doorbell register, which may generate a peer doorbell
+ * interrupt.  Bits that were already set must remain set.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_set(struct ntb_dev *ntb, u64 db_bits)
+{
+        return ntb->ops->peer_db_set(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_clear() - clear bits in the local doorbell register
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the peer doorbell register, arming the bits for the next
+ * doorbell.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_clear(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_clear)
+                return -EINVAL;
+
+        return ntb->ops->peer_db_clear(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_read_mask() - read the peer doorbell mask
+ * @ntb:        NTB device context.
+ *
+ * Read the peer doorbell mask register, and return the bits that are set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: The bits currently set in the peer doorbell mask register.
+ */
+static inline u64 ntb_peer_db_read_mask(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->db_read_mask)
+                return 0;
+
+        return ntb->ops->peer_db_read_mask(ntb);
+}
+
+/**
+ * ntb_peer_db_set_mask() - set bits in the peer doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell mask bits to set.
+ *
+ * Set bits in the peer doorbell mask register, preventing doorbell interrupts
+ * from being generated for those doorbell bits.  Bits that were already set
+ * must remain set.
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_set_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_set_mask)
+                return -EINVAL;
+
+        return ntb->ops->peer_db_set_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_peer_db_clear_mask() - clear bits in the peer doorbell mask
+ * @ntb:        NTB device context.
+ * @db_bits:    Doorbell bits to clear.
+ *
+ * Clear bits in the peer doorbell mask register, allowing doorbell interrupts
+ * from being generated for those doorbell bits.  If the hardware does not
+ * generate the interrupt on clearing the mask bit, then the driver should not
+ * implement this function!
+ *
+ * This is unusual, and hardware may not support it.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_db_clear_mask(struct ntb_dev *ntb, u64 db_bits)
+{
+        if (!ntb->ops->db_clear_mask)
+                return -EINVAL;
+
+        return ntb->ops->peer_db_clear_mask(ntb, db_bits);
+}
+
+/**
+ * ntb_spad_is_unsafe() - check if it is safe to use the hardware scratchpads
+ * @ntb:        NTB device context.
+ *
+ * It is possible for some ntb hardware to be affected by errata.  Hardware
+ * drivers can advise clients to avoid using scratchpads.  Clients may ignore
+ * this advice, though caution is recommended.
+ *
+ * Return: Zero if it is safe to use scratchpads, or One if it is not safe.
+ */
+static inline int ntb_spad_is_unsafe(struct ntb_dev *ntb)
+{
+        if (!ntb->ops->spad_is_unsafe)
+                return 0;
+
+        return ntb->ops->spad_is_unsafe(ntb);
+}
+
+/**
+ * ntb_mw_count() - get the number of scratchpads
+ * @ntb:        NTB device context.
+ *
+ * Hardware and topology may support a different number of scratchpads.
+ *
+ * Return: the number of scratchpads.
+ */
+static inline int ntb_spad_count(struct ntb_dev *ntb)
+{
+        return ntb->ops->spad_count(ntb);
+}
+
+/**
+ * ntb_spad_read() - read the local scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ *
+ * Read the local scratchpad register, and return the value.
+ *
+ * Return: The value of the local scratchpad register.
+ */
+static inline u32 ntb_spad_read(struct ntb_dev *ntb, int idx)
+{
+        return ntb->ops->spad_read(ntb, idx);
+}
+
+/**
+ * ntb_spad_write() - write the local scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ * @val:        Scratchpad value.
+ *
+ * Write the value to the local scratchpad register.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_spad_write(struct ntb_dev *ntb, int idx, u32 val)
+{
+        return ntb->ops->spad_write(ntb, idx, val);
+}
+
+/**
+ * ntb_peer_spad_addr() - address of the peer scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ * @spad_addr:  OUT - The address of the peer scratchpad register.
+ *
+ * Return the address of the peer doorbell register.  This may be used, for
+ * example, by drivers that offload memory copy operations to a dma engine.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_spad_addr(struct ntb_dev *ntb, int idx,
+                                     phys_addr_t *spad_addr)
+{
+        return ntb->ops->peer_spad_addr(ntb, idx, spad_addr);
+}
+
+/**
+ * ntb_peer_spad_read() - read the peer scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ *
+ * Read the peer scratchpad register, and return the value.
+ *
+ * Return: The value of the local scratchpad register.
+ */
+static inline u32 ntb_peer_spad_read(struct ntb_dev *ntb, int idx)
+{
+        return ntb->ops->peer_spad_read(ntb, idx);
+}
+
+/**
+ * ntb_peer_spad_write() - write the peer scratchpad register
+ * @ntb:        NTB device context.
+ * @idx:        Scratchpad index.
+ * @val:        Scratchpad value.
+ *
+ * Write the value to the peer scratchpad register.
+ *
+ * Return: Zero on success, otherwise an error number.
+ */
+static inline int ntb_peer_spad_write(struct ntb_dev *ntb, int idx, u32 val)
+{
+        return ntb->ops->peer_spad_write(ntb, idx, val);
+}
+
+#endif
diff --git a/include/linux/ntb_transport.h b/include/linux/ntb_transport.h
new file mode 100644
index 000000000000..2862861366a5
--- /dev/null
+++ b/include/linux/ntb_transport.h
@@ -0,0 +1,85 @@
+/*
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ *   redistributing this file, you may do so under either license.
+ *
+ *   GPL LICENSE SUMMARY
+ *
+ *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
+ *
+ *   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.
+ *
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *   Copyright (C) 2015 EMC Corporation. All Rights Reserved.
+ *
+ *   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 copy
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ *   OWNER 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.
+ *
+ * PCIe NTB Transport Linux driver
+ *
+ * Contact Information:
+ * Jon Mason <jon.mason@intel.com>
+ */
+
+struct ntb_transport_qp;
+
+struct ntb_transport_client {
+        struct device_driver driver;
+        int (*probe)(struct device *client_dev);
+        void (*remove)(struct device *client_dev);
+};
+
+int ntb_transport_register_client(struct ntb_transport_client *drvr);
+void ntb_transport_unregister_client(struct ntb_transport_client *drvr);
+int ntb_transport_register_client_dev(char *device_name);
+void ntb_transport_unregister_client_dev(char *device_name);
+
+struct ntb_queue_handlers {
+        void (*rx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
+        void (*tx_handler)(struct ntb_transport_qp *qp, void *qp_data,
+                           void *data, int len);
+        void (*event_handler)(void *data, int status);
+};
+
+unsigned char ntb_transport_qp_num(struct ntb_transport_qp *qp);
+unsigned int ntb_transport_max_size(struct ntb_transport_qp *qp);
+struct ntb_transport_qp *
+ntb_transport_create_queue(void *data, struct device *client_dev,
+                           const struct ntb_queue_handlers *handlers);
+void ntb_transport_free_queue(struct ntb_transport_qp *qp);
+int ntb_transport_rx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
+                             unsigned int len);
+int ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
+                             unsigned int len);
+void *ntb_transport_rx_remove(struct ntb_transport_qp *qp, unsigned int *len);
+void ntb_transport_link_up(struct ntb_transport_qp *qp);
+void ntb_transport_link_down(struct ntb_transport_qp *qp);
+bool ntb_transport_link_query(struct ntb_transport_qp *qp);
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 8dbd05e70f09..c0d94ed8ce9a 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -74,7 +74,7 @@ struct nvme_dev {
         struct blk_mq_tag_set tagset;
         struct blk_mq_tag_set admin_tagset;
         u32 __iomem *dbs;
-        struct pci_dev *pci_dev;
+        struct device *dev;
         struct dma_pool *prp_page_pool;
         struct dma_pool *prp_small_pool;
         int instance;
@@ -92,6 +92,7 @@ struct nvme_dev {
         work_func_t reset_workfn;
         struct work_struct reset_work;
         struct work_struct probe_work;
+        struct work_struct scan_work;
         char name[12];
         char serial[20];
         char model[40];
@@ -146,25 +147,15 @@ static inline u64 nvme_block_nr(struct nvme_ns *ns, sector_t sector)
         return (sector >> (ns->lba_shift - 9));
 }
 
-/**
- * nvme_free_iod - frees an nvme_iod
- * @dev: The device that the I/O was submitted to
- * @iod: The memory to free
- */
-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);
-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_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,
-                                                        dma_addr_t dma_addr);
+int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
+                void *buf, unsigned bufflen);
+int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,
+                void *buffer, void __user *ubuffer, unsigned bufflen,
+                u32 *result, unsigned timeout);
+int nvme_identify_ctrl(struct nvme_dev *dev, struct nvme_id_ctrl **id);
+int nvme_identify_ns(struct nvme_dev *dev, unsigned nsid,
+                struct nvme_id_ns **id);
+int nvme_get_log_page(struct nvme_dev *dev, struct nvme_smart_log **log);
 int nvme_get_features(struct nvme_dev *dev, unsigned fid, unsigned nsid,
                         dma_addr_t dma_addr, u32 *result);
 int nvme_set_features(struct nvme_dev *dev, unsigned fid, unsigned dword11,
diff --git a/include/linux/of.h b/include/linux/of.h
index b871ff9d81d7..edc068d19c79 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -120,6 +120,12 @@ extern struct device_node *of_aliases;
 extern struct device_node *of_stdout;
 extern raw_spinlock_t devtree_lock;
 
+/* flag descriptions (need to be visible even when !CONFIG_OF) */
+#define OF_DYNAMIC      1 /* node and properties were allocated via kmalloc */
+#define OF_DETACHED     2 /* node has been detached from the device tree */
+#define OF_POPULATED    3 /* device already created for the node */
+#define OF_POPULATED_BUS        4 /* of_platform_populate recursed to children of this node */
+
 #ifdef CONFIG_OF
 void of_core_init(void);
 
@@ -128,7 +134,7 @@ 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)
+static inline struct device_node *to_of_node(struct fwnode_handle *fwnode)
 {
         return fwnode ? container_of(fwnode, struct device_node, fwnode) : NULL;
 }
@@ -219,12 +225,6 @@ static inline unsigned long of_read_ulong(const __be32 *cell, int size)
 #define of_node_cmp(s1, s2)             strcasecmp((s1), (s2))
 #endif
 
-/* flag descriptions */
-#define OF_DYNAMIC      1 /* node and properties were allocated via kmalloc */
-#define OF_DETACHED     2 /* node has been detached from the device tree */
-#define OF_POPULATED    3 /* device already created for the node */
-#define OF_POPULATED_BUS        4 /* of_platform_populate recursed to children of this node */
-
 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
 
@@ -387,7 +387,7 @@ static inline bool is_of_node(struct fwnode_handle *fwnode)
         return false;
 }
 
-static inline struct device_node *of_node(struct fwnode_handle *fwnode)
+static inline struct device_node *to_of_node(struct fwnode_handle *fwnode)
 {
         return NULL;
 }
@@ -428,6 +428,11 @@ static inline struct device_node *of_find_node_opts_by_path(const char *path,
         return NULL;
 }
 
+static inline struct device_node *of_find_node_by_phandle(phandle handle)
+{
+        return NULL;
+}
+
 static inline struct device_node *of_get_parent(const struct device_node *node)
 {
         return NULL;
@@ -673,7 +678,10 @@ static inline void of_property_clear_flag(struct property *p, unsigned long flag
 #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
 extern int of_node_to_nid(struct device_node *np);
 #else
-static inline int of_node_to_nid(struct device_node *device) { return 0; }
+static inline int of_node_to_nid(struct device_node *device)
+{
+        return NUMA_NO_NODE;
+}
 #endif
 
 static inline struct device_node *of_find_matching_node(
@@ -821,7 +829,7 @@ static inline int of_property_read_string_index(struct device_node *np,
  * @propname:   name of the property to be searched.
  *
  * Search for a property in a device node.
- * Returns true if the property exist false otherwise.
+ * Returns true if the property exists false otherwise.
  */
 static inline bool of_property_read_bool(const struct device_node *np,
                                          const char *propname)
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
index 22801b10cef5..cc7dd687a89d 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -33,6 +33,8 @@ extern int of_device_add(struct platform_device *pdev);
 extern int of_device_register(struct platform_device *ofdev);
 extern void of_device_unregister(struct platform_device *ofdev);
 
+extern const void *of_device_get_match_data(const struct device *dev);
+
 extern ssize_t of_device_get_modalias(struct device *dev,
                                         char *str, ssize_t len);
 
@@ -57,7 +59,7 @@ void of_dma_configure(struct device *dev, struct device_node *np);
 #else /* CONFIG_OF */
 
 static inline int of_driver_match_device(struct device *dev,
-                                         struct device_driver *drv)
+                                         const struct device_driver *drv)
 {
         return 0;
 }
@@ -65,6 +67,11 @@ static inline int of_driver_match_device(struct device *dev,
 static inline void of_device_uevent(struct device *dev,
                         struct kobj_uevent_env *env) { }
 
+static inline const void *of_device_get_match_data(const struct device *dev)
+{
+        return NULL;
+}
+
 static inline int of_device_get_modalias(struct device *dev,
                                    char *str, ssize_t len)
 {
diff --git a/include/linux/of_dma.h b/include/linux/of_dma.h
index 56bc026c143f..98ba7525929e 100644
--- a/include/linux/of_dma.h
+++ b/include/linux/of_dma.h
@@ -23,6 +23,9 @@ struct of_dma {
         struct device_node      *of_node;
         struct dma_chan         *(*of_dma_xlate)
                                 (struct of_phandle_args *, struct of_dma *);
+        void                    *(*of_dma_route_allocate)
+                                (struct of_phandle_args *, struct of_dma *);
+        struct dma_router       *dma_router;
         void                    *of_dma_data;
 };
 
@@ -37,12 +40,20 @@ extern int of_dma_controller_register(struct device_node *np,
                 (struct of_phandle_args *, struct of_dma *),
                 void *data);
 extern void of_dma_controller_free(struct device_node *np);
+
+extern int of_dma_router_register(struct device_node *np,
+                void *(*of_dma_route_allocate)
+                (struct of_phandle_args *, struct of_dma *),
+                struct dma_router *dma_router);
+#define of_dma_router_free of_dma_controller_free
+
 extern struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                                                      const char *name);
 extern struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec,
                 struct of_dma *ofdma);
 extern struct dma_chan *of_dma_xlate_by_chan_id(struct of_phandle_args *dma_spec,
                 struct of_dma *ofdma);
+
 #else
 static inline int of_dma_controller_register(struct device_node *np,
                 struct dma_chan *(*of_dma_xlate)
@@ -56,6 +67,16 @@ static inline void of_dma_controller_free(struct device_node *np)
 {
 }
 
+static inline int of_dma_router_register(struct device_node *np,
+                void *(*of_dma_route_allocate)
+                (struct of_phandle_args *, struct of_dma *),
+                struct dma_router *dma_router)
+{
+        return -ENODEV;
+}
+
+#define of_dma_router_free of_dma_controller_free
+
 static inline struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
                                                      const char *name)
 {
diff --git a/include/linux/of_fdt.h b/include/linux/of_fdt.h
index 587ee507965d..df9ef3801812 100644
--- a/include/linux/of_fdt.h
+++ b/include/linux/of_fdt.h
@@ -37,7 +37,7 @@ extern bool of_fdt_is_big_endian(const void *blob,
                                  unsigned long node);
 extern int of_fdt_match(const void *blob, unsigned long node,
                         const char *const *compat);
-extern void of_fdt_unflatten_tree(unsigned long *blob,
+extern void of_fdt_unflatten_tree(const unsigned long *blob,
                                struct device_node **mynodes);
 
 /* TBD: Temporary export of fdt globals - remove when code fully merged */
@@ -64,6 +64,7 @@ extern int early_init_dt_scan_chosen(unsigned long node, const char *uname,
 extern int early_init_dt_scan_memory(unsigned long node, const char *uname,
                                      int depth, void *data);
 extern void early_init_fdt_scan_reserved_mem(void);
+extern void early_init_fdt_reserve_self(void);
 extern void early_init_dt_add_memory_arch(u64 base, u64 size);
 extern int early_init_dt_reserve_memory_arch(phys_addr_t base, phys_addr_t size,
                                              bool no_map);
@@ -91,6 +92,7 @@ extern u64 fdt_translate_address(const void *blob, int node_offset);
 extern void of_fdt_limit_memory(int limit);
 #else /* CONFIG_OF_FLATTREE */
 static inline void early_init_fdt_scan_reserved_mem(void) {}
+static inline void early_init_fdt_reserve_self(void) {}
 static inline const char *of_flat_dt_get_machine_name(void) { return NULL; }
 static inline void unflatten_device_tree(void) {}
 static inline void unflatten_and_copy_device_tree(void) {}
diff --git a/include/linux/of_graph.h b/include/linux/of_graph.h
index 7bc92e050608..f8bcd0e21a26 100644
--- a/include/linux/of_graph.h
+++ b/include/linux/of_graph.h
@@ -45,6 +45,8 @@ int of_graph_parse_endpoint(const struct device_node *node,
 struct device_node *of_graph_get_port_by_id(struct device_node *node, u32 id);
 struct device_node *of_graph_get_next_endpoint(const struct device_node *parent,
                                         struct device_node *previous);
+struct device_node *of_graph_get_endpoint_by_regs(
+                const struct device_node *parent, int port_reg, int reg);
 struct device_node *of_graph_get_remote_port_parent(
                                         const struct device_node *node);
 struct device_node *of_graph_get_remote_port(const struct device_node *node);
@@ -69,6 +71,12 @@ static inline struct device_node *of_graph_get_next_endpoint(
         return NULL;
 }
 
+static inline struct device_node *of_graph_get_endpoint_by_regs(
+                const struct device_node *parent, int port_reg, int reg)
+{
+        return NULL;
+}
+
 static inline struct device_node *of_graph_get_remote_port_parent(
                                         const struct device_node *node)
 {
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 44b2f6f7bbd8..7deecb7bca5e 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -32,6 +32,8 @@ enum oom_scan_t {
 /* Thread is the potential origin of an oom condition; kill first on oom */
 #define OOM_FLAG_ORIGIN         ((__force oom_flags_t)0x1)
 
+extern struct mutex oom_lock;
+
 static inline void set_current_oom_origin(void)
 {
         current->signal->oom_flags |= OOM_FLAG_ORIGIN;
@@ -47,9 +49,7 @@ static inline bool oom_task_origin(const struct task_struct *p)
         return !!(p->signal->oom_flags & OOM_FLAG_ORIGIN);
 }
 
-extern void mark_tsk_oom_victim(struct task_struct *tsk);
-
-extern void unmark_oom_victim(void);
+extern void mark_oom_victim(struct task_struct *tsk);
 
 extern unsigned long oom_badness(struct task_struct *p,
                 struct mem_cgroup *memcg, const nodemask_t *nodemask,
@@ -62,9 +62,6 @@ extern void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
                              struct mem_cgroup *memcg, nodemask_t *nodemask,
                              const char *message);
 
-extern bool oom_zonelist_trylock(struct zonelist *zonelist, gfp_t gfp_flags);
-extern void oom_zonelist_unlock(struct zonelist *zonelist, gfp_t gfp_flags);
-
 extern void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask,
                                int order, const nodemask_t *nodemask,
                                struct mem_cgroup *memcg);
@@ -75,6 +72,9 @@ extern enum oom_scan_t oom_scan_process_thread(struct task_struct *task,
 
 extern bool out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
                 int order, nodemask_t *mask, bool force_kill);
+
+extern void exit_oom_victim(void);
+
 extern int register_oom_notifier(struct notifier_block *nb);
 extern int unregister_oom_notifier(struct notifier_block *nb);
 
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index f34e040b34e9..41c93844fb1d 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -631,15 +631,19 @@ static inline void ClearPageSlabPfmemalloc(struct page *page)
          1 << PG_private | 1 << PG_private_2 | \
          1 << PG_writeback | 1 << PG_reserved | \
          1 << PG_slab    | 1 << PG_swapcache | 1 << PG_active | \
-         1 << PG_unevictable | __PG_MLOCKED | __PG_HWPOISON | \
+         1 << PG_unevictable | __PG_MLOCKED | \
          __PG_COMPOUND_LOCK)
 
 /*
  * Flags checked when a page is prepped for return by the page allocator.
- * Pages being prepped should not have any flags set.  It they are set,
+ * Pages being prepped should not have these flags set.  It they are set,
  * there has been a kernel bug or struct page corruption.
+ *
+ * __PG_HWPOISON is exceptional because it needs to be kept beyond page's
+ * alloc-free cycle to prevent from reusing the page.
  */
-#define PAGE_FLAGS_CHECK_AT_PREP        ((1 << NR_PAGEFLAGS) - 1)
+#define PAGE_FLAGS_CHECK_AT_PREP        \
+        (((1 << NR_PAGEFLAGS) - 1) & ~__PG_HWPOISON)
 
 #define PAGE_FLAGS_PRIVATE                              \
         (1 << PG_private | 1 << PG_private_2)
diff --git a/include/linux/page_owner.h b/include/linux/page_owner.h
index b48c3471c254..cacaabea8a09 100644
--- a/include/linux/page_owner.h
+++ b/include/linux/page_owner.h
@@ -8,6 +8,7 @@ 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);
+extern gfp_t __get_page_owner_gfp(struct page *page);
 
 static inline void reset_page_owner(struct page *page, unsigned int order)
 {
@@ -25,6 +26,14 @@ static inline void set_page_owner(struct page *page,
 
         __set_page_owner(page, order, gfp_mask);
 }
+
+static inline gfp_t get_page_owner_gfp(struct page *page)
+{
+        if (likely(!page_owner_inited))
+                return 0;
+
+        return __get_page_owner_gfp(page);
+}
 #else
 static inline void reset_page_owner(struct page *page, unsigned int order)
 {
@@ -33,6 +42,10 @@ static inline void set_page_owner(struct page *page,
                         unsigned int order, gfp_t gfp_mask)
 {
 }
+static inline gfp_t get_page_owner_gfp(struct page *page)
+{
+        return 0;
+}
 
 #endif /* CONFIG_PAGE_OWNER */
 #endif /* __LINUX_PAGE_OWNER_H */
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 4b3736f7065c..a6c78e00ea96 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -651,7 +651,8 @@ int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
 int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
                                 pgoff_t index, gfp_t gfp_mask);
 extern void delete_from_page_cache(struct page *page);
-extern void __delete_from_page_cache(struct page *page, void *shadow);
+extern void __delete_from_page_cache(struct page *page, void *shadow,
+                                     struct mem_cgroup *memcg);
 int replace_page_cache_page(struct page *old, struct page *new, gfp_t gfp_mask);
 
 /*
@@ -670,4 +671,10 @@ static inline int add_to_page_cache(struct page *page,
         return error;
 }
 
+static inline unsigned long dir_pages(struct inode *inode)
+{
+        return (unsigned long)(inode->i_size + PAGE_CACHE_SIZE - 1) >>
+                               PAGE_CACHE_SHIFT;
+}
+
 #endif /* _LINUX_PAGEMAP_H */
diff --git a/include/linux/parport.h b/include/linux/parport.h
index c22f12547324..58e3c64c6b49 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -13,6 +13,7 @@
 #include <linux/wait.h>
 #include <linux/irqreturn.h>
 #include <linux/semaphore.h>
+#include <linux/device.h>
 #include <asm/ptrace.h>
 #include <uapi/linux/parport.h>
 
@@ -145,6 +146,8 @@ struct pardevice {
         unsigned int flags;
         struct pardevice *next;
         struct pardevice *prev;
+        struct device dev;
+        bool devmodel;
         struct parport_state *state;     /* saved status over preemption */
         wait_queue_head_t wait_q;
         unsigned long int time;
@@ -156,6 +159,8 @@ struct pardevice {
         void * sysctl_table;
 };
 
+#define to_pardevice(n) container_of(n, struct pardevice, dev)
+
 /* IEEE1284 information */
 
 /* IEEE1284 phases. These are exposed to userland through ppdev IOCTL
@@ -195,7 +200,7 @@ struct parport {
                                  * This may unfortulately be null if the
                                  * port has a legacy driver.
                                  */
-
+        struct device bus_dev;  /* to link with the bus */
         struct parport *physport;
                                 /* If this is a non-default mux
                                    parport, i.e. we're a clone of a real
@@ -245,15 +250,26 @@ struct parport {
         struct parport *slaves[3];
 };
 
+#define to_parport_dev(n) container_of(n, struct parport, bus_dev)
+
 #define DEFAULT_SPIN_TIME 500 /* us */
 
 struct parport_driver {
         const char *name;
         void (*attach) (struct parport *);
         void (*detach) (struct parport *);
+        void (*match_port)(struct parport *);
+        int (*probe)(struct pardevice *);
+        struct device_driver driver;
+        bool devmodel;
         struct list_head list;
 };
 
+#define to_parport_driver(n) container_of(n, struct parport_driver, driver)
+
+int parport_bus_init(void);
+void parport_bus_exit(void);
+
 /* parport_register_port registers a new parallel port at the given
    address (if one does not already exist) and returns a pointer to it.
    This entails claiming the I/O region, IRQ and DMA.  NULL is returned
@@ -272,10 +288,20 @@ void parport_announce_port (struct parport *port);
 extern void parport_remove_port(struct parport *port);
 
 /* Register a new high-level driver. */
-extern int parport_register_driver (struct parport_driver *);
+
+int __must_check __parport_register_driver(struct parport_driver *,
+                                           struct module *,
+                                           const char *mod_name);
+/*
+ * parport_register_driver must be a macro so that KBUILD_MODNAME can
+ * be expanded
+ */
+#define parport_register_driver(driver)             \
+        __parport_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 
 /* Unregister a high-level driver. */
 extern void parport_unregister_driver (struct parport_driver *);
+void parport_unregister_driver(struct parport_driver *);
 
 /* If parport_register_driver doesn't fit your needs, perhaps
  * parport_find_xxx does. */
@@ -288,6 +314,15 @@ extern irqreturn_t parport_irq_handler(int irq, void *dev_id);
 /* Reference counting for ports. */
 extern struct parport *parport_get_port (struct parport *);
 extern void parport_put_port (struct parport *);
+void parport_del_port(struct parport *);
+
+struct pardev_cb {
+        int (*preempt)(void *);
+        void (*wakeup)(void *);
+        void *private;
+        void (*irq_func)(void *);
+        unsigned int flags;
+};
 
 /* parport_register_device declares that a device is connected to a
    port, and tells the kernel all it needs to know.
@@ -301,6 +336,10 @@ struct pardevice *parport_register_device(struct parport *port,
                           void (*irq_func)(void *), 
                           int flags, void *handle);
 
+struct pardevice *
+parport_register_dev_model(struct parport *port, const char *name,
+                           const struct pardev_cb *par_dev_cb, int cnt);
+
 /* parport_unregister unlinks a device from the chain. */
 extern void parport_unregister_device(struct pardevice *dev);
 
diff --git a/include/linux/pata_arasan_cf_data.h b/include/linux/pata_arasan_cf_data.h
index 3cc21c9cc1e8..9fade5dd2e86 100644
--- a/include/linux/pata_arasan_cf_data.h
+++ b/include/linux/pata_arasan_cf_data.h
@@ -4,7 +4,7 @@
  * Arasan Compact Flash host controller platform data header file
  *
  * Copyright (C) 2011 ST Microelectronics
- * Viresh Kumar <viresh.linux@gmail.com>
+ * Viresh Kumar <vireshk@kernel.org>
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2. This program is licensed "as is" without any
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index cb63a7b522ef..fcff8f865341 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2330,6 +2330,8 @@
 #define PCI_DEVICE_ID_ALTIMA_AC9100     0x03ea
 #define PCI_DEVICE_ID_ALTIMA_AC1003     0x03eb
 
+#define PCI_VENDOR_ID_CAVIUM            0x177d
+
 #define PCI_VENDOR_ID_BELKIN            0x1799
 #define PCI_DEVICE_ID_BELKIN_F5D7010V7  0x701f
 
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 1b82d44b0a02..2027809433b3 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -300,6 +300,11 @@ struct pmu {
          * Free pmu-private AUX data structures
          */
         void (*free_aux)                (void *aux); /* optional */
+
+        /*
+         * Filter events for PMU-specific reasons.
+         */
+        int (*filter_match)             (struct perf_event *event); /* optional */
 };
 
 /**
@@ -479,7 +484,7 @@ struct perf_event {
         void                            *overflow_handler_context;
 
 #ifdef CONFIG_EVENT_TRACING
-        struct ftrace_event_call        *tp_event;
+        struct trace_event_call         *tp_event;
         struct event_filter             *filter;
 #ifdef CONFIG_FUNCTION_TRACER
         struct ftrace_ops               ftrace_ops;
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 685809835b5c..a26c3f84b8dd 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -181,6 +181,9 @@ struct mii_bus {
         /* PHY addresses to be ignored when probing */
         u32 phy_mask;
 
+        /* PHY addresses to ignore the TA/read failure */
+        u32 phy_ignore_ta_mask;
+
         /*
          * Pointer to an array of interrupts, each PHY's
          * interrupt at the index matching its address
@@ -675,6 +678,17 @@ static inline bool phy_is_internal(struct phy_device *phydev)
 }
 
 /**
+ * phy_interface_is_rgmii - Convenience function for testing if a PHY interface
+ * is RGMII (all variants)
+ * @phydev: the phy_device struct
+ */
+static inline bool phy_interface_is_rgmii(struct phy_device *phydev)
+{
+        return phydev->interface >= PHY_INTERFACE_MODE_RGMII &&
+                phydev->interface <= PHY_INTERFACE_MODE_RGMII_TXID;
+}
+
+/**
  * phy_write_mmd - Convenience function for writing a register
  * on an MMD on a given PHY.
  * @phydev: The phy_device struct
diff --git a/include/linux/phy/phy-sun4i-usb.h b/include/linux/phy/phy-sun4i-usb.h
new file mode 100644
index 000000000000..50aed92ea89c
--- /dev/null
+++ b/include/linux/phy/phy-sun4i-usb.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2015 Hans de Goede <hdegoede@redhat.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 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 PHY_SUN4I_USB_H_
+#define PHY_SUN4I_USB_H_
+
+#include "phy.h"
+
+/**
+ * sun4i_usb_phy_set_squelch_detect() - Enable/disable squelch detect
+ * @phy: reference to a sun4i usb phy
+ * @enabled: wether to enable or disable squelch detect
+ */
+void sun4i_usb_phy_set_squelch_detect(struct phy *phy, bool enabled);
+
+#endif
diff --git a/include/linux/phy/phy.h b/include/linux/phy/phy.h
index a0197fa1b116..8cf05e341cff 100644
--- a/include/linux/phy/phy.h
+++ b/include/linux/phy/phy.h
@@ -133,6 +133,8 @@ struct phy *devm_phy_get(struct device *dev, const char *string);
 struct phy *devm_phy_optional_get(struct device *dev, const char *string);
 struct phy *devm_of_phy_get(struct device *dev, struct device_node *np,
                             const char *con_id);
+struct phy *devm_of_phy_get_by_index(struct device *dev, struct device_node *np,
+                                     int index);
 void phy_put(struct phy *phy);
 void devm_phy_put(struct device *dev, struct phy *phy);
 struct phy *of_phy_get(struct device_node *np, const char *con_id);
@@ -261,6 +263,13 @@ static inline struct phy *devm_of_phy_get(struct device *dev,
         return ERR_PTR(-ENOSYS);
 }
 
+static inline struct phy *devm_of_phy_get_by_index(struct device *dev,
+                                                   struct device_node *np,
+                                                   int index)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
 static inline void phy_put(struct phy *phy)
 {
 }
diff --git a/include/linux/pinctrl/consumer.h b/include/linux/pinctrl/consumer.h
index 18eccefea06e..d7e5d608faa7 100644
--- a/include/linux/pinctrl/consumer.h
+++ b/include/linux/pinctrl/consumer.h
@@ -142,7 +142,7 @@ static inline struct pinctrl * __must_check pinctrl_get_select(
         s = pinctrl_lookup_state(p, name);
         if (IS_ERR(s)) {
                 pinctrl_put(p);
-                return ERR_PTR(PTR_ERR(s));
+                return ERR_CAST(s);
         }
 
         ret = pinctrl_select_state(p, s);
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index 66e4697516de..9ba59fcba549 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -127,7 +127,7 @@ struct pinctrl_ops {
  */
 struct pinctrl_desc {
         const char *name;
-        struct pinctrl_pin_desc const *pins;
+        const struct pinctrl_pin_desc *pins;
         unsigned int npins;
         const struct pinctrl_ops *pctlops;
         const struct pinmux_ops *pmxops;
diff --git a/include/linux/pinctrl/pinmux.h b/include/linux/pinctrl/pinmux.h
index 511bda9ed4bf..ace60d775b20 100644
--- a/include/linux/pinctrl/pinmux.h
+++ b/include/linux/pinctrl/pinmux.h
@@ -56,6 +56,9 @@ struct pinctrl_dev;
  *      depending on whether the GPIO is configured as input or output,
  *      a direction selector function may be implemented as a backing
  *      to the GPIO controllers that need pin muxing.
+ * @strict: do not allow simultaneous use of the same pin for GPIO and another
+ *      function. Check both gpio_owner and mux_owner strictly before approving
+ *      the pin request.
  */
 struct pinmux_ops {
         int (*request) (struct pinctrl_dev *pctldev, unsigned offset);
@@ -66,7 +69,7 @@ struct pinmux_ops {
         int (*get_function_groups) (struct pinctrl_dev *pctldev,
                                   unsigned selector,
                                   const char * const **groups,
-                                  unsigned * const num_groups);
+                                  unsigned *num_groups);
         int (*set_mux) (struct pinctrl_dev *pctldev, unsigned func_selector,
                         unsigned group_selector);
         int (*gpio_request_enable) (struct pinctrl_dev *pctldev,
@@ -79,6 +82,7 @@ struct pinmux_ops {
                                    struct pinctrl_gpio_range *range,
                                    unsigned offset,
                                    bool input);
+        bool strict;
 };
 
 #endif /* CONFIG_PINMUX */
diff --git a/include/linux/platform_data/dma-rcar-audmapp.h b/include/linux/platform_data/dma-rcar-audmapp.h
deleted file mode 100644
index 471fffebbeb4..000000000000
--- a/include/linux/platform_data/dma-rcar-audmapp.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * This is for Renesas R-Car Audio-DMAC-peri-peri.
- *
- * Copyright (C) 2014 Renesas Electronics Corporation
- * Copyright (C) 2014 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
- *
- * This file is based on the include/linux/sh_dma.h
- *
- * Header for the new SH dmaengine driver
- *
- * Copyright (C) 2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
- *
- * 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 SH_AUDMAPP_H
-#define SH_AUDMAPP_H
-
-#include <linux/dmaengine.h>
-
-struct audmapp_slave_config {
-        int             slave_id;
-        dma_addr_t      src;
-        dma_addr_t      dst;
-        u32             chcr;
-};
-
-struct audmapp_pdata {
-        struct audmapp_slave_config *slave;
-        int slave_num;
-};
-
-#endif /* SH_AUDMAPP_H */
diff --git a/include/linux/platform_data/gpio-ath79.h b/include/linux/platform_data/gpio-ath79.h
new file mode 100644
index 000000000000..88b0db7bee74
--- /dev/null
+++ b/include/linux/platform_data/gpio-ath79.h
@@ -0,0 +1,19 @@
+/*
+ *  Atheros AR7XXX/AR9XXX GPIO controller platform data
+ *
+ * Copyright (C) 2015 Alban Bedel <albeu@free.fr>
+ *
+ * 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_PLATFORM_DATA_GPIO_ATH79_H
+#define __LINUX_PLATFORM_DATA_GPIO_ATH79_H
+
+struct ath79_gpio_platform_data {
+        unsigned ngpios;
+        bool oe_inverted;
+};
+
+#endif
diff --git a/include/linux/platform_data/keyboard-spear.h b/include/linux/platform_data/keyboard-spear.h
index 9248e3a7e333..5e3ff653900c 100644
--- a/include/linux/platform_data/keyboard-spear.h
+++ b/include/linux/platform_data/keyboard-spear.h
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2010 ST Microelectronics
- * Rajeev Kumar<rajeev-dlh.kumar@st.com>
+ * Rajeev Kumar <rajeevkumar.linux@gmail.com>
  *
  * This file is licensed under the terms of the GNU General Public
  * License version 2. This program is licensed "as is" without any
diff --git a/include/linux/platform_data/macb.h b/include/linux/platform_data/macb.h
index 044a124bfbbc..21b15f6fee25 100644
--- a/include/linux/platform_data/macb.h
+++ b/include/linux/platform_data/macb.h
@@ -8,11 +8,19 @@
 #ifndef __MACB_PDATA_H__
 #define __MACB_PDATA_H__
 
+/**
+ * struct macb_platform_data - platform data for MACB Ethernet
+ * @phy_mask:           phy mask passed when register the MDIO bus
+ *                      within the driver
+ * @phy_irq_pin:        PHY IRQ
+ * @is_rmii:            using RMII interface?
+ * @rev_eth_addr:       reverse Ethernet address byte order
+ */
 struct macb_platform_data {
         u32             phy_mask;
-        int             phy_irq_pin;    /* PHY IRQ */
-        u8              is_rmii;        /* using RMII interface? */
-        u8              rev_eth_addr;   /* reverse Ethernet address byte order */
+        int             phy_irq_pin;
+        u8              is_rmii;
+        u8              rev_eth_addr;
 };
 
 #endif /* __MACB_PDATA_H__ */
diff --git a/include/linux/platform_data/mmc-esdhc-imx.h b/include/linux/platform_data/mmc-esdhc-imx.h
index 75f70f6ac137..e1571efa3f2b 100644
--- a/include/linux/platform_data/mmc-esdhc-imx.h
+++ b/include/linux/platform_data/mmc-esdhc-imx.h
@@ -43,7 +43,6 @@ struct esdhc_platform_data {
         enum wp_types wp_type;
         enum cd_types cd_type;
         int max_bus_width;
-        unsigned int f_max;
         bool support_vsel;
         unsigned int delay_line;
 };
diff --git a/include/linux/platform_data/nfcmrvl.h b/include/linux/platform_data/nfcmrvl.h
new file mode 100644
index 000000000000..ac91707dabcb
--- /dev/null
+++ b/include/linux/platform_data/nfcmrvl.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015, Marvell International Ltd.
+ *
+ * This software file (the "File") is distributed by Marvell International
+ * Ltd. under the terms of the GNU General Public License Version 2, June 1991
+ * (the "License").  You may use, redistribute and/or modify this File in
+ * accordance with the terms and conditions of the License, a copy of which
+ * is available on the worldwide web at
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ *
+ * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
+ * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
+ * this warranty disclaimer.
+ */
+
+#ifndef _NFCMRVL_PTF_H_
+#define _NFCMRVL_PTF_H_
+
+struct nfcmrvl_platform_data {
+        /*
+         * Generic
+         */
+
+        /* GPIO that is wired to RESET_N signal */
+        unsigned int reset_n_io;
+        /* Tell if transport is muxed in HCI one */
+        unsigned int hci_muxed;
+
+        /*
+         * UART specific
+         */
+
+        /* Tell if UART needs flow control at init */
+        unsigned int flow_control;
+        /* Tell if firmware supports break control for power management */
+        unsigned int break_control;
+};
+
+#endif /* _NFCMRVL_PTF_H_ */
diff --git a/include/linux/platform_data/st21nfcb.h b/include/linux/platform_data/st-nci.h
index b023373d9874..d9d400a297bd 100644
--- a/include/linux/platform_data/st21nfcb.h
+++ b/include/linux/platform_data/st-nci.h
@@ -1,7 +1,7 @@
 /*
- * Driver include for the ST21NFCB NFC chip.
+ * Driver include for ST NCI NFC chip family.
  *
- * Copyright (C) 2014  STMicroelectronics SAS. All rights reserved.
+ * Copyright (C) 2014-2015  STMicroelectronics SAS. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -16,14 +16,14 @@
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef _ST21NFCB_NCI_H_
-#define _ST21NFCB_NCI_H_
+#ifndef _ST_NCI_H_
+#define _ST_NCI_H_
 
-#define ST21NFCB_NCI_DRIVER_NAME "st21nfcb_nci"
+#define ST_NCI_DRIVER_NAME "st_nci"
 
-struct st21nfcb_nfc_platform_data {
+struct st_nci_nfc_platform_data {
         unsigned int gpio_reset;
         unsigned int irq_polarity;
 };
 
-#endif /* _ST21NFCB_NCI_H_ */
+#endif /* _ST_NCI_H_ */
diff --git a/include/linux/platform_data/st_nci.h b/include/linux/platform_data/st_nci.h
new file mode 100644
index 000000000000..d9d400a297bd
--- /dev/null
+++ b/include/linux/platform_data/st_nci.h
@@ -0,0 +1,29 @@
+/*
+ * Driver include for ST NCI NFC chip family.
+ *
+ * Copyright (C) 2014-2015  STMicroelectronics SAS. All rights reserved.
+ *
+ * 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 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 _ST_NCI_H_
+#define _ST_NCI_H_
+
+#define ST_NCI_DRIVER_NAME "st_nci"
+
+struct st_nci_nfc_platform_data {
+        unsigned int gpio_reset;
+        unsigned int irq_polarity;
+};
+
+#endif /* _ST_NCI_H_ */
diff --git a/include/linux/platform_data/usb-rcar-gen2-phy.h b/include/linux/platform_data/usb-rcar-gen2-phy.h
deleted file mode 100644
index dd3ba46c0d90..000000000000
--- a/include/linux/platform_data/usb-rcar-gen2-phy.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2013 Renesas Solutions Corp.
- * Copyright (C) 2013 Cogent Embedded, Inc.
- *
- * 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 __USB_RCAR_GEN2_PHY_H
-#define __USB_RCAR_GEN2_PHY_H
-
-#include <linux/types.h>
-
-struct rcar_gen2_phy_platform_data {
-        /* USB channel 0 configuration */
-        bool chan0_pci:1;       /* true: PCI USB host 0, false: USBHS */
-        /* USB channel 2 configuration */
-        bool chan2_pci:1;       /* true: PCI USB host 2, false: USBSS */
-};
-
-#endif
diff --git a/include/linux/platform_data/video-msm_fb.h b/include/linux/platform_data/video-msm_fb.h
deleted file mode 100644
index 31449be3eadb..000000000000
--- a/include/linux/platform_data/video-msm_fb.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Internal shared definitions for various MSM framebuffer parts.
- *
- * Copyright (C) 2007 Google Incorporated
- *
- * 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 _MSM_FB_H_
-#define _MSM_FB_H_
-
-#include <linux/device.h>
-
-struct mddi_info;
-
-struct msm_fb_data {
-        int xres;       /* x resolution in pixels */
-        int yres;       /* y resolution in pixels */
-        int width;      /* disply width in mm */
-        int height;     /* display height in mm */
-        unsigned output_format;
-};
-
-struct msmfb_callback {
-        void (*func)(struct msmfb_callback *);
-};
-
-enum {
-        MSM_MDDI_PMDH_INTERFACE,
-        MSM_MDDI_EMDH_INTERFACE,
-        MSM_EBI2_INTERFACE,
-};
-
-#define MSMFB_CAP_PARTIAL_UPDATES       (1 << 0)
-
-struct msm_panel_data {
-        /* turns off the fb memory */
-        int (*suspend)(struct msm_panel_data *);
-        /* turns on the fb memory */
-        int (*resume)(struct msm_panel_data *);
-        /* turns off the panel */
-        int (*blank)(struct msm_panel_data *);
-        /* turns on the panel */
-        int (*unblank)(struct msm_panel_data *);
-        void (*wait_vsync)(struct msm_panel_data *);
-        void (*request_vsync)(struct msm_panel_data *, struct msmfb_callback *);
-        void (*clear_vsync)(struct msm_panel_data *);
-        /* from the enum above */
-        unsigned interface_type;
-        /* data to be passed to the fb driver */
-        struct msm_fb_data *fb_data;
-
-        /* capabilities supported by the panel */
-        uint32_t caps;
-};
-
-struct msm_mddi_client_data {
-        void (*suspend)(struct msm_mddi_client_data *);
-        void (*resume)(struct msm_mddi_client_data *);
-        void (*activate_link)(struct msm_mddi_client_data *);
-        void (*remote_write)(struct msm_mddi_client_data *, uint32_t val,
-                             uint32_t reg);
-        uint32_t (*remote_read)(struct msm_mddi_client_data *, uint32_t reg);
-        void (*auto_hibernate)(struct msm_mddi_client_data *, int);
-        /* custom data that needs to be passed from the board file to a 
-         * particular client */
-        void *private_client_data;
-        struct resource *fb_resource;
-        /* from the list above */
-        unsigned interface_type;
-};
-
-struct msm_mddi_platform_data {
-        unsigned int clk_rate;
-        void (*power_client)(struct msm_mddi_client_data *, int on);
-
-        /* fixup the mfr name, product id */
-        void (*fixup)(uint16_t *mfr_name, uint16_t *product_id);
-
-        struct resource *fb_resource; /*optional*/
-        /* number of clients in the list that follows */
-        int num_clients;
-        /* array of client information of clients */
-        struct {
-                unsigned product_id; /* mfr id in top 16 bits, product id
-                                      * in lower 16 bits
-                                      */
-                char *name;     /* the device name will be the platform
-                                 * device name registered for the client,
-                                 * it should match the name of the associated
-                                 * driver
-                                 */
-                unsigned id;    /* id for mddi client device node, will also
-                                 * be used as device id of panel devices, if
-                                 * the client device will have multiple panels
-                                 * space must be left here for them
-                                 */
-                void *client_data;      /* required private client data */
-                unsigned int clk_rate;  /* optional: if the client requires a
-                                        * different mddi clk rate
-                                        */
-        } client_platform_data[];
-};
-
-struct mdp_blit_req;
-struct fb_info;
-struct mdp_device {
-        struct device dev;
-        void (*dma)(struct mdp_device *mpd, uint32_t addr,
-                    uint32_t stride, uint32_t w, uint32_t h, uint32_t x,
-                    uint32_t y, struct msmfb_callback *callback, int interface);
-        void (*dma_wait)(struct mdp_device *mdp);
-        int (*blit)(struct mdp_device *mdp, struct fb_info *fb,
-                    struct mdp_blit_req *req);
-        void (*set_grp_disp)(struct mdp_device *mdp, uint32_t disp_id);
-};
-
-struct class_interface;
-int register_mdp_client(struct class_interface *class_intf);
-
-/**** private client data structs go below this line ***/
-
-struct msm_mddi_bridge_platform_data {
-        /* from board file */
-        int (*init)(struct msm_mddi_bridge_platform_data *,
-                    struct msm_mddi_client_data *);
-        int (*uninit)(struct msm_mddi_bridge_platform_data *,
-                      struct msm_mddi_client_data *);
-        /* passed to panel for use by the fb driver */
-        int (*blank)(struct msm_mddi_bridge_platform_data *,
-                     struct msm_mddi_client_data *);
-        int (*unblank)(struct msm_mddi_bridge_platform_data *,
-                       struct msm_mddi_client_data *);
-        struct msm_fb_data fb_data;
-};
-
-
-
-#endif
diff --git a/include/linux/platform_data/wkup_m3.h b/include/linux/platform_data/wkup_m3.h
new file mode 100644
index 000000000000..3f1d77effd71
--- /dev/null
+++ b/include/linux/platform_data/wkup_m3.h
@@ -0,0 +1,30 @@
+/*
+ * TI Wakeup M3 remote processor platform data
+ *
+ * Copyright (C) 2014-2015 Texas Instruments, Inc.
+ *
+ * Dave Gerlach <d-gerlach@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 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_PLATFORM_DATA_WKUP_M3_H
+#define _LINUX_PLATFORM_DATA_WKUP_M3_H
+
+struct platform_device;
+
+struct wkup_m3_platform_data {
+        const char *reset_name;
+
+        int (*assert_reset)(struct platform_device *pdev, const char *name);
+        int (*deassert_reset)(struct platform_device *pdev, const char *name);
+};
+
+#endif /* _LINUX_PLATFORM_DATA_WKUP_M3_H */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 58f1e75ba105..bba08f44cc97 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -222,6 +222,15 @@ static inline void platform_set_drvdata(struct platform_device *pdev,
         module_driver(__platform_driver, platform_driver_register, \
                         platform_driver_unregister)
 
+/* builtin_platform_driver() - Helper macro for builtin drivers that
+ * don't do anything special in driver init.  This eliminates some
+ * boilerplate.  Each driver may only use this macro once, and
+ * calling it replaces device_initcall().  Note this is meant to be
+ * a parallel of module_platform_driver() above, but w/o _exit stuff.
+ */
+#define builtin_platform_driver(__platform_driver) \
+        builtin_driver(__platform_driver, platform_driver_register)
+
 /* module_platform_driver_probe() - Helper macro for drivers that don't do
  * anything special in module init/exit.  This eliminates a lot of
  * boilerplate.  Each module may only use this macro once, and
@@ -240,6 +249,20 @@ static void __exit __platform_driver##_exit(void) \
 } \
 module_exit(__platform_driver##_exit);
 
+/* builtin_platform_driver_probe() - Helper macro for drivers that don't do
+ * anything special in device init.  This eliminates some boilerplate.  Each
+ * driver may only use this macro once, and using it replaces device_initcall.
+ * This is meant to be a parallel of module_platform_driver_probe above, but
+ * without the __exit parts.
+ */
+#define builtin_platform_driver_probe(__platform_driver, __platform_probe) \
+static int __init __platform_driver##_init(void) \
+{ \
+        return platform_driver_probe(&(__platform_driver), \
+                                     __platform_probe);    \
+} \
+device_initcall(__platform_driver##_init); \
+
 #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(
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 2d29c64f8fb1..35d599e7250d 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -342,6 +342,18 @@ struct dev_pm_ops {
 #define SET_LATE_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
 #endif
 
+#ifdef CONFIG_PM_SLEEP
+#define SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
+        .suspend_noirq = suspend_fn, \
+        .resume_noirq = resume_fn, \
+        .freeze_noirq = suspend_fn, \
+        .thaw_noirq = resume_fn, \
+        .poweroff_noirq = suspend_fn, \
+        .restore_noirq = resume_fn,
+#else
+#define SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
+#endif
+
 #ifdef CONFIG_PM
 #define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
         .runtime_suspend = suspend_fn, \
@@ -529,6 +541,7 @@ enum rpm_request {
 };
 
 struct wakeup_source;
+struct wake_irq;
 struct pm_domain_data;
 
 struct pm_subsys_data {
@@ -568,6 +581,7 @@ struct dev_pm_info {
         unsigned long           timer_expires;
         struct work_struct      work;
         wait_queue_head_t       wait_queue;
+        struct wake_irq         *wakeirq;
         atomic_t                usage_count;
         atomic_t                child_count;
         unsigned int            disable_depth:3;
diff --git a/include/linux/pm_clock.h b/include/linux/pm_clock.h
index 0b0039634410..25266c600021 100644
--- a/include/linux/pm_clock.h
+++ b/include/linux/pm_clock.h
@@ -20,6 +20,16 @@ struct pm_clk_notifier_block {
 
 struct clk;
 
+#ifdef CONFIG_PM
+extern int pm_clk_runtime_suspend(struct device *dev);
+extern int pm_clk_runtime_resume(struct device *dev);
+#define USE_PM_CLK_RUNTIME_OPS \
+        .runtime_suspend = pm_clk_runtime_suspend, \
+        .runtime_resume = pm_clk_runtime_resume,
+#else
+#define USE_PM_CLK_RUNTIME_OPS
+#endif
+
 #ifdef CONFIG_PM_CLK
 static inline bool pm_clk_no_clocks(struct device *dev)
 {
diff --git a/include/linux/pm_wakeirq.h b/include/linux/pm_wakeirq.h
new file mode 100644
index 000000000000..cd5b62db9084
--- /dev/null
+++ b/include/linux/pm_wakeirq.h
@@ -0,0 +1,51 @@
+/*
+ * pm_wakeirq.h - Device wakeirq helper functions
+ *
+ * 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 "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 _LINUX_PM_WAKEIRQ_H
+#define _LINUX_PM_WAKEIRQ_H
+
+#ifdef CONFIG_PM
+
+extern int dev_pm_set_wake_irq(struct device *dev, int irq);
+extern int dev_pm_set_dedicated_wake_irq(struct device *dev,
+                                         int irq);
+extern void dev_pm_clear_wake_irq(struct device *dev);
+extern void dev_pm_enable_wake_irq(struct device *dev);
+extern void dev_pm_disable_wake_irq(struct device *dev);
+
+#else   /* !CONFIG_PM */
+
+static inline int dev_pm_set_wake_irq(struct device *dev, int irq)
+{
+        return 0;
+}
+
+static inline int dev_pm_set_dedicated_wake_irq(struct device *dev, int irq)
+{
+        return 0;
+}
+
+static inline void dev_pm_clear_wake_irq(struct device *dev)
+{
+}
+
+static inline void dev_pm_enable_wake_irq(struct device *dev)
+{
+}
+
+static inline void dev_pm_disable_wake_irq(struct device *dev)
+{
+}
+
+#endif  /* CONFIG_PM */
+#endif  /* _LINUX_PM_WAKEIRQ_H */
diff --git a/include/linux/pm_wakeup.h b/include/linux/pm_wakeup.h
index a0f70808d7f4..a3447932df1f 100644
--- a/include/linux/pm_wakeup.h
+++ b/include/linux/pm_wakeup.h
@@ -28,9 +28,17 @@
 
 #include <linux/types.h>
 
+struct wake_irq;
+
 /**
  * struct wakeup_source - Representation of wakeup sources
  *
+ * @name: Name of the wakeup source
+ * @entry: Wakeup source list entry
+ * @lock: Wakeup source lock
+ * @wakeirq: Optional device specific wakeirq
+ * @timer: Wakeup timer list
+ * @timer_expires: Wakeup timer expiration
  * @total_time: Total time this wakeup source has been active.
  * @max_time: Maximum time this wakeup source has been continuously active.
  * @last_time: Monotonic clock when the wakeup source's was touched last time.
@@ -47,6 +55,7 @@ struct wakeup_source {
         const char              *name;
         struct list_head        entry;
         spinlock_t              lock;
+        struct wake_irq         *wakeirq;
         struct timer_list       timer;
         unsigned long           timer_expires;
         ktime_t total_time;
diff --git a/include/linux/pmem.h b/include/linux/pmem.h
new file mode 100644
index 000000000000..d2114045a6c4
--- /dev/null
+++ b/include/linux/pmem.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright(c) 2015 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * 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 __PMEM_H__
+#define __PMEM_H__
+
+#include <linux/io.h>
+
+#ifdef CONFIG_ARCH_HAS_PMEM_API
+#include <asm/cacheflush.h>
+#else
+static inline void arch_wmb_pmem(void)
+{
+        BUG();
+}
+
+static inline bool __arch_has_wmb_pmem(void)
+{
+        return false;
+}
+
+static inline void __pmem *arch_memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        return NULL;
+}
+
+static inline void arch_memcpy_to_pmem(void __pmem *dst, const void *src,
+                size_t n)
+{
+        BUG();
+}
+#endif
+
+/*
+ * Architectures that define ARCH_HAS_PMEM_API must provide
+ * implementations for arch_memremap_pmem(), arch_memcpy_to_pmem(),
+ * arch_wmb_pmem(), and __arch_has_wmb_pmem().
+ */
+
+static inline void memcpy_from_pmem(void *dst, void __pmem const *src, size_t size)
+{
+        memcpy(dst, (void __force const *) src, size);
+}
+
+static inline void memunmap_pmem(void __pmem *addr)
+{
+        iounmap((void __force __iomem *) addr);
+}
+
+/**
+ * arch_has_wmb_pmem - true if wmb_pmem() ensures durability
+ *
+ * For a given cpu implementation within an architecture it is possible
+ * that wmb_pmem() resolves to a nop.  In the case this returns
+ * false, pmem api users are unable to ensure durability and may want to
+ * fall back to a different data consistency model, or otherwise notify
+ * the user.
+ */
+static inline bool arch_has_wmb_pmem(void)
+{
+        if (IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API))
+                return __arch_has_wmb_pmem();
+        return false;
+}
+
+static inline bool arch_has_pmem_api(void)
+{
+        return IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API) && arch_has_wmb_pmem();
+}
+
+/*
+ * These defaults seek to offer decent performance and minimize the
+ * window between i/o completion and writes being durable on media.
+ * However, it is undefined / architecture specific whether
+ * default_memremap_pmem + default_memcpy_to_pmem is sufficient for
+ * making data durable relative to i/o completion.
+ */
+static void default_memcpy_to_pmem(void __pmem *dst, const void *src,
+                size_t size)
+{
+        memcpy((void __force *) dst, src, size);
+}
+
+static void __pmem *default_memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        return (void __pmem __force *)ioremap_wt(offset, size);
+}
+
+/**
+ * memremap_pmem - map physical persistent memory for pmem api
+ * @offset: physical address of persistent memory
+ * @size: size of the mapping
+ *
+ * Establish a mapping of the architecture specific memory type expected
+ * by memcpy_to_pmem() and wmb_pmem().  For example, it may be
+ * the case that an uncacheable or writethrough mapping is sufficient,
+ * or a writeback mapping provided memcpy_to_pmem() and
+ * wmb_pmem() arrange for the data to be written through the
+ * cache to persistent media.
+ */
+static inline void __pmem *memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        if (arch_has_pmem_api())
+                return arch_memremap_pmem(offset, size);
+        return default_memremap_pmem(offset, size);
+}
+
+/**
+ * memcpy_to_pmem - copy data to persistent memory
+ * @dst: destination buffer for the copy
+ * @src: source buffer for the copy
+ * @n: length of the copy in bytes
+ *
+ * Perform a memory copy that results in the destination of the copy
+ * being effectively evicted from, or never written to, the processor
+ * cache hierarchy after the copy completes.  After memcpy_to_pmem()
+ * data may still reside in cpu or platform buffers, so this operation
+ * must be followed by a wmb_pmem().
+ */
+static inline void memcpy_to_pmem(void __pmem *dst, const void *src, size_t n)
+{
+        if (arch_has_pmem_api())
+                arch_memcpy_to_pmem(dst, src, n);
+        else
+                default_memcpy_to_pmem(dst, src, n);
+}
+
+/**
+ * wmb_pmem - synchronize writes to persistent memory
+ *
+ * After a series of memcpy_to_pmem() operations this drains data from
+ * cpu write buffers and any platform (memory controller) buffers to
+ * ensure that written data is durable on persistent memory media.
+ */
+static inline void wmb_pmem(void)
+{
+        if (arch_has_pmem_api())
+                arch_wmb_pmem();
+}
+#endif /* __PMEM_H__ */
diff --git a/include/linux/power/max17042_battery.h b/include/linux/power/max17042_battery.h
index cf112b4075c8..522757ac9cd4 100644
--- a/include/linux/power/max17042_battery.h
+++ b/include/linux/power/max17042_battery.h
@@ -215,6 +215,10 @@ struct max17042_platform_data {
          * the datasheet although it can be changed by board designers.
          */
         unsigned int r_sns;
+        int         vmin;       /* in millivolts */
+        int         vmax;       /* in millivolts */
+        int         temp_min;   /* in tenths of degree Celsius */
+        int         temp_max;   /* in tenths of degree Celsius */
 };
 
 #endif /* __MAX17042_BATTERY_H_ */
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index 75a1dd8dc56e..ef9f1592185d 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -206,6 +206,11 @@ struct power_supply_desc {
         int (*set_property)(struct power_supply *psy,
                             enum power_supply_property psp,
                             const union power_supply_propval *val);
+        /*
+         * property_is_writeable() will be called during registration
+         * of power supply. If this happens during device probe then it must
+         * not access internal data of device (because probe did not end).
+         */
         int (*property_is_writeable)(struct power_supply *psy,
                                      enum power_supply_property psp);
         void (*external_power_changed)(struct power_supply *psy);
@@ -237,6 +242,7 @@ struct power_supply {
         /* private */
         struct device dev;
         struct work_struct changed_work;
+        struct delayed_work deferred_register_work;
         spinlock_t changed_lock;
         bool changed;
         atomic_t use_cnt;
@@ -286,10 +292,15 @@ extern void power_supply_put(struct power_supply *psy);
 #ifdef CONFIG_OF
 extern struct power_supply *power_supply_get_by_phandle(struct device_node *np,
                                                         const char *property);
+extern struct power_supply *devm_power_supply_get_by_phandle(
+                                    struct device *dev, const char *property);
 #else /* !CONFIG_OF */
 static inline struct power_supply *
 power_supply_get_by_phandle(struct device_node *np, const char *property)
 { return NULL; }
+static inline struct power_supply *
+devm_power_supply_get_by_phandle(struct device *dev, const char *property)
+{ return NULL; }
 #endif /* CONFIG_OF */
 extern void power_supply_changed(struct power_supply *psy);
 extern int power_supply_am_i_supplied(struct power_supply *psy);
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 0f1534acaf60..84991f185173 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -293,6 +293,8 @@ struct preempt_notifier {
         struct preempt_ops *ops;
 };
 
+void preempt_notifier_inc(void);
+void preempt_notifier_dec(void);
 void preempt_notifier_register(struct preempt_notifier *notifier);
 void preempt_notifier_unregister(struct preempt_notifier *notifier);
 
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 9b30871c9149..a6298b27ac99 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -30,6 +30,8 @@ static inline const char *printk_skip_level(const char *buffer)
         return buffer;
 }
 
+#define CONSOLE_EXT_LOG_MAX     8192
+
 /* printk's without a loglevel use this.. */
 #define MESSAGE_LOGLEVEL_DEFAULT CONFIG_MESSAGE_LOGLEVEL_DEFAULT
 
@@ -120,7 +122,7 @@ static inline __printf(1, 2) __cold
 void early_printk(const char *s, ...) { }
 #endif
 
-typedef int(*printk_func_t)(const char *fmt, va_list args);
+typedef __printf(1, 0) int (*printk_func_t)(const char *fmt, va_list args);
 
 #ifdef CONFIG_PRINTK
 asmlinkage __printf(5, 0)
@@ -164,7 +166,7 @@ char *log_buf_addr_get(void);
 u32 log_buf_len_get(void);
 void log_buf_kexec_setup(void);
 void __init setup_log_buf(int early);
-void dump_stack_set_arch_desc(const char *fmt, ...);
+__printf(1, 2) void dump_stack_set_arch_desc(const char *fmt, ...);
 void dump_stack_print_info(const char *log_lvl);
 void show_regs_print_info(const char *log_lvl);
 #else
@@ -215,7 +217,7 @@ static inline void setup_log_buf(int early)
 {
 }
 
-static inline void dump_stack_set_arch_desc(const char *fmt, ...)
+static inline __printf(1, 2) void dump_stack_set_arch_desc(const char *fmt, ...)
 {
 }
 
diff --git a/include/linux/property.h b/include/linux/property.h
index de8bdf417a35..76ebde9c11d4 100644
--- a/include/linux/property.h
+++ b/include/linux/property.h
@@ -164,4 +164,6 @@ struct property_set {
 
 void device_add_property_set(struct device *dev, struct property_set *pset);
 
+bool device_dma_is_coherent(struct device *dev);
+
 #endif /* _LINUX_PROPERTY_H_ */
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index dab545bb66b3..0485bab061fd 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -194,8 +194,9 @@ enum pxa_ssp_type {
         PXA168_SSP,
         PXA910_SSP,
         CE4100_SSP,
-        LPSS_SSP,
         QUARK_X1000_SSP,
+        LPSS_LPT_SSP, /* Keep LPSS types sorted with lpss_platforms[] */
+        LPSS_BYT_SSP,
 };
 
 struct ssp_device {
diff --git a/include/linux/qcom_scm.h b/include/linux/qcom_scm.h
index d7a974d5f57c..6e7d5ec65838 100644
--- a/include/linux/qcom_scm.h
+++ b/include/linux/qcom_scm.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2010-2015, The Linux Foundation. All rights reserved.
  * Copyright (C) 2015 Linaro Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -16,6 +16,17 @@
 extern int qcom_scm_set_cold_boot_addr(void *entry, const cpumask_t *cpus);
 extern int qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus);
 
+#define QCOM_SCM_HDCP_MAX_REQ_CNT       5
+
+struct qcom_scm_hdcp_req {
+        u32 addr;
+        u32 val;
+};
+
+extern bool qcom_scm_hdcp_available(void);
+extern int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt,
+                u32 *resp);
+
 #define QCOM_SCM_CPU_PWR_DOWN_L2_ON     0x0
 #define QCOM_SCM_CPU_PWR_DOWN_L2_OFF    0x1
 
diff --git a/include/linux/rbtree.h b/include/linux/rbtree.h
index fb31765e935a..830c4992088d 100644
--- a/include/linux/rbtree.h
+++ b/include/linux/rbtree.h
@@ -31,6 +31,7 @@
 
 #include <linux/kernel.h>
 #include <linux/stddef.h>
+#include <linux/rcupdate.h>
 
 struct rb_node {
         unsigned long  __rb_parent_color;
@@ -73,11 +74,11 @@ extern struct rb_node *rb_first_postorder(const struct rb_root *);
 extern struct rb_node *rb_next_postorder(const struct rb_node *);
 
 /* Fast replacement of a single node without remove/rebalance/add/rebalance */
-extern void rb_replace_node(struct rb_node *victim, struct rb_node *new, 
+extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
                             struct rb_root *root);
 
-static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
-                                struct rb_node ** rb_link)
+static inline void rb_link_node(struct rb_node *node, struct rb_node *parent,
+                                struct rb_node **rb_link)
 {
         node->__rb_parent_color = (unsigned long)parent;
         node->rb_left = node->rb_right = NULL;
@@ -85,6 +86,15 @@ static inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
         *rb_link = node;
 }
 
+static inline void rb_link_node_rcu(struct rb_node *node, struct rb_node *parent,
+                                    struct rb_node **rb_link)
+{
+        node->__rb_parent_color = (unsigned long)parent;
+        node->rb_left = node->rb_right = NULL;
+
+        rcu_assign_pointer(*rb_link, node);
+}
+
 #define rb_entry_safe(ptr, type, member) \
         ({ typeof(ptr) ____ptr = (ptr); \
            ____ptr ? rb_entry(____ptr, type, member) : NULL; \
diff --git a/include/linux/rbtree_augmented.h b/include/linux/rbtree_augmented.h
index 378c5ee75f78..14d7b831b63a 100644
--- a/include/linux/rbtree_augmented.h
+++ b/include/linux/rbtree_augmented.h
@@ -123,11 +123,11 @@ __rb_change_child(struct rb_node *old, struct rb_node *new,
 {
         if (parent) {
                 if (parent->rb_left == old)
-                        parent->rb_left = new;
+                        WRITE_ONCE(parent->rb_left, new);
                 else
-                        parent->rb_right = new;
+                        WRITE_ONCE(parent->rb_right, new);
         } else
-                root->rb_node = new;
+                WRITE_ONCE(root->rb_node, new);
 }
 
 extern void __rb_erase_color(struct rb_node *parent, struct rb_root *root,
@@ -137,7 +137,8 @@ static __always_inline struct rb_node *
 __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                      const struct rb_augment_callbacks *augment)
 {
-        struct rb_node *child = node->rb_right, *tmp = node->rb_left;
+        struct rb_node *child = node->rb_right;
+        struct rb_node *tmp = node->rb_left;
         struct rb_node *parent, *rebalance;
         unsigned long pc;
 
@@ -167,6 +168,7 @@ __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                 tmp = parent;
         } else {
                 struct rb_node *successor = child, *child2;
+
                 tmp = child->rb_left;
                 if (!tmp) {
                         /*
@@ -180,6 +182,7 @@ __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                          */
                         parent = successor;
                         child2 = successor->rb_right;
+
                         augment->copy(node, successor);
                 } else {
                         /*
@@ -201,19 +204,23 @@ __rb_erase_augmented(struct rb_node *node, struct rb_root *root,
                                 successor = tmp;
                                 tmp = tmp->rb_left;
                         } while (tmp);
-                        parent->rb_left = child2 = successor->rb_right;
-                        successor->rb_right = child;
+                        child2 = successor->rb_right;
+                        WRITE_ONCE(parent->rb_left, child2);
+                        WRITE_ONCE(successor->rb_right, child);
                         rb_set_parent(child, successor);
+
                         augment->copy(node, successor);
                         augment->propagate(parent, successor);
                 }
 
-                successor->rb_left = tmp = node->rb_left;
+                tmp = node->rb_left;
+                WRITE_ONCE(successor->rb_left, tmp);
                 rb_set_parent(tmp, successor);
 
                 pc = node->__rb_parent_color;
                 tmp = __rb_parent(pc);
                 __rb_change_child(node, successor, tmp, root);
+
                 if (child2) {
                         successor->__rb_parent_color = pc;
                         rb_set_parent_color(child2, parent, RB_BLACK);
diff --git a/include/linux/rbtree_latch.h b/include/linux/rbtree_latch.h
new file mode 100644
index 000000000000..4f3432c61d12
--- /dev/null
+++ b/include/linux/rbtree_latch.h
@@ -0,0 +1,212 @@
+/*
+ * Latched RB-trees
+ *
+ * Copyright (C) 2015 Intel Corp., Peter Zijlstra <peterz@infradead.org>
+ *
+ * Since RB-trees have non-atomic modifications they're not immediately suited
+ * for RCU/lockless queries. Even though we made RB-tree lookups non-fatal for
+ * lockless lookups; we cannot guarantee they return a correct result.
+ *
+ * The simplest solution is a seqlock + RB-tree, this will allow lockless
+ * lookups; but has the constraint (inherent to the seqlock) that read sides
+ * cannot nest in write sides.
+ *
+ * If we need to allow unconditional lookups (say as required for NMI context
+ * usage) we need a more complex setup; this data structure provides this by
+ * employing the latch technique -- see @raw_write_seqcount_latch -- to
+ * implement a latched RB-tree which does allow for unconditional lookups by
+ * virtue of always having (at least) one stable copy of the tree.
+ *
+ * However, while we have the guarantee that there is at all times one stable
+ * copy, this does not guarantee an iteration will not observe modifications.
+ * What might have been a stable copy at the start of the iteration, need not
+ * remain so for the duration of the iteration.
+ *
+ * Therefore, this does require a lockless RB-tree iteration to be non-fatal;
+ * see the comment in lib/rbtree.c. Note however that we only require the first
+ * condition -- not seeing partial stores -- because the latch thing isolates
+ * us from loops. If we were to interrupt a modification the lookup would be
+ * pointed at the stable tree and complete while the modification was halted.
+ */
+
+#ifndef RB_TREE_LATCH_H
+#define RB_TREE_LATCH_H
+
+#include <linux/rbtree.h>
+#include <linux/seqlock.h>
+
+struct latch_tree_node {
+        struct rb_node node[2];
+};
+
+struct latch_tree_root {
+        seqcount_t      seq;
+        struct rb_root  tree[2];
+};
+
+/**
+ * latch_tree_ops - operators to define the tree order
+ * @less: used for insertion; provides the (partial) order between two elements.
+ * @comp: used for lookups; provides the order between the search key and an element.
+ *
+ * The operators are related like:
+ *
+ *      comp(a->key,b) < 0  := less(a,b)
+ *      comp(a->key,b) > 0  := less(b,a)
+ *      comp(a->key,b) == 0 := !less(a,b) && !less(b,a)
+ *
+ * If these operators define a partial order on the elements we make no
+ * guarantee on which of the elements matching the key is found. See
+ * latch_tree_find().
+ */
+struct latch_tree_ops {
+        bool (*less)(struct latch_tree_node *a, struct latch_tree_node *b);
+        int  (*comp)(void *key,                 struct latch_tree_node *b);
+};
+
+static __always_inline struct latch_tree_node *
+__lt_from_rb(struct rb_node *node, int idx)
+{
+        return container_of(node, struct latch_tree_node, node[idx]);
+}
+
+static __always_inline void
+__lt_insert(struct latch_tree_node *ltn, struct latch_tree_root *ltr, int idx,
+            bool (*less)(struct latch_tree_node *a, struct latch_tree_node *b))
+{
+        struct rb_root *root = &ltr->tree[idx];
+        struct rb_node **link = &root->rb_node;
+        struct rb_node *node = &ltn->node[idx];
+        struct rb_node *parent = NULL;
+        struct latch_tree_node *ltp;
+
+        while (*link) {
+                parent = *link;
+                ltp = __lt_from_rb(parent, idx);
+
+                if (less(ltn, ltp))
+                        link = &parent->rb_left;
+                else
+                        link = &parent->rb_right;
+        }
+
+        rb_link_node_rcu(node, parent, link);
+        rb_insert_color(node, root);
+}
+
+static __always_inline void
+__lt_erase(struct latch_tree_node *ltn, struct latch_tree_root *ltr, int idx)
+{
+        rb_erase(&ltn->node[idx], &ltr->tree[idx]);
+}
+
+static __always_inline struct latch_tree_node *
+__lt_find(void *key, struct latch_tree_root *ltr, int idx,
+          int (*comp)(void *key, struct latch_tree_node *node))
+{
+        struct rb_node *node = rcu_dereference_raw(ltr->tree[idx].rb_node);
+        struct latch_tree_node *ltn;
+        int c;
+
+        while (node) {
+                ltn = __lt_from_rb(node, idx);
+                c = comp(key, ltn);
+
+                if (c < 0)
+                        node = rcu_dereference_raw(node->rb_left);
+                else if (c > 0)
+                        node = rcu_dereference_raw(node->rb_right);
+                else
+                        return ltn;
+        }
+
+        return NULL;
+}
+
+/**
+ * latch_tree_insert() - insert @node into the trees @root
+ * @node: nodes to insert
+ * @root: trees to insert @node into
+ * @ops: operators defining the node order
+ *
+ * It inserts @node into @root in an ordered fashion such that we can always
+ * observe one complete tree. See the comment for raw_write_seqcount_latch().
+ *
+ * The inserts use rcu_assign_pointer() to publish the element such that the
+ * tree structure is stored before we can observe the new @node.
+ *
+ * All modifications (latch_tree_insert, latch_tree_remove) are assumed to be
+ * serialized.
+ */
+static __always_inline void
+latch_tree_insert(struct latch_tree_node *node,
+                  struct latch_tree_root *root,
+                  const struct latch_tree_ops *ops)
+{
+        raw_write_seqcount_latch(&root->seq);
+        __lt_insert(node, root, 0, ops->less);
+        raw_write_seqcount_latch(&root->seq);
+        __lt_insert(node, root, 1, ops->less);
+}
+
+/**
+ * latch_tree_erase() - removes @node from the trees @root
+ * @node: nodes to remote
+ * @root: trees to remove @node from
+ * @ops: operators defining the node order
+ *
+ * Removes @node from the trees @root in an ordered fashion such that we can
+ * always observe one complete tree. See the comment for
+ * raw_write_seqcount_latch().
+ *
+ * It is assumed that @node will observe one RCU quiescent state before being
+ * reused of freed.
+ *
+ * All modifications (latch_tree_insert, latch_tree_remove) are assumed to be
+ * serialized.
+ */
+static __always_inline void
+latch_tree_erase(struct latch_tree_node *node,
+                 struct latch_tree_root *root,
+                 const struct latch_tree_ops *ops)
+{
+        raw_write_seqcount_latch(&root->seq);
+        __lt_erase(node, root, 0);
+        raw_write_seqcount_latch(&root->seq);
+        __lt_erase(node, root, 1);
+}
+
+/**
+ * latch_tree_find() - find the node matching @key in the trees @root
+ * @key: search key
+ * @root: trees to search for @key
+ * @ops: operators defining the node order
+ *
+ * Does a lockless lookup in the trees @root for the node matching @key.
+ *
+ * It is assumed that this is called while holding the appropriate RCU read
+ * side lock.
+ *
+ * If the operators define a partial order on the elements (there are multiple
+ * elements which have the same key value) it is undefined which of these
+ * elements will be found. Nor is it possible to iterate the tree to find
+ * further elements with the same key value.
+ *
+ * Returns: a pointer to the node matching @key or NULL.
+ */
+static __always_inline struct latch_tree_node *
+latch_tree_find(void *key, struct latch_tree_root *root,
+                const struct latch_tree_ops *ops)
+{
+        struct latch_tree_node *node;
+        unsigned int seq;
+
+        do {
+                seq = raw_read_seqcount_latch(&root->seq);
+                node = __lt_find(key, root, seq & 1, ops->comp);
+        } while (read_seqcount_retry(&root->seq, seq));
+
+        return node;
+}
+
+#endif /* RB_TREE_LATCH_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 33a056bb886f..4cf5f51b4c9c 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -633,21 +633,6 @@ 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 = READ_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)
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 116655d92269..59c55ea0f0b5 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -433,6 +433,8 @@ int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
                                    unsigned int mask, unsigned int val,
                                    bool *change);
 int regmap_get_val_bytes(struct regmap *map);
+int regmap_get_max_register(struct regmap *map);
+int regmap_get_reg_stride(struct regmap *map);
 int regmap_async_complete(struct regmap *map);
 bool regmap_can_raw_write(struct regmap *map);
 
@@ -676,6 +678,18 @@ static inline int regmap_get_val_bytes(struct regmap *map)
         return -EINVAL;
 }
 
+static inline int regmap_get_max_register(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
+static inline int regmap_get_reg_stride(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
 static inline int regcache_sync(struct regmap *map)
 {
         WARN_ONCE(1, "regmap API is disabled");
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index fffa688ac3a7..4db9fbe4889d 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -91,6 +91,7 @@ struct regulator_linear_range {
  * @set_current_limit: Configure a limit for a current-limited regulator.
  *                     The driver should select the current closest to max_uA.
  * @get_current_limit: Get the configured limit for a current-limited regulator.
+ * @set_input_current_limit: Configure an input limit.
  *
  * @set_mode: Set the configured operating mode for the regulator.
  * @get_mode: Get the configured operating mode for the regulator.
@@ -111,6 +112,7 @@ struct regulator_linear_range {
  *               to stabilise after being set to a new value, in microseconds.
  *               The function provides the from and to voltage selector, the
  *               function should return the worst case.
+ * @set_soft_start: Enable soft start for the regulator.
  *
  * @set_suspend_voltage: Set the voltage for the regulator when the system
  *                       is suspended.
@@ -121,6 +123,9 @@ struct regulator_linear_range {
  * @set_suspend_mode: Set the operating mode for the regulator when the
  *                    system is suspended.
  *
+ * @set_pull_down: Configure the regulator to pull down when the regulator
+ *                 is disabled.
+ *
  * This struct describes regulator operations which can be implemented by
  * regulator chip drivers.
  */
@@ -142,6 +147,8 @@ struct regulator_ops {
                                  int min_uA, int max_uA);
         int (*get_current_limit) (struct regulator_dev *);
 
+        int (*set_input_current_limit) (struct regulator_dev *, int lim_uA);
+
         /* enable/disable regulator */
         int (*enable) (struct regulator_dev *);
         int (*disable) (struct regulator_dev *);
@@ -158,6 +165,8 @@ struct regulator_ops {
                                      unsigned int old_selector,
                                      unsigned int new_selector);
 
+        int (*set_soft_start) (struct regulator_dev *);
+
         /* report regulator status ... most other accessors report
          * control inputs, this reports results of combining inputs
          * from Linux (and other sources) with the actual load.
@@ -187,6 +196,8 @@ struct regulator_ops {
 
         /* set regulator suspend operating mode (defined in consumer.h) */
         int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode);
+
+        int (*set_pull_down) (struct regulator_dev *);
 };
 
 /*
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index b07562e082c4..b11be1260129 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -75,6 +75,8 @@ struct regulator_state {
  *
  * @min_uA: Smallest current consumers may set.
  * @max_uA: Largest current consumers may set.
+ * @ilim_uA: Maximum input current.
+ * @system_load: Load that isn't captured by any consumer requests.
  *
  * @valid_modes_mask: Mask of modes which may be configured by consumers.
  * @valid_ops_mask: Operations which may be performed by consumers.
@@ -86,6 +88,8 @@ struct regulator_state {
  *           applied.
  * @apply_uV: Apply the voltage constraint when initialising.
  * @ramp_disable: Disable ramp delay when initialising or when setting voltage.
+ * @soft_start: Enable soft start so that voltage ramps slowly.
+ * @pull_down: Enable pull down when regulator is disabled.
  *
  * @input_uV: Input voltage for regulator when supplied by another regulator.
  *
@@ -111,6 +115,9 @@ struct regulation_constraints {
         /* current output range (inclusive) - for current control */
         int min_uA;
         int max_uA;
+        int ilim_uA;
+
+        int system_load;
 
         /* valid regulator operating modes for this machine */
         unsigned int valid_modes_mask;
@@ -138,6 +145,8 @@ struct regulation_constraints {
         unsigned boot_on:1;     /* bootloader/firmware enabled regulator */
         unsigned apply_uV:1;    /* apply uV constraint if min == max */
         unsigned ramp_disable:1; /* disable ramp delay */
+        unsigned soft_start:1;  /* ramp voltage slowly */
+        unsigned pull_down:1;   /* pull down resistor when regulator off */
 };
 
 /**
diff --git a/include/linux/regulator/max8973-regulator.h b/include/linux/regulator/max8973-regulator.h
index f8acc052e353..f6a8a16a0d4d 100644
--- a/include/linux/regulator/max8973-regulator.h
+++ b/include/linux/regulator/max8973-regulator.h
@@ -58,6 +58,9 @@
  *              control signal from EN input pin. If it is false then
  *              voltage output will be enabled/disabled through EN bit of
  *              device register.
+ * @enable_gpio: Enable GPIO. If EN pin is controlled through GPIO from host
+ *              then GPIO number can be provided. If no GPIO controlled then
+ *              it should be -1.
  * @dvs_gpio: GPIO for dvs. It should be -1 if this is tied with fixed logic.
  * @dvs_def_state: Default state of dvs. 1 if it is high else 0.
  */
@@ -65,6 +68,7 @@ struct max8973_regulator_platform_data {
         struct regulator_init_data *reg_init_data;
         unsigned long control_flags;
         bool enable_ext_control;
+        int enable_gpio;
         int dvs_gpio;
         unsigned dvs_def_state:1;
 };
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 78b8a9b9d40a..9c4e1384f636 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -36,11 +36,11 @@
 #define REMOTEPROC_H
 
 #include <linux/types.h>
-#include <linux/klist.h>
 #include <linux/mutex.h>
 #include <linux/virtio.h>
 #include <linux/completion.h>
 #include <linux/idr.h>
+#include <linux/of.h>
 
 /**
  * struct resource_table - firmware resource table header
@@ -330,11 +330,13 @@ struct rproc;
  * @start:      power on the device and boot it
  * @stop:       power off the device
  * @kick:       kick a virtqueue (virtqueue id given as a parameter)
+ * @da_to_va:   optional platform hook to perform address translations
  */
 struct rproc_ops {
         int (*start)(struct rproc *rproc);
         int (*stop)(struct rproc *rproc);
         void (*kick)(struct rproc *rproc, int vqid);
+        void * (*da_to_va)(struct rproc *rproc, u64 da, int len);
 };
 
 /**
@@ -375,7 +377,7 @@ enum rproc_crash_type {
 
 /**
  * struct rproc - represents a physical remote processor device
- * @node: klist node of this rproc object
+ * @node: list node of this rproc object
  * @domain: iommu domain
  * @name: human readable name of the rproc
  * @firmware: name of firmware file to be loaded
@@ -407,7 +409,7 @@ enum rproc_crash_type {
  * @has_iommu: flag to indicate if remote processor is behind an MMU
  */
 struct rproc {
-        struct klist_node node;
+        struct list_head node;
         struct iommu_domain *domain;
         const char *name;
         const char *firmware;
@@ -481,6 +483,7 @@ struct rproc_vdev {
         u32 rsc_offset;
 };
 
+struct rproc *rproc_get_by_phandle(phandle phandle);
 struct rproc *rproc_alloc(struct device *dev, const char *name,
                                 const struct rproc_ops *ops,
                                 const char *firmware, int len);
diff --git a/include/linux/reset/bcm63xx_pmb.h b/include/linux/reset/bcm63xx_pmb.h
new file mode 100644
index 000000000000..bb4af7b5eb36
--- /dev/null
+++ b/include/linux/reset/bcm63xx_pmb.h
@@ -0,0 +1,88 @@
+/*
+ * Broadcom BCM63xx Processor Monitor Bus shared routines (SMP and reset)
+ *
+ * Copyright (C) 2015, Broadcom Corporation
+ * Author: Florian Fainelli <f.fainelli@gmail.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 __BCM63XX_PMB_H
+#define __BCM63XX_PMB_H
+
+#include <linux/io.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+
+/* PMB Master controller register */
+#define PMB_CTRL                0x00
+#define  PMC_PMBM_START         (1 << 31)
+#define  PMC_PMBM_TIMEOUT       (1 << 30)
+#define  PMC_PMBM_SLAVE_ERR     (1 << 29)
+#define  PMC_PMBM_BUSY          (1 << 28)
+#define  PMC_PMBM_READ          (0 << 20)
+#define  PMC_PMBM_WRITE         (1 << 20)
+#define PMB_WR_DATA             0x04
+#define PMB_TIMEOUT             0x08
+#define PMB_RD_DATA             0x0C
+
+#define PMB_BUS_ID_SHIFT        8
+
+/* Perform the low-level PMB master operation, shared between reads and
+ * writes.
+ */
+static inline int __bpcm_do_op(void __iomem *master, unsigned int addr,
+                               u32 off, u32 op)
+{
+        unsigned int timeout = 1000;
+        u32 cmd;
+
+        cmd = (PMC_PMBM_START | op | (addr & 0xff) << 12 | off);
+        writel(cmd, master + PMB_CTRL);
+        do {
+                cmd = readl(master + PMB_CTRL);
+                if (!(cmd & PMC_PMBM_START))
+                        return 0;
+
+                if (cmd & PMC_PMBM_SLAVE_ERR)
+                        return -EIO;
+
+                if (cmd & PMC_PMBM_TIMEOUT)
+                        return -ETIMEDOUT;
+
+                udelay(1);
+        } while (timeout-- > 0);
+
+        return -ETIMEDOUT;
+}
+
+static inline int bpcm_rd(void __iomem *master, unsigned int addr,
+                          u32 off, u32 *val)
+{
+        int ret = 0;
+
+        ret = __bpcm_do_op(master, addr, off >> 2, PMC_PMBM_READ);
+        *val = readl(master + PMB_RD_DATA);
+
+        return ret;
+}
+
+static inline int bpcm_wr(void __iomem *master, unsigned int addr,
+                          u32 off, u32 val)
+{
+        int ret = 0;
+
+        writel(val, master + PMB_WR_DATA);
+        ret = __bpcm_do_op(master, addr, off >> 2, PMC_PMBM_WRITE);
+
+        return ret;
+}
+
+#endif /* __BCM63XX_PMB_H */
diff --git a/include/linux/rio.h b/include/linux/rio.h
index 6bda06f21930..cde976e86b48 100644
--- a/include/linux/rio.h
+++ b/include/linux/rio.h
@@ -298,7 +298,7 @@ struct rio_id_table {
  * struct rio_net - RIO network info
  * @node: Node in global list of RIO networks
  * @devices: List of devices in this network
- * @switches: List of switches in this netowrk
+ * @switches: List of switches in this network
  * @mports: List of master ports accessing this network
  * @hport: Default port for accessing this network
  * @id: RIO network ID
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 8dcf6825fa88..3359f0422c6b 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -24,6 +24,14 @@ 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);
 
+/*
+ * rtc_tm_sub - Return the difference in seconds.
+ */
+static inline time64_t rtc_tm_sub(struct rtc_time *lhs, struct rtc_time *rhs)
+{
+        return rtc_tm_to_time64(lhs) - rtc_tm_to_time64(rhs);
+}
+
 /**
  * Deprecated. Use rtc_time64_to_tm().
  */
@@ -101,8 +109,7 @@ struct rtc_timer {
 /* flags */
 #define RTC_DEV_BUSY 0
 
-struct rtc_device
-{
+struct rtc_device {
         struct device dev;
         struct module *owner;
 
@@ -161,7 +168,6 @@ extern void devm_rtc_device_unregister(struct device *dev,
 
 extern int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm);
 extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm);
-extern int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs);
 extern int rtc_set_ntp_time(struct timespec64 now);
 int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm);
 extern int rtc_read_alarm(struct rtc_device *rtc,
@@ -198,10 +204,10 @@ int rtc_register(rtc_task_t *task);
 int rtc_unregister(rtc_task_t *task);
 int rtc_control(rtc_task_t *t, unsigned int cmd, unsigned long arg);
 
-void rtc_timer_init(struct rtc_timer *timer, void (*f)(void* p), void* data);
-int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer* timer,
-                        ktime_t expires, ktime_t period);
-int rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer* timer);
+void rtc_timer_init(struct rtc_timer *timer, void (*f)(void *p), void *data);
+int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
+                    ktime_t expires, ktime_t period);
+void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer);
 void rtc_timer_do_work(struct work_struct *work);
 
 static inline bool is_leap_year(unsigned int year)
diff --git a/include/linux/rtc/sirfsoc_rtciobrg.h b/include/linux/rtc/sirfsoc_rtciobrg.h
index 2c92e1c8e055..aefd997262e4 100644
--- a/include/linux/rtc/sirfsoc_rtciobrg.h
+++ b/include/linux/rtc/sirfsoc_rtciobrg.h
@@ -9,10 +9,14 @@
 #ifndef _SIRFSOC_RTC_IOBRG_H_
 #define _SIRFSOC_RTC_IOBRG_H_
 
+struct regmap_config;
+
 extern void sirfsoc_rtc_iobrg_besyncing(void);
 
 extern u32 sirfsoc_rtc_iobrg_readl(u32 addr);
 
 extern void sirfsoc_rtc_iobrg_writel(u32 val, u32 addr);
+struct regmap *devm_regmap_init_iobg(struct device *dev,
+                                    const struct regmap_config *config);
 
 #endif
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 7b8e260c4a27..39adaa9529eb 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -79,17 +79,9 @@ static inline struct netdev_queue *dev_ingress_queue(struct net_device *dev)
 
 struct netdev_queue *dev_ingress_queue_create(struct net_device *dev);
 
-#ifdef CONFIG_NET_CLS_ACT
+#ifdef CONFIG_NET_INGRESS
 void net_inc_ingress_queue(void);
 void net_dec_ingress_queue(void);
-#else
-static inline void net_inc_ingress_queue(void)
-{
-}
-
-static inline void net_dec_ingress_queue(void)
-{
-}
 #endif
 
 extern void rtnetlink_init(void);
@@ -122,5 +114,9 @@ extern int ndo_dflt_fdb_del(struct ndmsg *ndm,
 
 extern int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
                                    struct net_device *dev, u16 mode,
-                                   u32 flags, u32 mask, int nlflags);
+                                   u32 flags, u32 mask, int nlflags,
+                                   u32 filter_mask,
+                                   int (*vlan_fill)(struct sk_buff *skb,
+                                                    struct net_device *dev,
+                                                    u32 filter_mask));
 #endif  /* __LINUX_RTNETLINK_H */
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index a0edb992c9c3..9b1ef0c820a7 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -2,13 +2,39 @@
 #define _LINUX_SCATTERLIST_H
 
 #include <linux/string.h>
+#include <linux/types.h>
 #include <linux/bug.h>
 #include <linux/mm.h>
-
-#include <asm/types.h>
-#include <asm/scatterlist.h>
 #include <asm/io.h>
 
+struct scatterlist {
+#ifdef CONFIG_DEBUG_SG
+        unsigned long   sg_magic;
+#endif
+        unsigned long   page_link;
+        unsigned int    offset;
+        unsigned int    length;
+        dma_addr_t      dma_address;
+#ifdef CONFIG_NEED_SG_DMA_LENGTH
+        unsigned int    dma_length;
+#endif
+};
+
+/*
+ * These macros should be used after a dma_map_sg call has been done
+ * to get bus addresses of each of the SG entries and their lengths.
+ * You should only work with the number of sg entries dma_map_sg
+ * returns, or alternatively stop on the first sg_dma_len(sg) which
+ * is 0.
+ */
+#define sg_dma_address(sg)      ((sg)->dma_address)
+
+#ifdef CONFIG_NEED_SG_DMA_LENGTH
+#define sg_dma_len(sg)          ((sg)->dma_length)
+#else
+#define sg_dma_len(sg)          ((sg)->length)
+#endif
+
 struct sg_table {
         struct scatterlist *sgl;        /* the list */
         unsigned int nents;             /* number of mapped entries */
@@ -18,10 +44,9 @@ struct sg_table {
 /*
  * Notes on SG table design.
  *
- * Architectures must provide an unsigned long page_link field in the
- * scatterlist struct. We use that to place the page pointer AND encode
- * information about the sg table as well. The two lower bits are reserved
- * for this information.
+ * We use the unsigned long page_link field in the scatterlist struct to place
+ * the page pointer AND encode information about the sg table as well. The two
+ * lower bits are reserved for this information.
  *
  * If bit 0 is set, then the page_link contains a pointer to the next sg
  * table list. Otherwise the next entry is at sg + 1.
@@ -240,13 +265,16 @@ int sg_alloc_table_from_pages(struct sg_table *sgt,
         unsigned long offset, unsigned long size,
         gfp_t gfp_mask);
 
+size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents, void *buf,
+                      size_t buflen, off_t skip, bool to_buffer);
+
 size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
-                           void *buf, size_t buflen);
+                           const void *buf, size_t buflen);
 size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
                          void *buf, size_t buflen);
 
 size_t sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents,
-                            void *buf, size_t buflen, off_t skip);
+                            const void *buf, size_t buflen, off_t skip);
 size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
                           void *buf, size_t buflen, off_t skip);
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 6633e83e608a..04b5ada460b4 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -58,6 +58,7 @@ struct sched_param {
 #include <linux/uidgid.h>
 #include <linux/gfp.h>
 #include <linux/magic.h>
+#include <linux/cgroup-defs.h>
 
 #include <asm/processor.h>
 
@@ -191,8 +192,6 @@ struct task_group;
 #ifdef CONFIG_SCHED_DEBUG
 extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
 extern void proc_sched_set_task(struct task_struct *p);
-extern void
-print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
 #endif
 
 /*
@@ -755,18 +754,6 @@ struct signal_struct {
         unsigned audit_tty_log_passwd;
         struct tty_audit_buf *tty_audit_buf;
 #endif
-#ifdef CONFIG_CGROUPS
-        /*
-         * group_rwsem prevents new tasks from entering the threadgroup and
-         * member tasks from exiting,a more specifically, setting of
-         * PF_EXITING.  fork and exit paths are protected with this rwsem
-         * using threadgroup_change_begin/end().  Users which require
-         * threadgroup to remain stable should use threadgroup_[un]lock()
-         * which also takes care of exec path.  Currently, cgroup is the
-         * only user.
-         */
-        struct rw_semaphore group_rwsem;
-#endif
 
         oom_flags_t oom_flags;
         short oom_score_adj;            /* OOM kill score adjustment */
@@ -849,7 +836,7 @@ extern struct user_struct root_user;
 struct backing_dev_info;
 struct reclaim_state;
 
-#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
+#ifdef CONFIG_SCHED_INFO
 struct sched_info {
         /* cumulative counters */
         unsigned long pcount;         /* # of times run on this cpu */
@@ -859,7 +846,7 @@ struct sched_info {
         unsigned long long last_arrival,/* when we last ran on a cpu */
                            last_queued; /* when we were last queued to run */
 };
-#endif /* defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) */
+#endif /* CONFIG_SCHED_INFO */
 
 #ifdef CONFIG_TASK_DELAY_ACCT
 struct task_delay_info {
@@ -1408,7 +1395,7 @@ struct task_struct {
         int rcu_tasks_idle_cpu;
 #endif /* #ifdef CONFIG_TASKS_RCU */
 
-#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
+#ifdef CONFIG_SCHED_INFO
         struct sched_info sched_info;
 #endif
 
@@ -1535,8 +1522,6 @@ struct task_struct {
 /* hung task detection */
         unsigned long last_switch_count;
 #endif
-/* CPU-specific state of this task */
-        struct thread_struct thread;
 /* filesystem information */
         struct fs_struct *fs;
 /* open file information */
@@ -1791,8 +1776,22 @@ struct task_struct {
         unsigned long   task_state_change;
 #endif
         int pagefault_disabled;
+/* CPU-specific state of this task */
+        struct thread_struct thread;
+/*
+ * WARNING: on x86, 'thread_struct' contains a variable-sized
+ * structure.  It *MUST* be at the end of 'task_struct'.
+ *
+ * Do not put anything below here!
+ */
 };
 
+#ifdef CONFIG_ARCH_WANTS_DYNAMIC_TASK_STRUCT
+extern int arch_task_struct_size __read_mostly;
+#else
+# define arch_task_struct_size (sizeof(struct task_struct))
+#endif
+
 /* Future-safe accessor for struct task_struct's cpus_allowed. */
 #define tsk_cpus_allowed(tsk) (&(tsk)->cpus_allowed)
 
@@ -2432,7 +2431,6 @@ extern void sched_dead(struct task_struct *p);
 
 extern void proc_caches_init(void);
 extern void flush_signals(struct task_struct *);
-extern void __flush_signals(struct task_struct *);
 extern void ignore_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *, int force_default);
 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
@@ -2556,8 +2554,22 @@ extern struct mm_struct *mm_access(struct task_struct *task, unsigned int mode);
 /* Remove the current tasks stale references to the old mm_struct */
 extern void mm_release(struct task_struct *, struct mm_struct *);
 
+#ifdef CONFIG_HAVE_COPY_THREAD_TLS
+extern int copy_thread_tls(unsigned long, unsigned long, unsigned long,
+                        struct task_struct *, unsigned long);
+#else
 extern int copy_thread(unsigned long, unsigned long, unsigned long,
                         struct task_struct *);
+
+/* Architectures that haven't opted into copy_thread_tls get the tls argument
+ * via pt_regs, so ignore the tls argument passed via C. */
+static inline int copy_thread_tls(
+                unsigned long clone_flags, unsigned long sp, unsigned long arg,
+                struct task_struct *p, unsigned long tls)
+{
+        return copy_thread(clone_flags, sp, arg, p);
+}
+#endif
 extern void flush_thread(void);
 extern void exit_thread(void);
 
@@ -2576,6 +2588,7 @@ 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 *, unsigned long);
 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);
@@ -2710,53 +2723,33 @@ static inline void unlock_task_sighand(struct task_struct *tsk,
         spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
 }
 
-#ifdef CONFIG_CGROUPS
-static inline void threadgroup_change_begin(struct task_struct *tsk)
-{
-        down_read(&tsk->signal->group_rwsem);
-}
-static inline void threadgroup_change_end(struct task_struct *tsk)
-{
-        up_read(&tsk->signal->group_rwsem);
-}
-
 /**
- * threadgroup_lock - lock threadgroup
- * @tsk: member task of the threadgroup to lock
- *
- * Lock the threadgroup @tsk belongs to.  No new task is allowed to enter
- * and member tasks aren't allowed to exit (as indicated by PF_EXITING) or
- * change ->group_leader/pid.  This is useful for cases where the threadgroup
- * needs to stay stable across blockable operations.
- *
- * fork and exit paths explicitly call threadgroup_change_{begin|end}() for
- * synchronization.  While held, no new task will be added to threadgroup
- * and no existing live task will have its PF_EXITING set.
+ * threadgroup_change_begin - mark the beginning of changes to a threadgroup
+ * @tsk: task causing the changes
  *
- * de_thread() does threadgroup_change_{begin|end}() when a non-leader
- * sub-thread becomes a new leader.
+ * All operations which modify a threadgroup - a new thread joining the
+ * group, death of a member thread (the assertion of PF_EXITING) and
+ * exec(2) dethreading the process and replacing the leader - are wrapped
+ * by threadgroup_change_{begin|end}().  This is to provide a place which
+ * subsystems needing threadgroup stability can hook into for
+ * synchronization.
  */
-static inline void threadgroup_lock(struct task_struct *tsk)
+static inline void threadgroup_change_begin(struct task_struct *tsk)
 {
-        down_write(&tsk->signal->group_rwsem);
+        might_sleep();
+        cgroup_threadgroup_change_begin(tsk);
 }
 
 /**
- * threadgroup_unlock - unlock threadgroup
- * @tsk: member task of the threadgroup to unlock
+ * threadgroup_change_end - mark the end of changes to a threadgroup
+ * @tsk: task causing the changes
  *
- * Reverse threadgroup_lock().
+ * See threadgroup_change_begin().
  */
-static inline void threadgroup_unlock(struct task_struct *tsk)
+static inline void threadgroup_change_end(struct task_struct *tsk)
 {
-        up_write(&tsk->signal->group_rwsem);
+        cgroup_threadgroup_change_end(tsk);
 }
-#else
-static inline void threadgroup_change_begin(struct task_struct *tsk) {}
-static inline void threadgroup_change_end(struct task_struct *tsk) {}
-static inline void threadgroup_lock(struct task_struct *tsk) {}
-static inline void threadgroup_unlock(struct task_struct *tsk) {}
-#endif
 
 #ifndef __HAVE_THREAD_FUNCTIONS
 
diff --git a/include/linux/scif.h b/include/linux/scif.h
new file mode 100644
index 000000000000..44f4f3898bbe
--- /dev/null
+++ b/include/linux/scif.h
@@ -0,0 +1,993 @@
+/*
+ * Intel MIC Platform Software Stack (MPSS)
+ *
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ * redistributing this file, you may do so under either license.
+ *
+ * GPL LICENSE SUMMARY
+ *
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * BSD LICENSE
+ *
+ * Copyright(c) 2014 Intel Corporation.
+ *
+ * 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.
+ * * Neither the name of Intel Corporation nor the names of its
+ *   contributors may be used to endorse or promote products derived
+ *   from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 THE COPYRIGHT
+ * OWNER 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.
+ *
+ * Intel SCIF driver.
+ *
+ */
+#ifndef __SCIF_H__
+#define __SCIF_H__
+
+#include <linux/types.h>
+#include <linux/poll.h>
+#include <linux/scif_ioctl.h>
+
+#define SCIF_ACCEPT_SYNC        1
+#define SCIF_SEND_BLOCK         1
+#define SCIF_RECV_BLOCK         1
+
+enum {
+        SCIF_PROT_READ = (1 << 0),
+        SCIF_PROT_WRITE = (1 << 1)
+};
+
+enum {
+        SCIF_MAP_FIXED = 0x10,
+        SCIF_MAP_KERNEL = 0x20,
+};
+
+enum {
+        SCIF_FENCE_INIT_SELF = (1 << 0),
+        SCIF_FENCE_INIT_PEER = (1 << 1),
+        SCIF_SIGNAL_LOCAL = (1 << 4),
+        SCIF_SIGNAL_REMOTE = (1 << 5)
+};
+
+enum {
+        SCIF_RMA_USECPU = (1 << 0),
+        SCIF_RMA_USECACHE = (1 << 1),
+        SCIF_RMA_SYNC = (1 << 2),
+        SCIF_RMA_ORDERED = (1 << 3)
+};
+
+/* End of SCIF Admin Reserved Ports */
+#define SCIF_ADMIN_PORT_END     1024
+
+/* End of SCIF Reserved Ports */
+#define SCIF_PORT_RSVD          1088
+
+typedef struct scif_endpt *scif_epd_t;
+
+#define SCIF_OPEN_FAILED ((scif_epd_t)-1)
+#define SCIF_REGISTER_FAILED ((off_t)-1)
+#define SCIF_MMAP_FAILED ((void *)-1)
+
+/**
+ * scif_open() - Create an endpoint
+ *
+ * Return:
+ * Upon successful completion, scif_open() returns an endpoint descriptor to
+ * be used in subsequent SCIF functions calls to refer to that endpoint;
+ * otherwise in user mode SCIF_OPEN_FAILED (that is ((scif_epd_t)-1)) is
+ * returned and errno is set to indicate the error; in kernel mode a NULL
+ * scif_epd_t is returned.
+ *
+ * Errors:
+ * ENOMEM - Insufficient kernel memory was available
+ */
+scif_epd_t scif_open(void);
+
+/**
+ * scif_bind() - Bind an endpoint to a port
+ * @epd:        endpoint descriptor
+ * @pn:         port number
+ *
+ * scif_bind() binds endpoint epd to port pn, where pn is a port number on the
+ * local node. If pn is zero, a port number greater than or equal to
+ * SCIF_PORT_RSVD is assigned and returned. Each endpoint may be bound to
+ * exactly one local port. Ports less than 1024 when requested can only be bound
+ * by system (or root) processes or by processes executed by privileged users.
+ *
+ * Return:
+ * Upon successful completion, scif_bind() returns the port number to which epd
+ * is bound; otherwise in user mode -1 is returned and errno is set to
+ * indicate the error; in kernel mode the negative of one of the following
+ * errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * EINVAL - the endpoint or the port is already bound
+ * EISCONN - The endpoint is already connected
+ * ENOSPC - No port number available for assignment
+ * EACCES - The port requested is protected and the user is not the superuser
+ */
+int scif_bind(scif_epd_t epd, u16 pn);
+
+/**
+ * scif_listen() - Listen for connections on an endpoint
+ * @epd:        endpoint descriptor
+ * @backlog:    maximum pending connection requests
+ *
+ * scif_listen() marks the endpoint epd as a listening endpoint - that is, as
+ * an endpoint that will be used to accept incoming connection requests. Once
+ * so marked, the endpoint is said to be in the listening state and may not be
+ * used as the endpoint of a connection.
+ *
+ * The endpoint, epd, must have been bound to a port.
+ *
+ * The backlog argument defines the maximum length to which the queue of
+ * pending connections for epd may grow. If a connection request arrives when
+ * the queue is full, the client may receive an error with an indication that
+ * the connection was refused.
+ *
+ * Return:
+ * Upon successful completion, scif_listen() returns 0; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode the
+ * negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * EINVAL - the endpoint is not bound to a port
+ * EISCONN - The endpoint is already connected or listening
+ */
+int scif_listen(scif_epd_t epd, int backlog);
+
+/**
+ * scif_connect() - Initiate a connection on a port
+ * @epd:        endpoint descriptor
+ * @dst:        global id of port to which to connect
+ *
+ * The scif_connect() function requests the connection of endpoint epd to remote
+ * port dst. If the connection is successful, a peer endpoint, bound to dst, is
+ * created on node dst.node. On successful return, the connection is complete.
+ *
+ * If the endpoint epd has not already been bound to a port, scif_connect()
+ * will bind it to an unused local port.
+ *
+ * A connection is terminated when an endpoint of the connection is closed,
+ * either explicitly by scif_close(), or when a process that owns one of the
+ * endpoints of the connection is terminated.
+ *
+ * In user space, scif_connect() supports an asynchronous connection mode
+ * if the application has set the O_NONBLOCK flag on the endpoint via the
+ * fcntl() system call. Setting this flag will result in the calling process
+ * not to wait during scif_connect().
+ *
+ * Return:
+ * Upon successful completion, scif_connect() returns the port ID to which the
+ * endpoint, epd, is bound; otherwise in user mode -1 is returned and errno is
+ * set to indicate the error; in kernel mode the negative of one of the
+ * following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNREFUSED - The destination was not listening for connections or refused
+ * the connection request
+ * EINVAL - dst.port is not a valid port ID
+ * EISCONN - The endpoint is already connected
+ * ENOMEM - No buffer space is available
+ * ENODEV - The destination node does not exist, or the node is lost or existed,
+ * but is not currently in the network since it may have crashed
+ * ENOSPC - No port number available for assignment
+ * EOPNOTSUPP - The endpoint is listening and cannot be connected
+ */
+int scif_connect(scif_epd_t epd, struct scif_port_id *dst);
+
+/**
+ * scif_accept() - Accept a connection on an endpoint
+ * @epd:        endpoint descriptor
+ * @peer:       global id of port to which connected
+ * @newepd:     new connected endpoint descriptor
+ * @flags:      flags
+ *
+ * The scif_accept() call extracts the first connection request from the queue
+ * of pending connections for the port on which epd is listening. scif_accept()
+ * creates a new endpoint, bound to the same port as epd, and allocates a new
+ * SCIF endpoint descriptor, returned in newepd, for the endpoint. The new
+ * endpoint is connected to the endpoint through which the connection was
+ * requested. epd is unaffected by this call, and remains in the listening
+ * state.
+ *
+ * On successful return, peer holds the global port identifier (node id and
+ * local port number) of the port which requested the connection.
+ *
+ * A connection is terminated when an endpoint of the connection is closed,
+ * either explicitly by scif_close(), or when a process that owns one of the
+ * endpoints of the connection is terminated.
+ *
+ * The number of connections that can (subsequently) be accepted on epd is only
+ * limited by system resources (memory).
+ *
+ * The flags argument is formed by OR'ing together zero or more of the
+ * following values.
+ * SCIF_ACCEPT_SYNC - block until a connection request is presented. If
+ *                      SCIF_ACCEPT_SYNC is not in flags, and no pending
+ *                      connections are present on the queue, scif_accept()
+ *                      fails with an EAGAIN error
+ *
+ * In user mode, the select() and poll() functions can be used to determine
+ * when there is a connection request. In kernel mode, the scif_poll()
+ * function may be used for this purpose. A readable event will be delivered
+ * when a connection is requested.
+ *
+ * Return:
+ * Upon successful completion, scif_accept() returns 0; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode the
+ *      negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EAGAIN - SCIF_ACCEPT_SYNC is not set and no connections are present to be
+ * accepted or SCIF_ACCEPT_SYNC is not set and remote node failed to complete
+ * its connection request
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * EINTR - Interrupted function
+ * EINVAL - epd is not a listening endpoint, or flags is invalid, or peer is
+ * NULL, or newepd is NULL
+ * ENODEV - The requesting node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOENT - Secondary part of epd registration failed
+ */
+int scif_accept(scif_epd_t epd, struct scif_port_id *peer, scif_epd_t
+                *newepd, int flags);
+
+/**
+ * scif_close() - Close an endpoint
+ * @epd:        endpoint descriptor
+ *
+ * scif_close() closes an endpoint and performs necessary teardown of
+ * facilities associated with that endpoint.
+ *
+ * If epd is a listening endpoint then it will no longer accept connection
+ * requests on the port to which it is bound. Any pending connection requests
+ * are rejected.
+ *
+ * If epd is a connected endpoint, then its peer endpoint is also closed. RMAs
+ * which are in-process through epd or its peer endpoint will complete before
+ * scif_close() returns. Registered windows of the local and peer endpoints are
+ * released as if scif_unregister() was called against each window.
+ *
+ * Closing a SCIF endpoint does not affect local registered memory mapped by
+ * a SCIF endpoint on a remote node. The local memory remains mapped by the peer
+ * SCIF endpoint explicitly removed by calling munmap(..) by the peer.
+ *
+ * If the peer endpoint's receive queue is not empty at the time that epd is
+ * closed, then the peer endpoint can be passed as the endpoint parameter to
+ * scif_recv() until the receive queue is empty.
+ *
+ * epd is freed and may no longer be accessed.
+ *
+ * Return:
+ * Upon successful completion, scif_close() returns 0; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode the
+ * negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ */
+int scif_close(scif_epd_t epd);
+
+/**
+ * scif_send() - Send a message
+ * @epd:        endpoint descriptor
+ * @msg:        message buffer address
+ * @len:        message length
+ * @flags:      blocking mode flags
+ *
+ * scif_send() sends data to the peer of endpoint epd. Up to len bytes of data
+ * are copied from memory starting at address msg. On successful execution the
+ * return value of scif_send() is the number of bytes that were sent, and is
+ * zero if no bytes were sent because len was zero. scif_send() may be called
+ * only when the endpoint is in a connected state.
+ *
+ * If a scif_send() call is non-blocking, then it sends only those bytes which
+ * can be sent without waiting, up to a maximum of len bytes.
+ *
+ * If a scif_send() call is blocking, then it normally returns after sending
+ * all len bytes. If a blocking call is interrupted or the connection is
+ * reset, the call is considered successful if some bytes were sent or len is
+ * zero, otherwise the call is considered unsuccessful.
+ *
+ * In user mode, the select() and poll() functions can be used to determine
+ * when the send queue is not full. In kernel mode, the scif_poll() function
+ * may be used for this purpose.
+ *
+ * It is recommended that scif_send()/scif_recv() only be used for short
+ * control-type message communication between SCIF endpoints. The SCIF RMA
+ * APIs are expected to provide better performance for transfer sizes of
+ * 1024 bytes or longer for the current MIC hardware and software
+ * implementation.
+ *
+ * scif_send() will block until the entire message is sent if SCIF_SEND_BLOCK
+ * is passed as the flags argument.
+ *
+ * Return:
+ * Upon successful completion, scif_send() returns the number of bytes sent;
+ * otherwise in user mode -1 is returned and errno is set to indicate the
+ * error; in kernel mode the negative of one of the following errors is
+ * returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - An invalid address was specified for a parameter
+ * EINVAL - flags is invalid, or len is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOTCONN - The endpoint is not connected
+ */
+int scif_send(scif_epd_t epd, void *msg, int len, int flags);
+
+/**
+ * scif_recv() - Receive a message
+ * @epd:        endpoint descriptor
+ * @msg:        message buffer address
+ * @len:        message buffer length
+ * @flags:      blocking mode flags
+ *
+ * scif_recv() receives data from the peer of endpoint epd. Up to len bytes of
+ * data are copied to memory starting at address msg. On successful execution
+ * the return value of scif_recv() is the number of bytes that were received,
+ * and is zero if no bytes were received because len was zero. scif_recv() may
+ * be called only when the endpoint is in a connected state.
+ *
+ * If a scif_recv() call is non-blocking, then it receives only those bytes
+ * which can be received without waiting, up to a maximum of len bytes.
+ *
+ * If a scif_recv() call is blocking, then it normally returns after receiving
+ * all len bytes. If the blocking call was interrupted due to a disconnection,
+ * subsequent calls to scif_recv() will copy all bytes received upto the point
+ * of disconnection.
+ *
+ * In user mode, the select() and poll() functions can be used to determine
+ * when data is available to be received. In kernel mode, the scif_poll()
+ * function may be used for this purpose.
+ *
+ * It is recommended that scif_send()/scif_recv() only be used for short
+ * control-type message communication between SCIF endpoints. The SCIF RMA
+ * APIs are expected to provide better performance for transfer sizes of
+ * 1024 bytes or longer for the current MIC hardware and software
+ * implementation.
+ *
+ * scif_recv() will block until the entire message is received if
+ * SCIF_RECV_BLOCK is passed as the flags argument.
+ *
+ * Return:
+ * Upon successful completion, scif_recv() returns the number of bytes
+ * received; otherwise in user mode -1 is returned and errno is set to
+ * indicate the error; in kernel mode the negative of one of the following
+ * errors is returned.
+ *
+ * Errors:
+ * EAGAIN - The destination node is returning from a low power state
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - An invalid address was specified for a parameter
+ * EINVAL - flags is invalid, or len is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOTCONN - The endpoint is not connected
+ */
+int scif_recv(scif_epd_t epd, void *msg, int len, int flags);
+
+/**
+ * scif_register() - Mark a memory region for remote access.
+ * @epd:                endpoint descriptor
+ * @addr:               starting virtual address
+ * @len:                length of range
+ * @offset:             offset of window
+ * @prot_flags:         read/write protection flags
+ * @map_flags:          mapping flags
+ *
+ * The scif_register() function opens a window, a range of whole pages of the
+ * registered address space of the endpoint epd, starting at offset po and
+ * continuing for len bytes. The value of po, further described below, is a
+ * function of the parameters offset and len, and the value of map_flags. Each
+ * page of the window represents the physical memory page which backs the
+ * corresponding page of the range of virtual address pages starting at addr
+ * and continuing for len bytes. addr and len are constrained to be multiples
+ * of the page size. A successful scif_register() call returns po.
+ *
+ * When SCIF_MAP_FIXED is set in the map_flags argument, po will be offset
+ * exactly, and offset is constrained to be a multiple of the page size. The
+ * mapping established by scif_register() will not replace any existing
+ * registration; an error is returned if any page within the range [offset,
+ * offset + len - 1] intersects an existing window.
+ *
+ * When SCIF_MAP_FIXED is not set, the implementation uses offset in an
+ * implementation-defined manner to arrive at po. The po value so chosen will
+ * be an area of the registered address space that the implementation deems
+ * suitable for a mapping of len bytes. An offset value of 0 is interpreted as
+ * granting the implementation complete freedom in selecting po, subject to
+ * constraints described below. A non-zero value of offset is taken to be a
+ * suggestion of an offset near which the mapping should be placed. When the
+ * implementation selects a value for po, it does not replace any extant
+ * window. In all cases, po will be a multiple of the page size.
+ *
+ * The physical pages which are so represented by a window are available for
+ * access in calls to mmap(), scif_readfrom(), scif_writeto(),
+ * scif_vreadfrom(), and scif_vwriteto(). While a window is registered, the
+ * physical pages represented by the window will not be reused by the memory
+ * subsystem for any other purpose. Note that the same physical page may be
+ * represented by multiple windows.
+ *
+ * Subsequent operations which change the memory pages to which virtual
+ * addresses are mapped (such as mmap(), munmap()) have no effect on
+ * existing window.
+ *
+ * If the process will fork(), it is recommended that the registered
+ * virtual address range be marked with MADV_DONTFORK. Doing so will prevent
+ * problems due to copy-on-write semantics.
+ *
+ * The prot_flags argument is formed by OR'ing together one or more of the
+ * following values.
+ * SCIF_PROT_READ - allow read operations from the window
+ * SCIF_PROT_WRITE - allow write operations to the window
+ *
+ * The map_flags argument can be set to SCIF_MAP_FIXED which interprets a
+ * fixed offset.
+ *
+ * Return:
+ * Upon successful completion, scif_register() returns the offset at which the
+ * mapping was placed (po); otherwise in user mode SCIF_REGISTER_FAILED (that
+ * is (off_t *)-1) is returned and errno is set to indicate the error; in
+ * kernel mode the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EADDRINUSE - SCIF_MAP_FIXED is set in map_flags, and pages in the range
+ * [offset, offset + len -1] are already registered
+ * EAGAIN - The mapping could not be performed due to lack of resources
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - Addresses in the range [addr, addr + len - 1] are invalid
+ * EINVAL - map_flags is invalid, or prot_flags is invalid, or SCIF_MAP_FIXED is
+ * set in flags, and offset is not a multiple of the page size, or addr is not a
+ * multiple of the page size, or len is not a multiple of the page size, or is
+ * 0, or offset is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOMEM - Not enough space
+ * ENOTCONN -The endpoint is not connected
+ */
+off_t scif_register(scif_epd_t epd, void *addr, size_t len, off_t offset,
+                    int prot_flags, int map_flags);
+
+/**
+ * scif_unregister() - Mark a memory region for remote access.
+ * @epd:        endpoint descriptor
+ * @offset:     start of range to unregister
+ * @len:        length of range to unregister
+ *
+ * The scif_unregister() function closes those previously registered windows
+ * which are entirely within the range [offset, offset + len - 1]. It is an
+ * error to specify a range which intersects only a subrange of a window.
+ *
+ * On a successful return, pages within the window may no longer be specified
+ * in calls to mmap(), scif_readfrom(), scif_writeto(), scif_vreadfrom(),
+ * scif_vwriteto(), scif_get_pages, and scif_fence_signal(). The window,
+ * however, continues to exist until all previous references against it are
+ * removed. A window is referenced if there is a mapping to it created by
+ * mmap(), or if scif_get_pages() was called against the window
+ * (and the pages have not been returned via scif_put_pages()). A window is
+ * also referenced while an RMA, in which some range of the window is a source
+ * or destination, is in progress. Finally a window is referenced while some
+ * offset in that window was specified to scif_fence_signal(), and the RMAs
+ * marked by that call to scif_fence_signal() have not completed. While a
+ * window is in this state, its registered address space pages are not
+ * available for use in a new registered window.
+ *
+ * When all such references to the window have been removed, its references to
+ * all the physical pages which it represents are removed. Similarly, the
+ * registered address space pages of the window become available for
+ * registration in a new window.
+ *
+ * Return:
+ * Upon successful completion, scif_unregister() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned. In the event of an
+ * error, no windows are unregistered.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - the range [offset, offset + len - 1] intersects a subrange of a
+ * window, or offset is negative
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - Offsets in the range [offset, offset + len - 1] are invalid for the
+ * registered address space of epd
+ */
+int scif_unregister(scif_epd_t epd, off_t offset, size_t len);
+
+/**
+ * scif_readfrom() - Copy from a remote address space
+ * @epd:        endpoint descriptor
+ * @loffset:    offset in local registered address space to
+ *              which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space
+ *              from which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_readfrom() copies len bytes from the remote registered address space of
+ * the peer of endpoint epd, starting at the offset roffset to the local
+ * registered address space of epd, starting at the offset loffset.
+ *
+ * Each of the specified ranges [loffset, loffset + len - 1] and [roffset,
+ * roffset + len - 1] must be within some registered window or windows of the
+ * local and remote nodes. A range may intersect multiple registered windows,
+ * but only if those windows are contiguous in the registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_readfrom() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * The optimal DMA performance will likely be realized if both
+ * loffset and roffset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if loffset and roffset are not
+ * cacheline aligned but are separated by some multiple of 64. The lowest level
+ * of performance is likely if loffset and roffset are not separated by a
+ * multiple of 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *      engine.
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *              the source range becomes visible on the destination node
+ *              after all other transferred data in the source range has
+ *              become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_readfrom() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - The range [loffset, loffset + len - 1] is invalid for the registered
+ * address space of epd, or, The range [roffset, roffset + len - 1] is invalid
+ * for the registered address space of the peer of epd, or loffset or roffset
+ * is negative
+ */
+int scif_readfrom(scif_epd_t epd, off_t loffset, size_t len, off_t
+                  roffset, int rma_flags);
+
+/**
+ * scif_writeto() - Copy to a remote address space
+ * @epd:        endpoint descriptor
+ * @loffset:    offset in local registered address space
+ *              from which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space to
+ *              which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_writeto() copies len bytes from the local registered address space of
+ * epd, starting at the offset loffset to the remote registered address space
+ * of the peer of endpoint epd, starting at the offset roffset.
+ *
+ * Each of the specified ranges [loffset, loffset + len - 1] and [roffset,
+ * roffset + len - 1] must be within some registered window or windows of the
+ * local and remote nodes. A range may intersect multiple registered windows,
+ * but only if those windows are contiguous in the registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_writeto() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * The optimal DMA performance will likely be realized if both
+ * loffset and roffset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if loffset and roffset are not cacheline
+ * aligned but are separated by some multiple of 64. The lowest level of
+ * performance is likely if loffset and roffset are not separated by a multiple
+ * of 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *                      engine.
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *              the source range becomes visible on the destination node
+ *              after all other transferred data in the source range has
+ *              become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_readfrom() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - The range [loffset, loffset + len - 1] is invalid for the registered
+ * address space of epd, or, The range [roffset , roffset + len -1] is invalid
+ * for the registered address space of the peer of epd, or loffset or roffset
+ * is negative
+ */
+int scif_writeto(scif_epd_t epd, off_t loffset, size_t len, off_t
+                 roffset, int rma_flags);
+
+/**
+ * scif_vreadfrom() - Copy from a remote address space
+ * @epd:        endpoint descriptor
+ * @addr:       address to which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space
+ *              from which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_vreadfrom() copies len bytes from the remote registered address
+ * space of the peer of endpoint epd, starting at the offset roffset, to local
+ * memory, starting at addr.
+ *
+ * The specified range [roffset, roffset + len - 1] must be within some
+ * registered window or windows of the remote nodes. The range may
+ * intersect multiple registered windows, but only if those windows are
+ * contiguous in the registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_vreadfrom() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * If rma_flags includes SCIF_RMA_USECACHE, then the physical pages which back
+ * the specified local memory range may be remain in a pinned state even after
+ * the specified transfer completes. This may reduce overhead if some or all of
+ * the same virtual address range is referenced in a subsequent call of
+ * scif_vreadfrom() or scif_vwriteto().
+ *
+ * The optimal DMA performance will likely be realized if both
+ * addr and roffset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if addr and roffset are not
+ * cacheline aligned but are separated by some multiple of 64. The lowest level
+ * of performance is likely if addr and roffset are not separated by a
+ * multiple of 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *      engine.
+ * SCIF_RMA_USECACHE - enable registration caching
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *      the source range becomes visible on the destination node
+ *      after all other transferred data in the source range has
+ *      become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_vreadfrom() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - Addresses in the range [addr, addr + len - 1] are invalid
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - Offsets in the range [roffset, roffset + len - 1] are invalid for the
+ * registered address space of epd
+ */
+int scif_vreadfrom(scif_epd_t epd, void *addr, size_t len, off_t roffset,
+                   int rma_flags);
+
+/**
+ * scif_vwriteto() - Copy to a remote address space
+ * @epd:        endpoint descriptor
+ * @addr:       address from which to copy
+ * @len:        length of range to copy
+ * @roffset:    offset in remote registered address space to
+ *              which to copy
+ * @rma_flags:  transfer mode flags
+ *
+ * scif_vwriteto() copies len bytes from the local memory, starting at addr, to
+ * the remote registered address space of the peer of endpoint epd, starting at
+ * the offset roffset.
+ *
+ * The specified range [roffset, roffset + len - 1] must be within some
+ * registered window or windows of the remote nodes. The range may intersect
+ * multiple registered windows, but only if those windows are contiguous in the
+ * registered address space.
+ *
+ * If rma_flags includes SCIF_RMA_USECPU, then the data is copied using
+ * programmed read/writes. Otherwise the data is copied using DMA. If rma_-
+ * flags includes SCIF_RMA_SYNC, then scif_vwriteto() will return after the
+ * transfer is complete. Otherwise, the transfer may be performed asynchron-
+ * ously. The order in which any two asynchronous RMA operations complete
+ * is non-deterministic. The synchronization functions, scif_fence_mark()/
+ * scif_fence_wait() and scif_fence_signal(), can be used to synchronize to
+ * the completion of asynchronous RMA operations on the same endpoint.
+ *
+ * The DMA transfer of individual bytes is not guaranteed to complete in
+ * address order. If rma_flags includes SCIF_RMA_ORDERED, then the last
+ * cacheline or partial cacheline of the source range will become visible on
+ * the destination node after all other transferred data in the source
+ * range has become visible on the destination node.
+ *
+ * If rma_flags includes SCIF_RMA_USECACHE, then the physical pages which back
+ * the specified local memory range may be remain in a pinned state even after
+ * the specified transfer completes. This may reduce overhead if some or all of
+ * the same virtual address range is referenced in a subsequent call of
+ * scif_vreadfrom() or scif_vwriteto().
+ *
+ * The optimal DMA performance will likely be realized if both
+ * addr and offset are cacheline aligned (are a multiple of 64). Lower
+ * performance will likely be realized if addr and offset are not cacheline
+ * aligned but are separated by some multiple of 64. The lowest level of
+ * performance is likely if addr and offset are not separated by a multiple of
+ * 64.
+ *
+ * The rma_flags argument is formed by ORing together zero or more of the
+ * following values.
+ * SCIF_RMA_USECPU - perform the transfer using the CPU, otherwise use the DMA
+ *      engine.
+ * SCIF_RMA_USECACHE - allow registration caching
+ * SCIF_RMA_SYNC - perform the transfer synchronously, returning after the
+ *              transfer has completed. Passing this flag results in the
+ *              current implementation busy waiting and consuming CPU cycles
+ *              while the DMA transfer is in progress for best performance by
+ *              avoiding the interrupt latency.
+ * SCIF_RMA_ORDERED - ensure that the last cacheline or partial cacheline of
+ *              the source range becomes visible on the destination node
+ *              after all other transferred data in the source range has
+ *              become visible on the destination
+ *
+ * Return:
+ * Upon successful completion, scif_vwriteto() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EACCESS - Attempt to write to a read-only range
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EFAULT - Addresses in the range [addr, addr + len - 1] are invalid
+ * EINVAL - rma_flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - Offsets in the range [roffset, roffset + len - 1] are invalid for the
+ * registered address space of epd
+ */
+int scif_vwriteto(scif_epd_t epd, void *addr, size_t len, off_t roffset,
+                  int rma_flags);
+
+/**
+ * scif_fence_mark() - Mark previously issued RMAs
+ * @epd:        endpoint descriptor
+ * @flags:      control flags
+ * @mark:       marked value returned as output.
+ *
+ * scif_fence_mark() returns after marking the current set of all uncompleted
+ * RMAs initiated through the endpoint epd or the current set of all
+ * uncompleted RMAs initiated through the peer of endpoint epd. The RMAs are
+ * marked with a value returned at mark. The application may subsequently call
+ * scif_fence_wait(), passing the value returned at mark, to await completion
+ * of all RMAs so marked.
+ *
+ * The flags argument has exactly one of the following values.
+ * SCIF_FENCE_INIT_SELF - RMA operations initiated through endpoint
+ *      epd are marked
+ * SCIF_FENCE_INIT_PEER - RMA operations initiated through the peer
+ *      of endpoint epd are marked
+ *
+ * Return:
+ * Upon successful completion, scif_fence_mark() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - flags is invalid
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENOMEM - Insufficient kernel memory was available
+ */
+int scif_fence_mark(scif_epd_t epd, int flags, int *mark);
+
+/**
+ * scif_fence_wait() - Wait for completion of marked RMAs
+ * @epd:        endpoint descriptor
+ * @mark:       mark request
+ *
+ * scif_fence_wait() returns after all RMAs marked with mark have completed.
+ * The value passed in mark must have been obtained in a previous call to
+ * scif_fence_mark().
+ *
+ * Return:
+ * Upon successful completion, scif_fence_wait() returns 0; otherwise in user
+ * mode -1 is returned and errno is set to indicate the error; in kernel mode
+ * the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENOMEM - Insufficient kernel memory was available
+ */
+int scif_fence_wait(scif_epd_t epd, int mark);
+
+/**
+ * scif_fence_signal() - Request a memory update on completion of RMAs
+ * @epd:        endpoint descriptor
+ * @loff:       local offset
+ * @lval:       local value to write to loffset
+ * @roff:       remote offset
+ * @rval:       remote value to write to roffset
+ * @flags:      flags
+ *
+ * scif_fence_signal() returns after marking the current set of all uncompleted
+ * RMAs initiated through the endpoint epd or marking the current set of all
+ * uncompleted RMAs initiated through the peer of endpoint epd.
+ *
+ * If flags includes SCIF_SIGNAL_LOCAL, then on completion of the RMAs in the
+ * marked set, lval is written to memory at the address corresponding to offset
+ * loff in the local registered address space of epd. loff must be within a
+ * registered window. If flags includes SCIF_SIGNAL_REMOTE, then on completion
+ * of the RMAs in the marked set, rval is written to memory at the address
+ * corresponding to offset roff in the remote registered address space of epd.
+ * roff must be within a remote registered window of the peer of epd. Note
+ * that any specified offset must be DWORD (4 byte / 32 bit) aligned.
+ *
+ * The flags argument is formed by OR'ing together the following.
+ * Exactly one of the following values.
+ * SCIF_FENCE_INIT_SELF - RMA operations initiated through endpoint
+ *      epd are marked
+ * SCIF_FENCE_INIT_PEER - RMA operations initiated through the peer
+ *      of endpoint epd are marked
+ * One or more of the following values.
+ * SCIF_SIGNAL_LOCAL - On completion of the marked set of RMAs, write lval to
+ *      memory at the address corresponding to offset loff in the local
+ *      registered address space of epd.
+ * SCIF_SIGNAL_REMOTE - On completion of the marked set of RMAs, write rval to
+ *      memory at the address corresponding to offset roff in the remote
+ *      registered address space of epd.
+ *
+ * Return:
+ * Upon successful completion, scif_fence_signal() returns 0; otherwise in
+ * user mode -1 is returned and errno is set to indicate the error; in kernel
+ * mode the negative of one of the following errors is returned.
+ *
+ * Errors:
+ * EBADF, ENOTTY - epd is not a valid endpoint descriptor
+ * ECONNRESET - Connection reset by peer
+ * EINVAL - flags is invalid, or loff or roff are not DWORD aligned
+ * ENODEV - The remote node is lost or existed, but is not currently in the
+ * network since it may have crashed
+ * ENOTCONN - The endpoint is not connected
+ * ENXIO - loff is invalid for the registered address of epd, or roff is invalid
+ * for the registered address space, of the peer of epd
+ */
+int scif_fence_signal(scif_epd_t epd, off_t loff, u64 lval, off_t roff,
+                      u64 rval, int flags);
+
+/**
+ * scif_get_node_ids() - Return information about online nodes
+ * @nodes:      array in which to return online node IDs
+ * @len:        number of entries in the nodes array
+ * @self:       address to place the node ID of the local node
+ *
+ * scif_get_node_ids() fills in the nodes array with up to len node IDs of the
+ * nodes in the SCIF network. If there is not enough space in nodes, as
+ * indicated by the len parameter, only len node IDs are returned in nodes. The
+ * return value of scif_get_node_ids() is the total number of nodes currently in
+ * the SCIF network. By checking the return value against the len parameter,
+ * the user may determine if enough space for nodes was allocated.
+ *
+ * The node ID of the local node is returned at self.
+ *
+ * Return:
+ * Upon successful completion, scif_get_node_ids() returns the actual number of
+ * online nodes in the SCIF network including 'self'; otherwise in user mode
+ * -1 is returned and errno is set to indicate the error; in kernel mode no
+ * errors are returned.
+ *
+ * Errors:
+ * EFAULT - Bad address
+ */
+int scif_get_node_ids(u16 *nodes, int len, u16 *self);
+
+#endif /* __SCIF_H__ */
diff --git a/include/linux/security.h b/include/linux/security.h
index 52febde52479..79d85ddf8093 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/string.h>
+#include <linux/mm.h>
 
 struct linux_binprm;
 struct cred;
@@ -53,9 +54,6 @@ struct xattr;
 struct xfrm_sec_ctx;
 struct mm_struct;
 
-/* Maximum number of letters for an LSM name string */
-#define SECURITY_NAME_MAX       10
-
 /* If capable should audit the security request */
 #define SECURITY_CAP_NOAUDIT 0
 #define SECURITY_CAP_AUDIT 1
@@ -68,10 +66,7 @@ struct audit_krule;
 struct user_namespace;
 struct timezone;
 
-/*
- * These functions are in security/capability.c and are used
- * as the default capabilities functions
- */
+/* These functions are in security/commoncap.c */
 extern int cap_capable(const struct cred *cred, struct user_namespace *ns,
                        int cap, int audit);
 extern int cap_settime(const struct timespec *ts, const struct timezone *tz);
@@ -113,10 +108,6 @@ struct xfrm_state;
 struct xfrm_user_sec_ctx;
 struct seq_file;
 
-extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb);
-
-void reset_security_ops(void);
-
 #ifdef CONFIG_MMU
 extern unsigned long mmap_min_addr;
 extern unsigned long dac_mmap_min_addr;
@@ -187,1583 +178,8 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
         opts->num_mnt_opts = 0;
 }
 
-/**
- * struct security_operations - main security structure
- *
- * Security module identifier.
- *
- * @name:
- *      A string that acts as a unique identifier for the LSM with max number
- *      of characters = SECURITY_NAME_MAX.
- *
- * Security hooks for program execution operations.
- *
- * @bprm_set_creds:
- *      Save security information in the bprm->security field, typically based
- *      on information about the bprm->file, for later use by the apply_creds
- *      hook.  This hook may also optionally check permissions (e.g. for
- *      transitions between security domains).
- *      This hook may be called multiple times during a single execve, e.g. for
- *      interpreters.  The hook can tell whether it has already been called by
- *      checking to see if @bprm->security is non-NULL.  If so, then the hook
- *      may decide either to retain the security information saved earlier or
- *      to replace it.
- *      @bprm contains the linux_binprm structure.
- *      Return 0 if the hook is successful and permission is granted.
- * @bprm_check_security:
- *      This hook mediates the point when a search for a binary handler will
- *      begin.  It allows a check the @bprm->security value which is set in the
- *      preceding set_creds call.  The primary difference from set_creds is
- *      that the argv list and envp list are reliably available in @bprm.  This
- *      hook may be called multiple times during a single execve; and in each
- *      pass set_creds is called first.
- *      @bprm contains the linux_binprm structure.
- *      Return 0 if the hook is successful and permission is granted.
- * @bprm_committing_creds:
- *      Prepare to install the new security attributes of a process being
- *      transformed by an execve operation, based on the old credentials
- *      pointed to by @current->cred and the information set in @bprm->cred by
- *      the bprm_set_creds hook.  @bprm points to the linux_binprm structure.
- *      This hook is a good place to perform state changes on the process such
- *      as closing open file descriptors to which access will no longer be
- *      granted when the attributes are changed.  This is called immediately
- *      before commit_creds().
- * @bprm_committed_creds:
- *      Tidy up after the installation of the new security attributes of a
- *      process being transformed by an execve operation.  The new credentials
- *      have, by this point, been set to @current->cred.  @bprm points to the
- *      linux_binprm structure.  This hook is a good place to perform state
- *      changes on the process such as clearing out non-inheritable signal
- *      state.  This is called immediately after commit_creds().
- * @bprm_secureexec:
- *      Return a boolean value (0 or 1) indicating whether a "secure exec"
- *      is required.  The flag is passed in the auxiliary table
- *      on the initial stack to the ELF interpreter to indicate whether libc
- *      should enable secure mode.
- *      @bprm contains the linux_binprm structure.
- *
- * Security hooks for filesystem operations.
- *
- * @sb_alloc_security:
- *      Allocate and attach a security structure to the sb->s_security field.
- *      The s_security field is initialized to NULL when the structure is
- *      allocated.
- *      @sb contains the super_block structure to be modified.
- *      Return 0 if operation was successful.
- * @sb_free_security:
- *      Deallocate and clear the sb->s_security field.
- *      @sb contains the super_block structure to be modified.
- * @sb_statfs:
- *      Check permission before obtaining filesystem statistics for the @mnt
- *      mountpoint.
- *      @dentry is a handle on the superblock for the filesystem.
- *      Return 0 if permission is granted.
- * @sb_mount:
- *      Check permission before an object specified by @dev_name is mounted on
- *      the mount point named by @nd.  For an ordinary mount, @dev_name
- *      identifies a device if the file system type requires a device.  For a
- *      remount (@flags & MS_REMOUNT), @dev_name is irrelevant.  For a
- *      loopback/bind mount (@flags & MS_BIND), @dev_name identifies the
- *      pathname of the object being mounted.
- *      @dev_name contains the name for object being mounted.
- *      @path contains the path for mount point object.
- *      @type contains the filesystem type.
- *      @flags contains the mount flags.
- *      @data contains the filesystem-specific data.
- *      Return 0 if permission is granted.
- * @sb_copy_data:
- *      Allow mount option data to be copied prior to parsing by the filesystem,
- *      so that the security module can extract security-specific mount
- *      options cleanly (a filesystem may modify the data e.g. with strsep()).
- *      This also allows the original mount data to be stripped of security-
- *      specific options to avoid having to make filesystems aware of them.
- *      @type the type of filesystem being mounted.
- *      @orig the original mount data copied from userspace.
- *      @copy copied data which will be passed to the security module.
- *      Returns 0 if the copy was successful.
- * @sb_remount:
- *      Extracts security system specific mount options and verifies no changes
- *      are being made to those options.
- *      @sb superblock being remounted
- *      @data contains the filesystem-specific data.
- *      Return 0 if permission is granted.
- * @sb_umount:
- *      Check permission before the @mnt file system is unmounted.
- *      @mnt contains the mounted file system.
- *      @flags contains the unmount flags, e.g. MNT_FORCE.
- *      Return 0 if permission is granted.
- * @sb_pivotroot:
- *      Check permission before pivoting the root filesystem.
- *      @old_path contains the path for the new location of the current root (put_old).
- *      @new_path contains the path for the new root (new_root).
- *      Return 0 if permission is granted.
- * @sb_set_mnt_opts:
- *      Set the security relevant mount options used for a superblock
- *      @sb the superblock to set security mount options for
- *      @opts binary data structure containing all lsm mount data
- * @sb_clone_mnt_opts:
- *      Copy all security options from a given superblock to another
- *      @oldsb old superblock which contain information to clone
- *      @newsb new superblock which needs filled in
- * @sb_parse_opts_str:
- *      Parse a string of security data filling in the opts structure
- *      @options string containing all mount options known by the LSM
- *      @opts binary data structure usable by the LSM
- * @dentry_init_security:
- *      Compute a context for a dentry as the inode is not yet available
- *      since NFSv4 has no label backed by an EA anyway.
- *      @dentry dentry to use in calculating the context.
- *      @mode mode used to determine resource type.
- *      @name name of the last path component used to create file
- *      @ctx pointer to place the pointer to the resulting context in.
- *      @ctxlen point to place the length of the resulting context.
- *
- *
- * Security hooks for inode operations.
- *
- * @inode_alloc_security:
- *      Allocate and attach a security structure to @inode->i_security.  The
- *      i_security field is initialized to NULL when the inode structure is
- *      allocated.
- *      @inode contains the inode structure.
- *      Return 0 if operation was successful.
- * @inode_free_security:
- *      @inode contains the inode structure.
- *      Deallocate the inode security structure and set @inode->i_security to
- *      NULL.
- * @inode_init_security:
- *      Obtain the security attribute name suffix and value to set on a newly
- *      created inode and set up the incore security field for the new inode.
- *      This hook is called by the fs code as part of the inode creation
- *      transaction and provides for atomic labeling of the inode, unlike
- *      the post_create/mkdir/... hooks called by the VFS.  The hook function
- *      is expected to allocate the name and value via kmalloc, with the caller
- *      being responsible for calling kfree after using them.
- *      If the security module does not use security attributes or does
- *      not wish to put a security attribute on this particular inode,
- *      then it should return -EOPNOTSUPP to skip this processing.
- *      @inode contains the inode structure of the newly created inode.
- *      @dir contains the inode structure of the parent directory.
- *      @qstr contains the last path component of the new object
- *      @name will be set to the allocated name suffix (e.g. selinux).
- *      @value will be set to the allocated attribute value.
- *      @len will be set to the length of the value.
- *      Returns 0 if @name and @value have been successfully set,
- *              -EOPNOTSUPP if no security attribute is needed, or
- *              -ENOMEM on memory allocation failure.
- * @inode_create:
- *      Check permission to create a regular file.
- *      @dir contains inode structure of the parent of the new file.
- *      @dentry contains the dentry structure for the file to be created.
- *      @mode contains the file mode of the file to be created.
- *      Return 0 if permission is granted.
- * @inode_link:
- *      Check permission before creating a new hard link to a file.
- *      @old_dentry contains the dentry structure for an existing link to the file.
- *      @dir contains the inode structure of the parent directory of the new link.
- *      @new_dentry contains the dentry structure for the new link.
- *      Return 0 if permission is granted.
- * @path_link:
- *      Check permission before creating a new hard link to a file.
- *      @old_dentry contains the dentry structure for an existing link
- *      to the file.
- *      @new_dir contains the path structure of the parent directory of
- *      the new link.
- *      @new_dentry contains the dentry structure for the new link.
- *      Return 0 if permission is granted.
- * @inode_unlink:
- *      Check the permission to remove a hard link to a file.
- *      @dir contains the inode structure of parent directory of the file.
- *      @dentry contains the dentry structure for file to be unlinked.
- *      Return 0 if permission is granted.
- * @path_unlink:
- *      Check the permission to remove a hard link to a file.
- *      @dir contains the path structure of parent directory of the file.
- *      @dentry contains the dentry structure for file to be unlinked.
- *      Return 0 if permission is granted.
- * @inode_symlink:
- *      Check the permission to create a symbolic link to a file.
- *      @dir contains the inode structure of parent directory of the symbolic link.
- *      @dentry contains the dentry structure of the symbolic link.
- *      @old_name contains the pathname of file.
- *      Return 0 if permission is granted.
- * @path_symlink:
- *      Check the permission to create a symbolic link to a file.
- *      @dir contains the path structure of parent directory of
- *      the symbolic link.
- *      @dentry contains the dentry structure of the symbolic link.
- *      @old_name contains the pathname of file.
- *      Return 0 if permission is granted.
- * @inode_mkdir:
- *      Check permissions to create a new directory in the existing directory
- *      associated with inode structure @dir.
- *      @dir contains the inode structure of parent of the directory to be created.
- *      @dentry contains the dentry structure of new directory.
- *      @mode contains the mode of new directory.
- *      Return 0 if permission is granted.
- * @path_mkdir:
- *      Check permissions to create a new directory in the existing directory
- *      associated with path structure @path.
- *      @dir contains the path structure of parent of the directory
- *      to be created.
- *      @dentry contains the dentry structure of new directory.
- *      @mode contains the mode of new directory.
- *      Return 0 if permission is granted.
- * @inode_rmdir:
- *      Check the permission to remove a directory.
- *      @dir contains the inode structure of parent of the directory to be removed.
- *      @dentry contains the dentry structure of directory to be removed.
- *      Return 0 if permission is granted.
- * @path_rmdir:
- *      Check the permission to remove a directory.
- *      @dir contains the path structure of parent of the directory to be
- *      removed.
- *      @dentry contains the dentry structure of directory to be removed.
- *      Return 0 if permission is granted.
- * @inode_mknod:
- *      Check permissions when creating a special file (or a socket or a fifo
- *      file created via the mknod system call).  Note that if mknod operation
- *      is being done for a regular file, then the create hook will be called
- *      and not this hook.
- *      @dir contains the inode structure of parent of the new file.
- *      @dentry contains the dentry structure of the new file.
- *      @mode contains the mode of the new file.
- *      @dev contains the device number.
- *      Return 0 if permission is granted.
- * @path_mknod:
- *      Check permissions when creating a file. Note that this hook is called
- *      even if mknod operation is being done for a regular file.
- *      @dir contains the path structure of parent of the new file.
- *      @dentry contains the dentry structure of the new file.
- *      @mode contains the mode of the new file.
- *      @dev contains the undecoded device number. Use new_decode_dev() to get
- *      the decoded device number.
- *      Return 0 if permission is granted.
- * @inode_rename:
- *      Check for permission to rename a file or directory.
- *      @old_dir contains the inode structure for parent of the old link.
- *      @old_dentry contains the dentry structure of the old link.
- *      @new_dir contains the inode structure for parent of the new link.
- *      @new_dentry contains the dentry structure of the new link.
- *      Return 0 if permission is granted.
- * @path_rename:
- *      Check for permission to rename a file or directory.
- *      @old_dir contains the path structure for parent of the old link.
- *      @old_dentry contains the dentry structure of the old link.
- *      @new_dir contains the path structure for parent of the new link.
- *      @new_dentry contains the dentry structure of the new link.
- *      Return 0 if permission is granted.
- * @path_chmod:
- *      Check for permission to change DAC's permission of a file or directory.
- *      @dentry contains the dentry structure.
- *      @mnt contains the vfsmnt structure.
- *      @mode contains DAC's mode.
- *      Return 0 if permission is granted.
- * @path_chown:
- *      Check for permission to change owner/group of a file or directory.
- *      @path contains the path structure.
- *      @uid contains new owner's ID.
- *      @gid contains new group's ID.
- *      Return 0 if permission is granted.
- * @path_chroot:
- *      Check for permission to change root directory.
- *      @path contains the path structure.
- *      Return 0 if permission is granted.
- * @inode_readlink:
- *      Check the permission to read the symbolic link.
- *      @dentry contains the dentry structure for the file link.
- *      Return 0 if permission is granted.
- * @inode_follow_link:
- *      Check permission to follow a symbolic link when looking up a pathname.
- *      @dentry contains the dentry structure for the link.
- *      @inode contains the inode, which itself is not stable in RCU-walk
- *      @rcu indicates whether we are in RCU-walk mode.
- *      Return 0 if permission is granted.
- * @inode_permission:
- *      Check permission before accessing an inode.  This hook is called by the
- *      existing Linux permission function, so a security module can use it to
- *      provide additional checking for existing Linux permission checks.
- *      Notice that this hook is called when a file is opened (as well as many
- *      other operations), whereas the file_security_ops permission hook is
- *      called when the actual read/write operations are performed.
- *      @inode contains the inode structure to check.
- *      @mask contains the permission mask.
- *      Return 0 if permission is granted.
- * @inode_setattr:
- *      Check permission before setting file attributes.  Note that the kernel
- *      call to notify_change is performed from several locations, whenever
- *      file attributes change (such as when a file is truncated, chown/chmod
- *      operations, transferring disk quotas, etc).
- *      @dentry contains the dentry structure for the file.
- *      @attr is the iattr structure containing the new file attributes.
- *      Return 0 if permission is granted.
- * @path_truncate:
- *      Check permission before truncating a file.
- *      @path contains the path structure for the file.
- *      Return 0 if permission is granted.
- * @inode_getattr:
- *      Check permission before obtaining file attributes.
- *      @mnt is the vfsmount where the dentry was looked up
- *      @dentry contains the dentry structure for the file.
- *      Return 0 if permission is granted.
- * @inode_setxattr:
- *      Check permission before setting the extended attributes
- *      @value identified by @name for @dentry.
- *      Return 0 if permission is granted.
- * @inode_post_setxattr:
- *      Update inode security field after successful setxattr operation.
- *      @value identified by @name for @dentry.
- * @inode_getxattr:
- *      Check permission before obtaining the extended attributes
- *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
- * @inode_listxattr:
- *      Check permission before obtaining the list of extended attribute
- *      names for @dentry.
- *      Return 0 if permission is granted.
- * @inode_removexattr:
- *      Check permission before removing the extended attribute
- *      identified by @name for @dentry.
- *      Return 0 if permission is granted.
- * @inode_getsecurity:
- *      Retrieve a copy of the extended attribute representation of the
- *      security label associated with @name for @inode via @buffer.  Note that
- *      @name is the remainder of the attribute name after the security prefix
- *      has been removed. @alloc is used to specify of the call should return a
- *      value via the buffer or just the value length Return size of buffer on
- *      success.
- * @inode_setsecurity:
- *      Set the security label associated with @name for @inode from the
- *      extended attribute value @value.  @size indicates the size of the
- *      @value in bytes.  @flags may be XATTR_CREATE, XATTR_REPLACE, or 0.
- *      Note that @name is the remainder of the attribute name after the
- *      security. prefix has been removed.
- *      Return 0 on success.
- * @inode_listsecurity:
- *      Copy the extended attribute names for the security labels
- *      associated with @inode into @buffer.  The maximum size of @buffer
- *      is specified by @buffer_size.  @buffer may be NULL to request
- *      the size of the buffer required.
- *      Returns number of bytes used/required on success.
- * @inode_need_killpriv:
- *      Called when an inode has been changed.
- *      @dentry is the dentry being changed.
- *      Return <0 on error to abort the inode change operation.
- *      Return 0 if inode_killpriv does not need to be called.
- *      Return >0 if inode_killpriv does need to be called.
- * @inode_killpriv:
- *      The setuid bit is being removed.  Remove similar security labels.
- *      Called with the dentry->d_inode->i_mutex held.
- *      @dentry is the dentry being changed.
- *      Return 0 on success.  If error is returned, then the operation
- *      causing setuid bit removal is failed.
- * @inode_getsecid:
- *      Get the secid associated with the node.
- *      @inode contains a pointer to the inode.
- *      @secid contains a pointer to the location where result will be saved.
- *      In case of failure, @secid will be set to zero.
- *
- * Security hooks for file operations
- *
- * @file_permission:
- *      Check file permissions before accessing an open file.  This hook is
- *      called by various operations that read or write files.  A security
- *      module can use this hook to perform additional checking on these
- *      operations, e.g.  to revalidate permissions on use to support privilege
- *      bracketing or policy changes.  Notice that this hook is used when the
- *      actual read/write operations are performed, whereas the
- *      inode_security_ops hook is called when a file is opened (as well as
- *      many other operations).
- *      Caveat:  Although this hook can be used to revalidate permissions for
- *      various system call operations that read or write files, it does not
- *      address the revalidation of permissions for memory-mapped files.
- *      Security modules must handle this separately if they need such
- *      revalidation.
- *      @file contains the file structure being accessed.
- *      @mask contains the requested permissions.
- *      Return 0 if permission is granted.
- * @file_alloc_security:
- *      Allocate and attach a security structure to the file->f_security field.
- *      The security field is initialized to NULL when the structure is first
- *      created.
- *      @file contains the file structure to secure.
- *      Return 0 if the hook is successful and permission is granted.
- * @file_free_security:
- *      Deallocate and free any security structures stored in file->f_security.
- *      @file contains the file structure being modified.
- * @file_ioctl:
- *      @file contains the file structure.
- *      @cmd contains the operation to perform.
- *      @arg contains the operational arguments.
- *      Check permission for an ioctl operation on @file.  Note that @arg
- *      sometimes represents a user space pointer; in other cases, it may be a
- *      simple integer value.  When @arg represents a user space pointer, it
- *      should never be used by the security module.
- *      Return 0 if permission is granted.
- * @mmap_addr :
- *      Check permissions for a mmap operation at @addr.
- *      @addr contains virtual address that will be used for the operation.
- *      Return 0 if permission is granted.
- * @mmap_file :
- *      Check permissions for a mmap operation.  The @file may be NULL, e.g.
- *      if mapping anonymous memory.
- *      @file contains the file structure for file to map (may be NULL).
- *      @reqprot contains the protection requested by the application.
- *      @prot contains the protection that will be applied by the kernel.
- *      @flags contains the operational flags.
- *      Return 0 if permission is granted.
- * @file_mprotect:
- *      Check permissions before changing memory access permissions.
- *      @vma contains the memory region to modify.
- *      @reqprot contains the protection requested by the application.
- *      @prot contains the protection that will be applied by the kernel.
- *      Return 0 if permission is granted.
- * @file_lock:
- *      Check permission before performing file locking operations.
- *      Note: this hook mediates both flock and fcntl style locks.
- *      @file contains the file structure.
- *      @cmd contains the posix-translated lock operation to perform
- *      (e.g. F_RDLCK, F_WRLCK).
- *      Return 0 if permission is granted.
- * @file_fcntl:
- *      Check permission before allowing the file operation specified by @cmd
- *      from being performed on the file @file.  Note that @arg sometimes
- *      represents a user space pointer; in other cases, it may be a simple
- *      integer value.  When @arg represents a user space pointer, it should
- *      never be used by the security module.
- *      @file contains the file structure.
- *      @cmd contains the operation to be performed.
- *      @arg contains the operational arguments.
- *      Return 0 if permission is granted.
- * @file_set_fowner:
- *      Save owner security information (typically from current->security) in
- *      file->f_security for later use by the send_sigiotask hook.
- *      @file contains the file structure to update.
- *      Return 0 on success.
- * @file_send_sigiotask:
- *      Check permission for the file owner @fown to send SIGIO or SIGURG to the
- *      process @tsk.  Note that this hook is sometimes called from interrupt.
- *      Note that the fown_struct, @fown, is never outside the context of a
- *      struct file, so the file structure (and associated security information)
- *      can always be obtained:
- *              container_of(fown, struct file, f_owner)
- *      @tsk contains the structure of task receiving signal.
- *      @fown contains the file owner information.
- *      @sig is the signal that will be sent.  When 0, kernel sends SIGIO.
- *      Return 0 if permission is granted.
- * @file_receive:
- *      This hook allows security modules to control the ability of a process
- *      to receive an open file descriptor via socket IPC.
- *      @file contains the file structure being received.
- *      Return 0 if permission is granted.
- * @file_open
- *      Save open-time permission checking state for later use upon
- *      file_permission, and recheck access if anything has changed
- *      since inode_permission.
- *
- * Security hooks for task operations.
- *
- * @task_create:
- *      Check permission before creating a child process.  See the clone(2)
- *      manual page for definitions of the @clone_flags.
- *      @clone_flags contains the flags indicating what should be shared.
- *      Return 0 if permission is granted.
- * @task_free:
- *      @task task being freed
- *      Handle release of task-related resources. (Note that this can be called
- *      from interrupt context.)
- * @cred_alloc_blank:
- *      @cred points to the credentials.
- *      @gfp indicates the atomicity of any memory allocations.
- *      Only allocate sufficient memory and attach to @cred such that
- *      cred_transfer() will not get ENOMEM.
- * @cred_free:
- *      @cred points to the credentials.
- *      Deallocate and clear the cred->security field in a set of credentials.
- * @cred_prepare:
- *      @new points to the new credentials.
- *      @old points to the original credentials.
- *      @gfp indicates the atomicity of any memory allocations.
- *      Prepare a new set of credentials by copying the data from the old set.
- * @cred_transfer:
- *      @new points to the new credentials.
- *      @old points to the original credentials.
- *      Transfer data from original creds to new creds
- * @kernel_act_as:
- *      Set the credentials for a kernel service to act as (subjective context).
- *      @new points to the credentials to be modified.
- *      @secid specifies the security ID to be set
- *      The current task must be the one that nominated @secid.
- *      Return 0 if successful.
- * @kernel_create_files_as:
- *      Set the file creation context in a set of credentials to be the same as
- *      the objective context of the specified inode.
- *      @new points to the credentials to be modified.
- *      @inode points to the inode to use as a reference.
- *      The current task must be the one that nominated @inode.
- *      Return 0 if successful.
- * @kernel_fw_from_file:
- *      Load firmware from userspace (not called for built-in firmware).
- *      @file contains the file structure pointing to the file containing
- *      the firmware to load. This argument will be NULL if the firmware
- *      was loaded via the uevent-triggered blob-based interface exposed
- *      by CONFIG_FW_LOADER_USER_HELPER.
- *      @buf pointer to buffer containing firmware contents.
- *      @size length of the firmware contents.
- *      Return 0 if permission is granted.
- * @kernel_module_request:
- *      Ability to trigger the kernel to automatically upcall to userspace for
- *      userspace to load a kernel module with the given name.
- *      @kmod_name name of the module requested by the kernel
- *      Return 0 if successful.
- * @kernel_module_from_file:
- *      Load a kernel module from userspace.
- *      @file contains the file structure pointing to the file containing
- *      the kernel module to load. If the module is being loaded from a blob,
- *      this argument will be NULL.
- *      Return 0 if permission is granted.
- * @task_fix_setuid:
- *      Update the module's state after setting one or more of the user
- *      identity attributes of the current process.  The @flags parameter
- *      indicates which of the set*uid system calls invoked this hook.  If
- *      @new is the set of credentials that will be installed.  Modifications
- *      should be made to this rather than to @current->cred.
- *      @old is the set of credentials that are being replaces
- *      @flags contains one of the LSM_SETID_* values.
- *      Return 0 on success.
- * @task_setpgid:
- *      Check permission before setting the process group identifier of the
- *      process @p to @pgid.
- *      @p contains the task_struct for process being modified.
- *      @pgid contains the new pgid.
- *      Return 0 if permission is granted.
- * @task_getpgid:
- *      Check permission before getting the process group identifier of the
- *      process @p.
- *      @p contains the task_struct for the process.
- *      Return 0 if permission is granted.
- * @task_getsid:
- *      Check permission before getting the session identifier of the process
- *      @p.
- *      @p contains the task_struct for the process.
- *      Return 0 if permission is granted.
- * @task_getsecid:
- *      Retrieve the security identifier of the process @p.
- *      @p contains the task_struct for the process and place is into @secid.
- *      In case of failure, @secid will be set to zero.
- *
- * @task_setnice:
- *      Check permission before setting the nice value of @p to @nice.
- *      @p contains the task_struct of process.
- *      @nice contains the new nice value.
- *      Return 0 if permission is granted.
- * @task_setioprio
- *      Check permission before setting the ioprio value of @p to @ioprio.
- *      @p contains the task_struct of process.
- *      @ioprio contains the new ioprio value
- *      Return 0 if permission is granted.
- * @task_getioprio
- *      Check permission before getting the ioprio value of @p.
- *      @p contains the task_struct of process.
- *      Return 0 if permission is granted.
- * @task_setrlimit:
- *      Check permission before setting the resource limits of the current
- *      process for @resource to @new_rlim.  The old resource limit values can
- *      be examined by dereferencing (current->signal->rlim + resource).
- *      @resource contains the resource whose limit is being set.
- *      @new_rlim contains the new limits for @resource.
- *      Return 0 if permission is granted.
- * @task_setscheduler:
- *      Check permission before setting scheduling policy and/or parameters of
- *      process @p based on @policy and @lp.
- *      @p contains the task_struct for process.
- *      @policy contains the scheduling policy.
- *      @lp contains the scheduling parameters.
- *      Return 0 if permission is granted.
- * @task_getscheduler:
- *      Check permission before obtaining scheduling information for process
- *      @p.
- *      @p contains the task_struct for process.
- *      Return 0 if permission is granted.
- * @task_movememory
- *      Check permission before moving memory owned by process @p.
- *      @p contains the task_struct for process.
- *      Return 0 if permission is granted.
- * @task_kill:
- *      Check permission before sending signal @sig to @p.  @info can be NULL,
- *      the constant 1, or a pointer to a siginfo structure.  If @info is 1 or
- *      SI_FROMKERNEL(info) is true, then the signal should be viewed as coming
- *      from the kernel and should typically be permitted.
- *      SIGIO signals are handled separately by the send_sigiotask hook in
- *      file_security_ops.
- *      @p contains the task_struct for process.
- *      @info contains the signal information.
- *      @sig contains the signal value.
- *      @secid contains the sid of the process where the signal originated
- *      Return 0 if permission is granted.
- * @task_wait:
- *      Check permission before allowing a process to reap a child process @p
- *      and collect its status information.
- *      @p contains the task_struct for process.
- *      Return 0 if permission is granted.
- * @task_prctl:
- *      Check permission before performing a process control operation on the
- *      current process.
- *      @option contains the operation.
- *      @arg2 contains a argument.
- *      @arg3 contains a argument.
- *      @arg4 contains a argument.
- *      @arg5 contains a argument.
- *      Return -ENOSYS if no-one wanted to handle this op, any other value to
- *      cause prctl() to return immediately with that value.
- * @task_to_inode:
- *      Set the security attributes for an inode based on an associated task's
- *      security attributes, e.g. for /proc/pid inodes.
- *      @p contains the task_struct for the task.
- *      @inode contains the inode structure for the inode.
- *
- * Security hooks for Netlink messaging.
- *
- * @netlink_send:
- *      Save security information for a netlink message so that permission
- *      checking can be performed when the message is processed.  The security
- *      information can be saved using the eff_cap field of the
- *      netlink_skb_parms structure.  Also may be used to provide fine
- *      grained control over message transmission.
- *      @sk associated sock of task sending the message.
- *      @skb contains the sk_buff structure for the netlink message.
- *      Return 0 if the information was successfully saved and message
- *      is allowed to be transmitted.
- *
- * Security hooks for Unix domain networking.
- *
- * @unix_stream_connect:
- *      Check permissions before establishing a Unix domain stream connection
- *      between @sock and @other.
- *      @sock contains the sock structure.
- *      @other contains the peer sock structure.
- *      @newsk contains the new sock structure.
- *      Return 0 if permission is granted.
- * @unix_may_send:
- *      Check permissions before connecting or sending datagrams from @sock to
- *      @other.
- *      @sock contains the socket structure.
- *      @other contains the peer socket structure.
- *      Return 0 if permission is granted.
- *
- * The @unix_stream_connect and @unix_may_send hooks were necessary because
- * Linux provides an alternative to the conventional file name space for Unix
- * domain sockets.  Whereas binding and connecting to sockets in the file name
- * space is mediated by the typical file permissions (and caught by the mknod
- * and permission hooks in inode_security_ops), binding and connecting to
- * sockets in the abstract name space is completely unmediated.  Sufficient
- * control of Unix domain sockets in the abstract name space isn't possible
- * using only the socket layer hooks, since we need to know the actual target
- * socket, which is not looked up until we are inside the af_unix code.
- *
- * Security hooks for socket operations.
- *
- * @socket_create:
- *      Check permissions prior to creating a new socket.
- *      @family contains the requested protocol family.
- *      @type contains the requested communications type.
- *      @protocol contains the requested protocol.
- *      @kern set to 1 if a kernel socket.
- *      Return 0 if permission is granted.
- * @socket_post_create:
- *      This hook allows a module to update or allocate a per-socket security
- *      structure. Note that the security field was not added directly to the
- *      socket structure, but rather, the socket security information is stored
- *      in the associated inode.  Typically, the inode alloc_security hook will
- *      allocate and and attach security information to
- *      sock->inode->i_security.  This hook may be used to update the
- *      sock->inode->i_security field with additional information that wasn't
- *      available when the inode was allocated.
- *      @sock contains the newly created socket structure.
- *      @family contains the requested protocol family.
- *      @type contains the requested communications type.
- *      @protocol contains the requested protocol.
- *      @kern set to 1 if a kernel socket.
- * @socket_bind:
- *      Check permission before socket protocol layer bind operation is
- *      performed and the socket @sock is bound to the address specified in the
- *      @address parameter.
- *      @sock contains the socket structure.
- *      @address contains the address to bind to.
- *      @addrlen contains the length of address.
- *      Return 0 if permission is granted.
- * @socket_connect:
- *      Check permission before socket protocol layer connect operation
- *      attempts to connect socket @sock to a remote address, @address.
- *      @sock contains the socket structure.
- *      @address contains the address of remote endpoint.
- *      @addrlen contains the length of address.
- *      Return 0 if permission is granted.
- * @socket_listen:
- *      Check permission before socket protocol layer listen operation.
- *      @sock contains the socket structure.
- *      @backlog contains the maximum length for the pending connection queue.
- *      Return 0 if permission is granted.
- * @socket_accept:
- *      Check permission before accepting a new connection.  Note that the new
- *      socket, @newsock, has been created and some information copied to it,
- *      but the accept operation has not actually been performed.
- *      @sock contains the listening socket structure.
- *      @newsock contains the newly created server socket for connection.
- *      Return 0 if permission is granted.
- * @socket_sendmsg:
- *      Check permission before transmitting a message to another socket.
- *      @sock contains the socket structure.
- *      @msg contains the message to be transmitted.
- *      @size contains the size of message.
- *      Return 0 if permission is granted.
- * @socket_recvmsg:
- *      Check permission before receiving a message from a socket.
- *      @sock contains the socket structure.
- *      @msg contains the message structure.
- *      @size contains the size of message structure.
- *      @flags contains the operational flags.
- *      Return 0 if permission is granted.
- * @socket_getsockname:
- *      Check permission before the local address (name) of the socket object
- *      @sock is retrieved.
- *      @sock contains the socket structure.
- *      Return 0 if permission is granted.
- * @socket_getpeername:
- *      Check permission before the remote address (name) of a socket object
- *      @sock is retrieved.
- *      @sock contains the socket structure.
- *      Return 0 if permission is granted.
- * @socket_getsockopt:
- *      Check permissions before retrieving the options associated with socket
- *      @sock.
- *      @sock contains the socket structure.
- *      @level contains the protocol level to retrieve option from.
- *      @optname contains the name of option to retrieve.
- *      Return 0 if permission is granted.
- * @socket_setsockopt:
- *      Check permissions before setting the options associated with socket
- *      @sock.
- *      @sock contains the socket structure.
- *      @level contains the protocol level to set options for.
- *      @optname contains the name of the option to set.
- *      Return 0 if permission is granted.
- * @socket_shutdown:
- *      Checks permission before all or part of a connection on the socket
- *      @sock is shut down.
- *      @sock contains the socket structure.
- *      @how contains the flag indicating how future sends and receives are handled.
- *      Return 0 if permission is granted.
- * @socket_sock_rcv_skb:
- *      Check permissions on incoming network packets.  This hook is distinct
- *      from Netfilter's IP input hooks since it is the first time that the
- *      incoming sk_buff @skb has been associated with a particular socket, @sk.
- *      Must not sleep inside this hook because some callers hold spinlocks.
- *      @sk contains the sock (not socket) associated with the incoming sk_buff.
- *      @skb contains the incoming network data.
- * @socket_getpeersec_stream:
- *      This hook allows the security module to provide peer socket security
- *      state for unix or connected tcp sockets to userspace via getsockopt
- *      SO_GETPEERSEC.  For tcp sockets this can be meaningful if the
- *      socket is associated with an ipsec SA.
- *      @sock is the local socket.
- *      @optval userspace memory where the security state is to be copied.
- *      @optlen userspace int where the module should copy the actual length
- *      of the security state.
- *      @len as input is the maximum length to copy to userspace provided
- *      by the caller.
- *      Return 0 if all is well, otherwise, typical getsockopt return
- *      values.
- * @socket_getpeersec_dgram:
- *      This hook allows the security module to provide peer socket security
- *      state for udp sockets on a per-packet basis to userspace via
- *      getsockopt SO_GETPEERSEC.  The application must first have indicated
- *      the IP_PASSSEC option via getsockopt.  It can then retrieve the
- *      security state returned by this hook for a packet via the SCM_SECURITY
- *      ancillary message type.
- *      @skb is the skbuff for the packet being queried
- *      @secdata is a pointer to a buffer in which to copy the security data
- *      @seclen is the maximum length for @secdata
- *      Return 0 on success, error on failure.
- * @sk_alloc_security:
- *      Allocate and attach a security structure to the sk->sk_security field,
- *      which is used to copy security attributes between local stream sockets.
- * @sk_free_security:
- *      Deallocate security structure.
- * @sk_clone_security:
- *      Clone/copy security structure.
- * @sk_getsecid:
- *      Retrieve the LSM-specific secid for the sock to enable caching of network
- *      authorizations.
- * @sock_graft:
- *      Sets the socket's isec sid to the sock's sid.
- * @inet_conn_request:
- *      Sets the openreq's sid to socket's sid with MLS portion taken from peer sid.
- * @inet_csk_clone:
- *      Sets the new child socket's sid to the openreq sid.
- * @inet_conn_established:
- *      Sets the connection's peersid to the secmark on skb.
- * @secmark_relabel_packet:
- *      check if the process should be allowed to relabel packets to the given secid
- * @security_secmark_refcount_inc
- *      tells the LSM to increment the number of secmark labeling rules loaded
- * @security_secmark_refcount_dec
- *      tells the LSM to decrement the number of secmark labeling rules loaded
- * @req_classify_flow:
- *      Sets the flow's sid to the openreq sid.
- * @tun_dev_alloc_security:
- *      This hook allows a module to allocate a security structure for a TUN
- *      device.
- *      @security pointer to a security structure pointer.
- *      Returns a zero on success, negative values on failure.
- * @tun_dev_free_security:
- *      This hook allows a module to free the security structure for a TUN
- *      device.
- *      @security pointer to the TUN device's security structure
- * @tun_dev_create:
- *      Check permissions prior to creating a new TUN device.
- * @tun_dev_attach_queue:
- *      Check permissions prior to attaching to a TUN device queue.
- *      @security pointer to the TUN device's security structure.
- * @tun_dev_attach:
- *      This hook can be used by the module to update any security state
- *      associated with the TUN device's sock structure.
- *      @sk contains the existing sock structure.
- *      @security pointer to the TUN device's security structure.
- * @tun_dev_open:
- *      This hook can be used by the module to update any security state
- *      associated with the TUN device's security structure.
- *      @security pointer to the TUN devices's security structure.
- * @skb_owned_by:
- *      This hook sets the packet's owning sock.
- *      @skb is the packet.
- *      @sk the sock which owns the packet.
- *
- * Security hooks for XFRM operations.
- *
- * @xfrm_policy_alloc_security:
- *      @ctxp is a pointer to the xfrm_sec_ctx being added to Security Policy
- *      Database used by the XFRM system.
- *      @sec_ctx contains the security context information being provided by
- *      the user-level policy update program (e.g., setkey).
- *      Allocate a security structure to the xp->security field; the security
- *      field is initialized to NULL when the xfrm_policy is allocated.
- *      Return 0 if operation was successful (memory to allocate, legal context)
- *      @gfp is to specify the context for the allocation
- * @xfrm_policy_clone_security:
- *      @old_ctx contains an existing xfrm_sec_ctx.
- *      @new_ctxp contains a new xfrm_sec_ctx being cloned from old.
- *      Allocate a security structure in new_ctxp that contains the
- *      information from the old_ctx structure.
- *      Return 0 if operation was successful (memory to allocate).
- * @xfrm_policy_free_security:
- *      @ctx contains the xfrm_sec_ctx
- *      Deallocate xp->security.
- * @xfrm_policy_delete_security:
- *      @ctx contains the xfrm_sec_ctx.
- *      Authorize deletion of xp->security.
- * @xfrm_state_alloc:
- *      @x contains the xfrm_state being added to the Security Association
- *      Database by the XFRM system.
- *      @sec_ctx contains the security context information being provided by
- *      the user-level SA generation program (e.g., setkey or racoon).
- *      Allocate a security structure to the x->security field; the security
- *      field is initialized to NULL when the xfrm_state is allocated. Set the
- *      context to correspond to sec_ctx. Return 0 if operation was successful
- *      (memory to allocate, legal context).
- * @xfrm_state_alloc_acquire:
- *      @x contains the xfrm_state being added to the Security Association
- *      Database by the XFRM system.
- *      @polsec contains the policy's security context.
- *      @secid contains the secid from which to take the mls portion of the
- *      context.
- *      Allocate a security structure to the x->security field; the security
- *      field is initialized to NULL when the xfrm_state is allocated. Set the
- *      context to correspond to secid. Return 0 if operation was successful
- *      (memory to allocate, legal context).
- * @xfrm_state_free_security:
- *      @x contains the xfrm_state.
- *      Deallocate x->security.
- * @xfrm_state_delete_security:
- *      @x contains the xfrm_state.
- *      Authorize deletion of x->security.
- * @xfrm_policy_lookup:
- *      @ctx contains the xfrm_sec_ctx for which the access control is being
- *      checked.
- *      @fl_secid contains the flow security label that is used to authorize
- *      access to the policy xp.
- *      @dir contains the direction of the flow (input or output).
- *      Check permission when a flow selects a xfrm_policy for processing
- *      XFRMs on a packet.  The hook is called when selecting either a
- *      per-socket policy or a generic xfrm policy.
- *      Return 0 if permission is granted, -ESRCH otherwise, or -errno
- *      on other errors.
- * @xfrm_state_pol_flow_match:
- *      @x contains the state to match.
- *      @xp contains the policy to check for a match.
- *      @fl contains the flow to check for a match.
- *      Return 1 if there is a match.
- * @xfrm_decode_session:
- *      @skb points to skb to decode.
- *      @secid points to the flow key secid to set.
- *      @ckall says if all xfrms used should be checked for same secid.
- *      Return 0 if ckall is zero or all xfrms used have the same secid.
- *
- * Security hooks affecting all Key Management operations
- *
- * @key_alloc:
- *      Permit allocation of a key and assign security data. Note that key does
- *      not have a serial number assigned at this point.
- *      @key points to the key.
- *      @flags is the allocation flags
- *      Return 0 if permission is granted, -ve error otherwise.
- * @key_free:
- *      Notification of destruction; free security data.
- *      @key points to the key.
- *      No return value.
- * @key_permission:
- *      See whether a specific operational right is granted to a process on a
- *      key.
- *      @key_ref refers to the key (key pointer + possession attribute bit).
- *      @cred points to the credentials to provide the context against which to
- *      evaluate the security data on the key.
- *      @perm describes the combination of permissions required of this key.
- *      Return 0 if permission is granted, -ve error otherwise.
- * @key_getsecurity:
- *      Get a textual representation of the security context attached to a key
- *      for the purposes of honouring KEYCTL_GETSECURITY.  This function
- *      allocates the storage for the NUL-terminated string and the caller
- *      should free it.
- *      @key points to the key to be queried.
- *      @_buffer points to a pointer that should be set to point to the
- *      resulting string (if no label or an error occurs).
- *      Return the length of the string (including terminating NUL) or -ve if
- *      an error.
- *      May also return 0 (and a NULL buffer pointer) if there is no label.
- *
- * Security hooks affecting all System V IPC operations.
- *
- * @ipc_permission:
- *      Check permissions for access to IPC
- *      @ipcp contains the kernel IPC permission structure
- *      @flag contains the desired (requested) permission set
- *      Return 0 if permission is granted.
- * @ipc_getsecid:
- *      Get the secid associated with the ipc object.
- *      @ipcp contains the kernel IPC permission structure.
- *      @secid contains a pointer to the location where result will be saved.
- *      In case of failure, @secid will be set to zero.
- *
- * Security hooks for individual messages held in System V IPC message queues
- * @msg_msg_alloc_security:
- *      Allocate and attach a security structure to the msg->security field.
- *      The security field is initialized to NULL when the structure is first
- *      created.
- *      @msg contains the message structure to be modified.
- *      Return 0 if operation was successful and permission is granted.
- * @msg_msg_free_security:
- *      Deallocate the security structure for this message.
- *      @msg contains the message structure to be modified.
- *
- * Security hooks for System V IPC Message Queues
- *
- * @msg_queue_alloc_security:
- *      Allocate and attach a security structure to the
- *      msq->q_perm.security field. The security field is initialized to
- *      NULL when the structure is first created.
- *      @msq contains the message queue structure to be modified.
- *      Return 0 if operation was successful and permission is granted.
- * @msg_queue_free_security:
- *      Deallocate security structure for this message queue.
- *      @msq contains the message queue structure to be modified.
- * @msg_queue_associate:
- *      Check permission when a message queue is requested through the
- *      msgget system call.  This hook is only called when returning the
- *      message queue identifier for an existing message queue, not when a
- *      new message queue is created.
- *      @msq contains the message queue to act upon.
- *      @msqflg contains the operation control flags.
- *      Return 0 if permission is granted.
- * @msg_queue_msgctl:
- *      Check permission when a message control operation specified by @cmd
- *      is to be performed on the message queue @msq.
- *      The @msq may be NULL, e.g. for IPC_INFO or MSG_INFO.
- *      @msq contains the message queue to act upon.  May be NULL.
- *      @cmd contains the operation to be performed.
- *      Return 0 if permission is granted.
- * @msg_queue_msgsnd:
- *      Check permission before a message, @msg, is enqueued on the message
- *      queue, @msq.
- *      @msq contains the message queue to send message to.
- *      @msg contains the message to be enqueued.
- *      @msqflg contains operational flags.
- *      Return 0 if permission is granted.
- * @msg_queue_msgrcv:
- *      Check permission before a message, @msg, is removed from the message
- *      queue, @msq.  The @target task structure contains a pointer to the
- *      process that will be receiving the message (not equal to the current
- *      process when inline receives are being performed).
- *      @msq contains the message queue to retrieve message from.
- *      @msg contains the message destination.
- *      @target contains the task structure for recipient process.
- *      @type contains the type of message requested.
- *      @mode contains the operational flags.
- *      Return 0 if permission is granted.
- *
- * Security hooks for System V Shared Memory Segments
- *
- * @shm_alloc_security:
- *      Allocate and attach a security structure to the shp->shm_perm.security
- *      field.  The security field is initialized to NULL when the structure is
- *      first created.
- *      @shp contains the shared memory structure to be modified.
- *      Return 0 if operation was successful and permission is granted.
- * @shm_free_security:
- *      Deallocate the security struct for this memory segment.
- *      @shp contains the shared memory structure to be modified.
- * @shm_associate:
- *      Check permission when a shared memory region is requested through the
- *      shmget system call.  This hook is only called when returning the shared
- *      memory region identifier for an existing region, not when a new shared
- *      memory region is created.
- *      @shp contains the shared memory structure to be modified.
- *      @shmflg contains the operation control flags.
- *      Return 0 if permission is granted.
- * @shm_shmctl:
- *      Check permission when a shared memory control operation specified by
- *      @cmd is to be performed on the shared memory region @shp.
- *      The @shp may be NULL, e.g. for IPC_INFO or SHM_INFO.
- *      @shp contains shared memory structure to be modified.
- *      @cmd contains the operation to be performed.
- *      Return 0 if permission is granted.
- * @shm_shmat:
- *      Check permissions prior to allowing the shmat system call to attach the
- *      shared memory segment @shp to the data segment of the calling process.
- *      The attaching address is specified by @shmaddr.
- *      @shp contains the shared memory structure to be modified.
- *      @shmaddr contains the address to attach memory region to.
- *      @shmflg contains the operational flags.
- *      Return 0 if permission is granted.
- *
- * Security hooks for System V Semaphores
- *
- * @sem_alloc_security:
- *      Allocate and attach a security structure to the sma->sem_perm.security
- *      field.  The security field is initialized to NULL when the structure is
- *      first created.
- *      @sma contains the semaphore structure
- *      Return 0 if operation was successful and permission is granted.
- * @sem_free_security:
- *      deallocate security struct for this semaphore
- *      @sma contains the semaphore structure.
- * @sem_associate:
- *      Check permission when a semaphore is requested through the semget
- *      system call.  This hook is only called when returning the semaphore
- *      identifier for an existing semaphore, not when a new one must be
- *      created.
- *      @sma contains the semaphore structure.
- *      @semflg contains the operation control flags.
- *      Return 0 if permission is granted.
- * @sem_semctl:
- *      Check permission when a semaphore operation specified by @cmd is to be
- *      performed on the semaphore @sma.  The @sma may be NULL, e.g. for
- *      IPC_INFO or SEM_INFO.
- *      @sma contains the semaphore structure.  May be NULL.
- *      @cmd contains the operation to be performed.
- *      Return 0 if permission is granted.
- * @sem_semop
- *      Check permissions before performing operations on members of the
- *      semaphore set @sma.  If the @alter flag is nonzero, the semaphore set
- *      may be modified.
- *      @sma contains the semaphore structure.
- *      @sops contains the operations to perform.
- *      @nsops contains the number of operations to perform.
- *      @alter contains the flag indicating whether changes are to be made.
- *      Return 0 if permission is granted.
- *
- * @binder_set_context_mgr
- *      Check whether @mgr is allowed to be the binder context manager.
- *      @mgr contains the task_struct for the task being registered.
- *      Return 0 if permission is granted.
- * @binder_transaction
- *      Check whether @from is allowed to invoke a binder transaction call
- *      to @to.
- *      @from contains the task_struct for the sending task.
- *      @to contains the task_struct for the receiving task.
- * @binder_transfer_binder
- *      Check whether @from is allowed to transfer a binder reference to @to.
- *      @from contains the task_struct for the sending task.
- *      @to contains the task_struct for the receiving task.
- * @binder_transfer_file
- *      Check whether @from is allowed to transfer @file to @to.
- *      @from contains the task_struct for the sending task.
- *      @file contains the struct file being transferred.
- *      @to contains the task_struct for the receiving task.
- *
- * @ptrace_access_check:
- *      Check permission before allowing the current process to trace the
- *      @child process.
- *      Security modules may also want to perform a process tracing check
- *      during an execve in the set_security or apply_creds hooks of
- *      tracing check during an execve in the bprm_set_creds hook of
- *      binprm_security_ops if the process is being traced and its security
- *      attributes would be changed by the execve.
- *      @child contains the task_struct structure for the target process.
- *      @mode contains the PTRACE_MODE flags indicating the form of access.
- *      Return 0 if permission is granted.
- * @ptrace_traceme:
- *      Check that the @parent process has sufficient permission to trace the
- *      current process before allowing the current process to present itself
- *      to the @parent process for tracing.
- *      @parent contains the task_struct structure for debugger process.
- *      Return 0 if permission is granted.
- * @capget:
- *      Get the @effective, @inheritable, and @permitted capability sets for
- *      the @target process.  The hook may also perform permission checking to
- *      determine if the current process is allowed to see the capability sets
- *      of the @target process.
- *      @target contains the task_struct structure for target process.
- *      @effective contains the effective capability set.
- *      @inheritable contains the inheritable capability set.
- *      @permitted contains the permitted capability set.
- *      Return 0 if the capability sets were successfully obtained.
- * @capset:
- *      Set the @effective, @inheritable, and @permitted capability sets for
- *      the current process.
- *      @new contains the new credentials structure for target process.
- *      @old contains the current credentials structure for target process.
- *      @effective contains the effective capability set.
- *      @inheritable contains the inheritable capability set.
- *      @permitted contains the permitted capability set.
- *      Return 0 and update @new if permission is granted.
- * @capable:
- *      Check whether the @tsk process has the @cap capability in the indicated
- *      credentials.
- *      @cred contains the credentials to use.
- *      @ns contains the user namespace we want the capability in
- *      @cap contains the capability <include/linux/capability.h>.
- *      @audit: Whether to write an audit message or not
- *      Return 0 if the capability is granted for @tsk.
- * @syslog:
- *      Check permission before accessing the kernel message ring or changing
- *      logging to the console.
- *      See the syslog(2) manual page for an explanation of the @type values.
- *      @type contains the type of action.
- *      @from_file indicates the context of action (if it came from /proc).
- *      Return 0 if permission is granted.
- * @settime:
- *      Check permission to change the system time.
- *      struct timespec and timezone are defined in include/linux/time.h
- *      @ts contains new time
- *      @tz contains new timezone
- *      Return 0 if permission is granted.
- * @vm_enough_memory:
- *      Check permissions for allocating a new virtual mapping.
- *      @mm contains the mm struct it is being added to.
- *      @pages contains the number of pages.
- *      Return 0 if permission is granted.
- *
- * @ismaclabel:
- *      Check if the extended attribute specified by @name
- *      represents a MAC label. Returns 1 if name is a MAC
- *      attribute otherwise returns 0.
- *      @name full extended attribute name to check against
- *      LSM as a MAC label.
- *
- * @secid_to_secctx:
- *      Convert secid to security context.  If secdata is NULL the length of
- *      the result will be returned in seclen, but no secdata will be returned.
- *      This does mean that the length could change between calls to check the
- *      length and the next call which actually allocates and returns the secdata.
- *      @secid contains the security ID.
- *      @secdata contains the pointer that stores the converted security context.
- *      @seclen pointer which contains the length of the data
- * @secctx_to_secid:
- *      Convert security context to secid.
- *      @secid contains the pointer to the generated security ID.
- *      @secdata contains the security context.
- *
- * @release_secctx:
- *      Release the security context.
- *      @secdata contains the security context.
- *      @seclen contains the length of the security context.
- *
- * Security hooks for Audit
- *
- * @audit_rule_init:
- *      Allocate and initialize an LSM audit rule structure.
- *      @field contains the required Audit action. Fields flags are defined in include/linux/audit.h
- *      @op contains the operator the rule uses.
- *      @rulestr contains the context where the rule will be applied to.
- *      @lsmrule contains a pointer to receive the result.
- *      Return 0 if @lsmrule has been successfully set,
- *      -EINVAL in case of an invalid rule.
- *
- * @audit_rule_known:
- *      Specifies whether given @rule contains any fields related to current LSM.
- *      @rule contains the audit rule of interest.
- *      Return 1 in case of relation found, 0 otherwise.
- *
- * @audit_rule_match:
- *      Determine if given @secid matches a rule previously approved
- *      by @audit_rule_known.
- *      @secid contains the security id in question.
- *      @field contains the field which relates to current LSM.
- *      @op contains the operator that will be used for matching.
- *      @rule points to the audit rule that will be checked against.
- *      @actx points to the audit context associated with the check.
- *      Return 1 if secid matches the rule, 0 if it does not, -ERRNO on failure.
- *
- * @audit_rule_free:
- *      Deallocate the LSM audit rule structure previously allocated by
- *      audit_rule_init.
- *      @rule contains the allocated rule
- *
- * @inode_notifysecctx:
- *      Notify the security module of what the security context of an inode
- *      should be.  Initializes the incore security context managed by the
- *      security module for this inode.  Example usage:  NFS client invokes
- *      this hook to initialize the security context in its incore inode to the
- *      value provided by the server for the file when the server returned the
- *      file's attributes to the client.
- *
- *      Must be called with inode->i_mutex locked.
- *
- *      @inode we wish to set the security context of.
- *      @ctx contains the string which we wish to set in the inode.
- *      @ctxlen contains the length of @ctx.
- *
- * @inode_setsecctx:
- *      Change the security context of an inode.  Updates the
- *      incore security context managed by the security module and invokes the
- *      fs code as needed (via __vfs_setxattr_noperm) to update any backing
- *      xattrs that represent the context.  Example usage:  NFS server invokes
- *      this hook to change the security context in its incore inode and on the
- *      backing filesystem to a value provided by the client on a SETATTR
- *      operation.
- *
- *      Must be called with inode->i_mutex locked.
- *
- *      @dentry contains the inode we wish to set the security context of.
- *      @ctx contains the string which we wish to set in the inode.
- *      @ctxlen contains the length of @ctx.
- *
- * @inode_getsecctx:
- *      On success, returns 0 and fills out @ctx and @ctxlen with the security
- *      context for the given @inode.
- *
- *      @inode we wish to get the security context of.
- *      @ctx is a pointer in which to place the allocated security context.
- *      @ctxlen points to the place to put the length of @ctx.
- * This is the main security structure.
- */
-struct security_operations {
-        char name[SECURITY_NAME_MAX + 1];
-
-        int (*binder_set_context_mgr) (struct task_struct *mgr);
-        int (*binder_transaction) (struct task_struct *from,
-                                   struct task_struct *to);
-        int (*binder_transfer_binder) (struct task_struct *from,
-                                       struct task_struct *to);
-        int (*binder_transfer_file) (struct task_struct *from,
-                                     struct task_struct *to, struct file *file);
-
-        int (*ptrace_access_check) (struct task_struct *child, unsigned int mode);
-        int (*ptrace_traceme) (struct task_struct *parent);
-        int (*capget) (struct task_struct *target,
-                       kernel_cap_t *effective,
-                       kernel_cap_t *inheritable, kernel_cap_t *permitted);
-        int (*capset) (struct cred *new,
-                       const struct cred *old,
-                       const kernel_cap_t *effective,
-                       const kernel_cap_t *inheritable,
-                       const kernel_cap_t *permitted);
-        int (*capable) (const struct cred *cred, struct user_namespace *ns,
-                        int cap, int audit);
-        int (*quotactl) (int cmds, int type, int id, struct super_block *sb);
-        int (*quota_on) (struct dentry *dentry);
-        int (*syslog) (int type);
-        int (*settime) (const struct timespec *ts, const struct timezone *tz);
-        int (*vm_enough_memory) (struct mm_struct *mm, long pages);
-
-        int (*bprm_set_creds) (struct linux_binprm *bprm);
-        int (*bprm_check_security) (struct linux_binprm *bprm);
-        int (*bprm_secureexec) (struct linux_binprm *bprm);
-        void (*bprm_committing_creds) (struct linux_binprm *bprm);
-        void (*bprm_committed_creds) (struct linux_binprm *bprm);
-
-        int (*sb_alloc_security) (struct super_block *sb);
-        void (*sb_free_security) (struct super_block *sb);
-        int (*sb_copy_data) (char *orig, char *copy);
-        int (*sb_remount) (struct super_block *sb, void *data);
-        int (*sb_kern_mount) (struct super_block *sb, int flags, void *data);
-        int (*sb_show_options) (struct seq_file *m, struct super_block *sb);
-        int (*sb_statfs) (struct dentry *dentry);
-        int (*sb_mount) (const char *dev_name, struct path *path,
-                         const char *type, unsigned long flags, void *data);
-        int (*sb_umount) (struct vfsmount *mnt, int flags);
-        int (*sb_pivotroot) (struct path *old_path,
-                             struct path *new_path);
-        int (*sb_set_mnt_opts) (struct super_block *sb,
-                                struct security_mnt_opts *opts,
-                                unsigned long kern_flags,
-                                unsigned long *set_kern_flags);
-        int (*sb_clone_mnt_opts) (const struct super_block *oldsb,
-                                   struct super_block *newsb);
-        int (*sb_parse_opts_str) (char *options, struct security_mnt_opts *opts);
-        int (*dentry_init_security) (struct dentry *dentry, int mode,
-                                        struct qstr *name, void **ctx,
-                                        u32 *ctxlen);
-
-
-#ifdef CONFIG_SECURITY_PATH
-        int (*path_unlink) (struct path *dir, struct dentry *dentry);
-        int (*path_mkdir) (struct path *dir, struct dentry *dentry, umode_t mode);
-        int (*path_rmdir) (struct path *dir, struct dentry *dentry);
-        int (*path_mknod) (struct path *dir, struct dentry *dentry, umode_t mode,
-                           unsigned int dev);
-        int (*path_truncate) (struct path *path);
-        int (*path_symlink) (struct path *dir, struct dentry *dentry,
-                             const char *old_name);
-        int (*path_link) (struct dentry *old_dentry, struct path *new_dir,
-                          struct dentry *new_dentry);
-        int (*path_rename) (struct path *old_dir, struct dentry *old_dentry,
-                            struct path *new_dir, struct dentry *new_dentry);
-        int (*path_chmod) (struct path *path, umode_t mode);
-        int (*path_chown) (struct path *path, kuid_t uid, kgid_t gid);
-        int (*path_chroot) (struct path *path);
-#endif
-
-        int (*inode_alloc_security) (struct inode *inode);
-        void (*inode_free_security) (struct inode *inode);
-        int (*inode_init_security) (struct inode *inode, struct inode *dir,
-                                    const struct qstr *qstr, const char **name,
-                                    void **value, size_t *len);
-        int (*inode_create) (struct inode *dir,
-                             struct dentry *dentry, umode_t mode);
-        int (*inode_link) (struct dentry *old_dentry,
-                           struct inode *dir, struct dentry *new_dentry);
-        int (*inode_unlink) (struct inode *dir, struct dentry *dentry);
-        int (*inode_symlink) (struct inode *dir,
-                              struct dentry *dentry, const char *old_name);
-        int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, umode_t mode);
-        int (*inode_rmdir) (struct inode *dir, struct dentry *dentry);
-        int (*inode_mknod) (struct inode *dir, struct dentry *dentry,
-                            umode_t mode, dev_t dev);
-        int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry,
-                             struct inode *new_dir, struct dentry *new_dentry);
-        int (*inode_readlink) (struct dentry *dentry);
-        int (*inode_follow_link) (struct dentry *dentry, struct inode *inode,
-                                  bool rcu);
-        int (*inode_permission) (struct inode *inode, int mask);
-        int (*inode_setattr)    (struct dentry *dentry, struct iattr *attr);
-        int (*inode_getattr) (const struct path *path);
-        int (*inode_setxattr) (struct dentry *dentry, const char *name,
-                               const void *value, size_t size, int flags);
-        void (*inode_post_setxattr) (struct dentry *dentry, const char *name,
-                                     const void *value, size_t size, int flags);
-        int (*inode_getxattr) (struct dentry *dentry, const char *name);
-        int (*inode_listxattr) (struct dentry *dentry);
-        int (*inode_removexattr) (struct dentry *dentry, const char *name);
-        int (*inode_need_killpriv) (struct dentry *dentry);
-        int (*inode_killpriv) (struct dentry *dentry);
-        int (*inode_getsecurity) (const struct inode *inode, const char *name, void **buffer, bool alloc);
-        int (*inode_setsecurity) (struct inode *inode, const char *name, const void *value, size_t size, int flags);
-        int (*inode_listsecurity) (struct inode *inode, char *buffer, size_t buffer_size);
-        void (*inode_getsecid) (const struct inode *inode, u32 *secid);
-
-        int (*file_permission) (struct file *file, int mask);
-        int (*file_alloc_security) (struct file *file);
-        void (*file_free_security) (struct file *file);
-        int (*file_ioctl) (struct file *file, unsigned int cmd,
-                           unsigned long arg);
-        int (*mmap_addr) (unsigned long addr);
-        int (*mmap_file) (struct file *file,
-                          unsigned long reqprot, unsigned long prot,
-                          unsigned long flags);
-        int (*file_mprotect) (struct vm_area_struct *vma,
-                              unsigned long reqprot,
-                              unsigned long prot);
-        int (*file_lock) (struct file *file, unsigned int cmd);
-        int (*file_fcntl) (struct file *file, unsigned int cmd,
-                           unsigned long arg);
-        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);
-        int (*file_open) (struct file *file, const struct cred *cred);
-
-        int (*task_create) (unsigned long clone_flags);
-        void (*task_free) (struct task_struct *task);
-        int (*cred_alloc_blank) (struct cred *cred, gfp_t gfp);
-        void (*cred_free) (struct cred *cred);
-        int (*cred_prepare)(struct cred *new, const struct cred *old,
-                            gfp_t gfp);
-        void (*cred_transfer)(struct cred *new, const struct cred *old);
-        int (*kernel_act_as)(struct cred *new, u32 secid);
-        int (*kernel_create_files_as)(struct cred *new, struct inode *inode);
-        int (*kernel_fw_from_file)(struct file *file, char *buf, size_t size);
-        int (*kernel_module_request)(char *kmod_name);
-        int (*kernel_module_from_file)(struct file *file);
-        int (*task_fix_setuid) (struct cred *new, const struct cred *old,
-                                int flags);
-        int (*task_setpgid) (struct task_struct *p, pid_t pgid);
-        int (*task_getpgid) (struct task_struct *p);
-        int (*task_getsid) (struct task_struct *p);
-        void (*task_getsecid) (struct task_struct *p, u32 *secid);
-        int (*task_setnice) (struct task_struct *p, int nice);
-        int (*task_setioprio) (struct task_struct *p, int ioprio);
-        int (*task_getioprio) (struct task_struct *p);
-        int (*task_setrlimit) (struct task_struct *p, unsigned int resource,
-                        struct rlimit *new_rlim);
-        int (*task_setscheduler) (struct task_struct *p);
-        int (*task_getscheduler) (struct task_struct *p);
-        int (*task_movememory) (struct task_struct *p);
-        int (*task_kill) (struct task_struct *p,
-                          struct siginfo *info, int sig, u32 secid);
-        int (*task_wait) (struct task_struct *p);
-        int (*task_prctl) (int option, unsigned long arg2,
-                           unsigned long arg3, unsigned long arg4,
-                           unsigned long arg5);
-        void (*task_to_inode) (struct task_struct *p, struct inode *inode);
-
-        int (*ipc_permission) (struct kern_ipc_perm *ipcp, short flag);
-        void (*ipc_getsecid) (struct kern_ipc_perm *ipcp, u32 *secid);
-
-        int (*msg_msg_alloc_security) (struct msg_msg *msg);
-        void (*msg_msg_free_security) (struct msg_msg *msg);
-
-        int (*msg_queue_alloc_security) (struct msg_queue *msq);
-        void (*msg_queue_free_security) (struct msg_queue *msq);
-        int (*msg_queue_associate) (struct msg_queue *msq, int msqflg);
-        int (*msg_queue_msgctl) (struct msg_queue *msq, int cmd);
-        int (*msg_queue_msgsnd) (struct msg_queue *msq,
-                                 struct msg_msg *msg, int msqflg);
-        int (*msg_queue_msgrcv) (struct msg_queue *msq,
-                                 struct msg_msg *msg,
-                                 struct task_struct *target,
-                                 long type, int mode);
-
-        int (*shm_alloc_security) (struct shmid_kernel *shp);
-        void (*shm_free_security) (struct shmid_kernel *shp);
-        int (*shm_associate) (struct shmid_kernel *shp, int shmflg);
-        int (*shm_shmctl) (struct shmid_kernel *shp, int cmd);
-        int (*shm_shmat) (struct shmid_kernel *shp,
-                          char __user *shmaddr, int shmflg);
-
-        int (*sem_alloc_security) (struct sem_array *sma);
-        void (*sem_free_security) (struct sem_array *sma);
-        int (*sem_associate) (struct sem_array *sma, int semflg);
-        int (*sem_semctl) (struct sem_array *sma, int cmd);
-        int (*sem_semop) (struct sem_array *sma,
-                          struct sembuf *sops, unsigned nsops, int alter);
-
-        int (*netlink_send) (struct sock *sk, struct sk_buff *skb);
-
-        void (*d_instantiate) (struct dentry *dentry, struct inode *inode);
-
-        int (*getprocattr) (struct task_struct *p, char *name, char **value);
-        int (*setprocattr) (struct task_struct *p, char *name, void *value, size_t size);
-        int (*ismaclabel) (const char *name);
-        int (*secid_to_secctx) (u32 secid, char **secdata, u32 *seclen);
-        int (*secctx_to_secid) (const char *secdata, u32 seclen, u32 *secid);
-        void (*release_secctx) (char *secdata, u32 seclen);
-
-        int (*inode_notifysecctx)(struct inode *inode, void *ctx, u32 ctxlen);
-        int (*inode_setsecctx)(struct dentry *dentry, void *ctx, u32 ctxlen);
-        int (*inode_getsecctx)(struct inode *inode, void **ctx, u32 *ctxlen);
-
-#ifdef CONFIG_SECURITY_NETWORK
-        int (*unix_stream_connect) (struct sock *sock, struct sock *other, struct sock *newsk);
-        int (*unix_may_send) (struct socket *sock, struct socket *other);
-
-        int (*socket_create) (int family, int type, int protocol, int kern);
-        int (*socket_post_create) (struct socket *sock, int family,
-                                   int type, int protocol, int kern);
-        int (*socket_bind) (struct socket *sock,
-                            struct sockaddr *address, int addrlen);
-        int (*socket_connect) (struct socket *sock,
-                               struct sockaddr *address, int addrlen);
-        int (*socket_listen) (struct socket *sock, int backlog);
-        int (*socket_accept) (struct socket *sock, struct socket *newsock);
-        int (*socket_sendmsg) (struct socket *sock,
-                               struct msghdr *msg, int size);
-        int (*socket_recvmsg) (struct socket *sock,
-                               struct msghdr *msg, int size, int flags);
-        int (*socket_getsockname) (struct socket *sock);
-        int (*socket_getpeername) (struct socket *sock);
-        int (*socket_getsockopt) (struct socket *sock, int level, int optname);
-        int (*socket_setsockopt) (struct socket *sock, int level, int optname);
-        int (*socket_shutdown) (struct socket *sock, int how);
-        int (*socket_sock_rcv_skb) (struct sock *sk, struct sk_buff *skb);
-        int (*socket_getpeersec_stream) (struct socket *sock, char __user *optval, int __user *optlen, unsigned len);
-        int (*socket_getpeersec_dgram) (struct socket *sock, struct sk_buff *skb, u32 *secid);
-        int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority);
-        void (*sk_free_security) (struct sock *sk);
-        void (*sk_clone_security) (const struct sock *sk, struct sock *newsk);
-        void (*sk_getsecid) (struct sock *sk, u32 *secid);
-        void (*sock_graft) (struct sock *sk, struct socket *parent);
-        int (*inet_conn_request) (struct sock *sk, struct sk_buff *skb,
-                                  struct request_sock *req);
-        void (*inet_csk_clone) (struct sock *newsk, const struct request_sock *req);
-        void (*inet_conn_established) (struct sock *sk, struct sk_buff *skb);
-        int (*secmark_relabel_packet) (u32 secid);
-        void (*secmark_refcount_inc) (void);
-        void (*secmark_refcount_dec) (void);
-        void (*req_classify_flow) (const struct request_sock *req, struct flowi *fl);
-        int (*tun_dev_alloc_security) (void **security);
-        void (*tun_dev_free_security) (void *security);
-        int (*tun_dev_create) (void);
-        int (*tun_dev_attach_queue) (void *security);
-        int (*tun_dev_attach) (struct sock *sk, void *security);
-        int (*tun_dev_open) (void *security);
-#endif  /* CONFIG_SECURITY_NETWORK */
-
-#ifdef CONFIG_SECURITY_NETWORK_XFRM
-        int (*xfrm_policy_alloc_security) (struct xfrm_sec_ctx **ctxp,
-                        struct xfrm_user_sec_ctx *sec_ctx, gfp_t gfp);
-        int (*xfrm_policy_clone_security) (struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctx);
-        void (*xfrm_policy_free_security) (struct xfrm_sec_ctx *ctx);
-        int (*xfrm_policy_delete_security) (struct xfrm_sec_ctx *ctx);
-        int (*xfrm_state_alloc) (struct xfrm_state *x,
-                                 struct xfrm_user_sec_ctx *sec_ctx);
-        int (*xfrm_state_alloc_acquire) (struct xfrm_state *x,
-                                         struct xfrm_sec_ctx *polsec,
-                                         u32 secid);
-        void (*xfrm_state_free_security) (struct xfrm_state *x);
-        int (*xfrm_state_delete_security) (struct xfrm_state *x);
-        int (*xfrm_policy_lookup) (struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
-        int (*xfrm_state_pol_flow_match) (struct xfrm_state *x,
-                                          struct xfrm_policy *xp,
-                                          const struct flowi *fl);
-        int (*xfrm_decode_session) (struct sk_buff *skb, u32 *secid, int ckall);
-#endif  /* CONFIG_SECURITY_NETWORK_XFRM */
-
-        /* key management security hooks */
-#ifdef CONFIG_KEYS
-        int (*key_alloc) (struct key *key, const struct cred *cred, unsigned long flags);
-        void (*key_free) (struct key *key);
-        int (*key_permission) (key_ref_t key_ref,
-                               const struct cred *cred,
-                               unsigned perm);
-        int (*key_getsecurity)(struct key *key, char **_buffer);
-#endif  /* CONFIG_KEYS */
-
-#ifdef CONFIG_AUDIT
-        int (*audit_rule_init) (u32 field, u32 op, char *rulestr, void **lsmrule);
-        int (*audit_rule_known) (struct audit_krule *krule);
-        int (*audit_rule_match) (u32 secid, u32 field, u32 op, void *lsmrule,
-                                 struct audit_context *actx);
-        void (*audit_rule_free) (void *lsmrule);
-#endif /* CONFIG_AUDIT */
-};
-
 /* prototypes */
 extern int security_init(void);
-extern int security_module_enable(struct security_operations *ops);
-extern int register_security(struct security_operations *ops);
-extern void __init security_fixup_ops(struct security_operations *ops);
-
 
 /* Security operations */
 int security_binder_set_context_mgr(struct task_struct *mgr);
@@ -2049,7 +465,7 @@ static inline int security_settime(const struct timespec *ts,
 
 static inline int security_vm_enough_memory_mm(struct mm_struct *mm, long pages)
 {
-        return cap_vm_enough_memory(mm, pages);
+        return __vm_enough_memory(mm, pages, cap_vm_enough_memory(mm, pages));
 }
 
 static inline int security_bprm_set_creds(struct linux_binprm *bprm)
@@ -2653,7 +1069,7 @@ static inline int security_setprocattr(struct task_struct *p, char *name, void *
 
 static inline int security_netlink_send(struct sock *sk, struct sk_buff *skb)
 {
-        return cap_netlink_send(sk, skb);
+        return 0;
 }
 
 static inline int security_ismaclabel(const char *name)
@@ -3221,36 +1637,5 @@ static inline void free_secdata(void *secdata)
 { }
 #endif /* CONFIG_SECURITY */
 
-#ifdef CONFIG_SECURITY_YAMA
-extern int yama_ptrace_access_check(struct task_struct *child,
-                                    unsigned int mode);
-extern int yama_ptrace_traceme(struct task_struct *parent);
-extern void yama_task_free(struct task_struct *task);
-extern int yama_task_prctl(int option, unsigned long arg2, unsigned long arg3,
-                           unsigned long arg4, unsigned long arg5);
-#else
-static inline int yama_ptrace_access_check(struct task_struct *child,
-                                           unsigned int mode)
-{
-        return 0;
-}
-
-static inline int yama_ptrace_traceme(struct task_struct *parent)
-{
-        return 0;
-}
-
-static inline void yama_task_free(struct task_struct *task)
-{
-}
-
-static inline int yama_task_prctl(int option, unsigned long arg2,
-                                  unsigned long arg3, unsigned long arg4,
-                                  unsigned long arg5)
-{
-        return -ENOSYS;
-}
-#endif /* CONFIG_SECURITY_YAMA */
-
 #endif /* ! __LINUX_SECURITY_H */
 
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index afbb1fd77c77..912a7c482649 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -123,6 +123,7 @@ __printf(2, 3) int seq_printf(struct seq_file *, const char *, ...);
 __printf(2, 0) int seq_vprintf(struct seq_file *, const char *, va_list args);
 
 int seq_path(struct seq_file *, const struct path *, const char *);
+int seq_file_path(struct seq_file *, struct file *, const char *);
 int seq_dentry(struct seq_file *, struct dentry *, const char *);
 int seq_path_root(struct seq_file *m, const struct path *path,
                   const struct path *root, const char *esc);
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index 486e685a226a..e0582106ef4f 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -35,6 +35,7 @@
 #include <linux/spinlock.h>
 #include <linux/preempt.h>
 #include <linux/lockdep.h>
+#include <linux/compiler.h>
 #include <asm/processor.h>
 
 /*
@@ -274,9 +275,87 @@ static inline void raw_write_seqcount_barrier(seqcount_t *s)
         s->sequence++;
 }
 
-/*
+static inline int raw_read_seqcount_latch(seqcount_t *s)
+{
+        return lockless_dereference(s->sequence);
+}
+
+/**
  * raw_write_seqcount_latch - redirect readers to even/odd copy
  * @s: pointer to seqcount_t
+ *
+ * The latch technique is a multiversion concurrency control method that allows
+ * queries during non-atomic modifications. If you can guarantee queries never
+ * interrupt the modification -- e.g. the concurrency is strictly between CPUs
+ * -- you most likely do not need this.
+ *
+ * Where the traditional RCU/lockless data structures rely on atomic
+ * modifications to ensure queries observe either the old or the new state the
+ * latch allows the same for non-atomic updates. The trade-off is doubling the
+ * cost of storage; we have to maintain two copies of the entire data
+ * structure.
+ *
+ * Very simply put: we first modify one copy and then the other. This ensures
+ * there is always one copy in a stable state, ready to give us an answer.
+ *
+ * The basic form is a data structure like:
+ *
+ * struct latch_struct {
+ *      seqcount_t              seq;
+ *      struct data_struct      data[2];
+ * };
+ *
+ * Where a modification, which is assumed to be externally serialized, does the
+ * following:
+ *
+ * void latch_modify(struct latch_struct *latch, ...)
+ * {
+ *      smp_wmb();      <- Ensure that the last data[1] update is visible
+ *      latch->seq++;
+ *      smp_wmb();      <- Ensure that the seqcount update is visible
+ *
+ *      modify(latch->data[0], ...);
+ *
+ *      smp_wmb();      <- Ensure that the data[0] update is visible
+ *      latch->seq++;
+ *      smp_wmb();      <- Ensure that the seqcount update is visible
+ *
+ *      modify(latch->data[1], ...);
+ * }
+ *
+ * The query will have a form like:
+ *
+ * struct entry *latch_query(struct latch_struct *latch, ...)
+ * {
+ *      struct entry *entry;
+ *      unsigned seq, idx;
+ *
+ *      do {
+ *              seq = lockless_dereference(latch->seq);
+ *
+ *              idx = seq & 0x01;
+ *              entry = data_query(latch->data[idx], ...);
+ *
+ *              smp_rmb();
+ *      } while (seq != latch->seq);
+ *
+ *      return entry;
+ * }
+ *
+ * So during the modification, queries are first redirected to data[1]. Then we
+ * modify data[0]. When that is complete, we redirect queries back to data[0]
+ * and we can modify data[1].
+ *
+ * NOTE: The non-requirement for atomic modifications does _NOT_ include
+ *       the publishing of new entries in the case where data is a dynamic
+ *       data structure.
+ *
+ *       An iteration might start in data[0] and get suspended long enough
+ *       to miss an entire modification sequence, once it resumes it might
+ *       observe the new entry.
+ *
+ * NOTE: When data is a dynamic data structure; one should use regular RCU
+ *       patterns to manage the lifetimes of the objects within.
  */
 static inline void raw_write_seqcount_latch(seqcount_t *s)
 {
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 78097e7a330a..ba82c07feb95 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -12,6 +12,7 @@
 #define _LINUX_SERIAL_8250_H
 
 #include <linux/serial_core.h>
+#include <linux/serial_reg.h>
 #include <linux/platform_device.h>
 
 /*
@@ -137,6 +138,8 @@ extern int early_serial_setup(struct uart_port *port);
 
 extern unsigned int serial8250_early_in(struct uart_port *port, int offset);
 extern void serial8250_early_out(struct uart_port *port, int offset, int value);
+extern int early_serial8250_setup(struct earlycon_device *device,
+                                         const char *options);
 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);
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 025dad9dcde4..297d4fa1cfe5 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -35,7 +35,7 @@
 #define uart_console(port) \
         ((port)->cons && (port)->cons->index == (port)->line)
 #else
-#define uart_console(port)      (0)
+#define uart_console(port)      ({ (void)port; 0; })
 #endif
 
 struct uart_port;
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index 6c5e3bb282b0..7c536ac5be05 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -1,6 +1,7 @@
 #ifndef __LINUX_SERIAL_SCI_H
 #define __LINUX_SERIAL_SCI_H
 
+#include <linux/bitops.h>
 #include <linux/serial_core.h>
 #include <linux/sh_dma.h>
 
@@ -10,59 +11,16 @@
 
 #define SCIx_NOT_SUPPORTED      (-1)
 
-/* SCSMR (Serial Mode Register) */
-#define SCSMR_CHR       (1 << 6)        /* 7-bit Character Length */
-#define SCSMR_PE        (1 << 5)        /* Parity Enable */
-#define SCSMR_ODD       (1 << 4)        /* Odd Parity */
-#define SCSMR_STOP      (1 << 3)        /* Stop Bit Length */
-#define SCSMR_CKS       0x0003          /* Clock Select */
-
 /* Serial Control Register (@ = not supported by all parts) */
-#define SCSCR_TIE       (1 << 7)        /* Transmit Interrupt Enable */
-#define SCSCR_RIE       (1 << 6)        /* Receive Interrupt Enable */
-#define SCSCR_TE        (1 << 5)        /* Transmit Enable */
-#define SCSCR_RE        (1 << 4)        /* Receive Enable */
-#define SCSCR_REIE      (1 << 3)        /* Receive Error Interrupt Enable @ */
-#define SCSCR_TOIE      (1 << 2)        /* Timeout Interrupt Enable @ */
-#define SCSCR_CKE1      (1 << 1)        /* Clock Enable 1 */
-#define SCSCR_CKE0      (1 << 0)        /* Clock Enable 0 */
-/* SCIFA/SCIFB only */
-#define SCSCR_TDRQE     (1 << 15)       /* Tx Data Transfer Request Enable */
-#define SCSCR_RDRQE     (1 << 14)       /* Rx Data Transfer Request Enable */
-
-/* SCxSR (Serial Status Register) on SCI */
-#define SCI_TDRE  0x80                  /* Transmit Data Register Empty */
-#define SCI_RDRF  0x40                  /* Receive Data Register Full */
-#define SCI_ORER  0x20                  /* Overrun Error */
-#define SCI_FER   0x10                  /* Framing Error */
-#define SCI_PER   0x08                  /* Parity Error */
-#define SCI_TEND  0x04                  /* Transmit End */
-
-#define SCI_DEFAULT_ERROR_MASK (SCI_PER | SCI_FER)
-
-/* SCxSR (Serial Status Register) on SCIF, HSCIF */
-#define SCIF_ER    0x0080               /* Receive Error */
-#define SCIF_TEND  0x0040               /* Transmission End */
-#define SCIF_TDFE  0x0020               /* Transmit FIFO Data Empty */
-#define SCIF_BRK   0x0010               /* Break Detect */
-#define SCIF_FER   0x0008               /* Framing Error */
-#define SCIF_PER   0x0004               /* Parity Error */
-#define SCIF_RDF   0x0002               /* Receive FIFO Data Full */
-#define SCIF_DR    0x0001               /* Receive Data Ready */
-
-#define SCIF_DEFAULT_ERROR_MASK (SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK)
-
-/* SCFCR (FIFO Control Register) */
-#define SCFCR_LOOP      (1 << 0)        /* Loopback Test */
-
-/* SCSPTR (Serial Port Register), optional */
-#define SCSPTR_RTSIO    (1 << 7)        /* Serial Port RTS Pin Input/Output */
-#define SCSPTR_CTSIO    (1 << 5)        /* Serial Port CTS Pin Input/Output */
-#define SCSPTR_SPB2IO   (1 << 1)        /* Serial Port Break Input/Output */
-#define SCSPTR_SPB2DT   (1 << 0)        /* Serial Port Break Data */
-
-/* HSSRR HSCIF */
-#define HSCIF_SRE       0x8000          /* Sampling Rate Register Enable */
+#define SCSCR_TIE       BIT(7)  /* Transmit Interrupt Enable */
+#define SCSCR_RIE       BIT(6)  /* Receive Interrupt Enable */
+#define SCSCR_TE        BIT(5)  /* Transmit Enable */
+#define SCSCR_RE        BIT(4)  /* Receive Enable */
+#define SCSCR_REIE      BIT(3)  /* Receive Error Interrupt Enable @ */
+#define SCSCR_TOIE      BIT(2)  /* Timeout Interrupt Enable @ */
+#define SCSCR_CKE1      BIT(1)  /* Clock Enable 1 */
+#define SCSCR_CKE0      BIT(0)  /* Clock Enable 0 */
+
 
 enum {
         SCIx_PROBE_REGTYPE,
@@ -82,28 +40,6 @@ enum {
         SCIx_NR_REGTYPES,
 };
 
-/*
- * SCI register subset common for all port types.
- * Not all registers will exist on all parts.
- */
-enum {
-        SCSMR,                          /* Serial Mode Register */
-        SCBRR,                          /* Bit Rate Register */
-        SCSCR,                          /* Serial Control Register */
-        SCxSR,                          /* Serial Status Register */
-        SCFCR,                          /* FIFO Control Register */
-        SCFDR,                          /* FIFO Data Count Register */
-        SCxTDR,                         /* Transmit (FIFO) Data Register */
-        SCxRDR,                         /* Receive (FIFO) Data Register */
-        SCLSR,                          /* Line Status Register */
-        SCTFDR,                         /* Transmit FIFO Data Count Register */
-        SCRFDR,                         /* Receive FIFO Data Count Register */
-        SCSPTR,                         /* Serial Port Register */
-        HSSRR,                          /* Sampling Rate Register */
-
-        SCIx_NR_REGS,
-};
-
 struct device;
 
 struct plat_sci_port_ops {
@@ -113,7 +49,7 @@ struct plat_sci_port_ops {
 /*
  * Port-specific capabilities
  */
-#define SCIx_HAVE_RTSCTS        (1 << 0)
+#define SCIx_HAVE_RTSCTS        BIT(0)
 
 /*
  * Platform device specific platform_data struct
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index f15154a879c7..d6cdd6e87d53 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -34,7 +34,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/netdev_features.h>
 #include <linux/sched.h>
-#include <net/flow_keys.h>
+#include <net/flow_dissector.h>
+#include <linux/splice.h>
+#include <linux/in6.h>
 
 /* A. Checksumming of received packets by device.
  *
@@ -170,13 +172,19 @@ struct nf_bridge_info {
                 BRNF_PROTO_UNCHANGED,
                 BRNF_PROTO_8021Q,
                 BRNF_PROTO_PPPOE
-        } orig_proto;
+        } orig_proto:8;
         bool                    pkt_otherhost;
+        __u16                   frag_max_size;
         unsigned int            mask;
         struct net_device       *physindev;
-        struct net_device       *physoutdev;
-        char                    neigh_header[8];
-        __be32                  ipv4_daddr;
+        union {
+                struct net_device *physoutdev;
+                char neigh_header[8];
+        };
+        union {
+                __be32          ipv4_daddr;
+                struct in6_addr ipv6_daddr;
+        };
 };
 #endif
 
@@ -859,6 +867,9 @@ int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
                                         int len, int odd, struct sk_buff *skb),
                             void *from, int length);
 
+int skb_append_pagefrags(struct sk_buff *skb, struct page *page,
+                         int offset, size_t size);
+
 struct skb_seq_state {
         __u32           lower_offset;
         __u32           upper_offset;
@@ -919,7 +930,6 @@ skb_set_hash(struct sk_buff *skb, __u32 hash, enum pkt_hash_types type)
         skb->hash = hash;
 }
 
-void __skb_get_hash(struct sk_buff *skb);
 static inline __u32 skb_get_hash(struct sk_buff *skb)
 {
         if (!skb->l4_hash && !skb->sw_hash)
@@ -928,6 +938,8 @@ static inline __u32 skb_get_hash(struct sk_buff *skb)
         return skb->hash;
 }
 
+__u32 skb_get_hash_perturb(const struct sk_buff *skb, u32 perturb);
+
 static inline __u32 skb_get_hash_raw(const struct sk_buff *skb)
 {
         return skb->hash;
@@ -1935,8 +1947,8 @@ static inline void skb_probe_transport_header(struct sk_buff *skb,
 
         if (skb_transport_header_was_set(skb))
                 return;
-        else if (skb_flow_dissect(skb, &keys))
-                skb_set_transport_header(skb, keys.thoff);
+        else if (skb_flow_dissect_flow_keys(skb, &keys))
+                skb_set_transport_header(skb, keys.control.thoff);
         else
                 skb_set_transport_header(skb, offset_hint);
 }
@@ -2127,10 +2139,6 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
                 kfree_skb(skb);
 }
 
-#define NETDEV_FRAG_PAGE_MAX_ORDER get_order(32768)
-#define NETDEV_FRAG_PAGE_MAX_SIZE  (PAGE_SIZE << NETDEV_FRAG_PAGE_MAX_ORDER)
-#define NETDEV_PAGECNT_MAX_BIAS    NETDEV_FRAG_PAGE_MAX_SIZE
-
 void *netdev_alloc_frag(unsigned int fragsz);
 
 struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int length,
@@ -2185,6 +2193,11 @@ static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
         return __netdev_alloc_skb_ip_align(dev, length, GFP_ATOMIC);
 }
 
+static inline void skb_free_frag(void *addr)
+{
+        __free_page_frag(addr);
+}
+
 void *napi_alloc_frag(unsigned int fragsz);
 struct sk_buff *__napi_alloc_skb(struct napi_struct *napi,
                                  unsigned int length, gfp_t gfp_mask);
@@ -2692,9 +2705,15 @@ int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len);
 int skb_store_bits(struct sk_buff *skb, int offset, const void *from, int len);
 __wsum skb_copy_and_csum_bits(const struct sk_buff *skb, int offset, u8 *to,
                               int len, __wsum csum);
-int skb_splice_bits(struct sk_buff *skb, unsigned int offset,
+ssize_t skb_socket_splice(struct sock *sk,
+                          struct pipe_inode_info *pipe,
+                          struct splice_pipe_desc *spd);
+int skb_splice_bits(struct sk_buff *skb, struct sock *sk, unsigned int offset,
                     struct pipe_inode_info *pipe, unsigned int len,
-                    unsigned int flags);
+                    unsigned int flags,
+                    ssize_t (*splice_cb)(struct sock *,
+                                         struct pipe_inode_info *,
+                                         struct splice_pipe_desc *));
 void skb_copy_and_csum_dev(const struct sk_buff *skb, u8 *to);
 unsigned int skb_zerocopy_headlen(const struct sk_buff *from);
 int skb_zerocopy(struct sk_buff *to, struct sk_buff *from,
@@ -2729,8 +2748,9 @@ __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 *data, int hlen, void *buffer)
+static inline void * __must_check
+__skb_header_pointer(const struct sk_buff *skb, int offset,
+                     int len, void *data, int hlen, void *buffer)
 {
         if (hlen - offset >= len)
                 return data + offset;
@@ -2742,8 +2762,8 @@ static inline void *__skb_header_pointer(const struct sk_buff *skb, int offset,
         return buffer;
 }
 
-static inline void *skb_header_pointer(const struct sk_buff *skb, int offset,
-                                       int len, void *buffer)
+static inline void * __must_check
+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);
@@ -3050,7 +3070,7 @@ static inline __sum16 __skb_checksum_validate_complete(struct sk_buff *skb,
                 }
         } else if (skb->csum_bad) {
                 /* ip_summed == CHECKSUM_NONE in this case */
-                return 1;
+                return (__force __sum16)1;
         }
 
         skb->csum = psum;
@@ -3298,9 +3318,6 @@ static inline bool skb_rx_queue_recorded(const struct sk_buff *skb)
         return skb->queue_mapping != 0;
 }
 
-u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
-                  unsigned int num_tx_queues);
-
 static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
 {
 #ifdef CONFIG_XFRM
@@ -3355,15 +3372,14 @@ static inline int gso_pskb_expand_head(struct sk_buff *skb, int extra)
 static inline __sum16 gso_make_checksum(struct sk_buff *skb, __wsum res)
 {
         int plen = SKB_GSO_CB(skb)->csum_start - skb_headroom(skb) -
-            skb_transport_offset(skb);
-        __u16 csum;
+                   skb_transport_offset(skb);
+        __wsum partial;
 
-        csum = csum_fold(csum_partial(skb_transport_header(skb),
-                                      plen, skb->csum));
+        partial = csum_partial(skb_transport_header(skb), plen, skb->csum);
         skb->csum = res;
         SKB_GSO_CB(skb)->csum_start -= plen;
 
-        return csum;
+        return csum_fold(partial);
 }
 
 static inline bool skb_is_gso(const struct sk_buff *skb)
@@ -3418,10 +3434,9 @@ static inline void skb_checksum_none_assert(const struct sk_buff *skb)
 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, void *data,
-                   const struct flow_keys *keys, int hlen);
+struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb,
+                                     unsigned int transport_len,
+                                     __sum16(*skb_chkf)(struct sk_buff *skb));
 
 /**
  * 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 ffd24c830151..a99f0e5243e1 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -240,8 +240,8 @@ extern struct kmem_cache *kmalloc_dma_caches[KMALLOC_SHIFT_HIGH + 1];
  * belongs to.
  * 0 = zero alloc
  * 1 =  65 .. 96 bytes
- * 2 = 120 .. 192 bytes
- * n = 2^(n-1) .. 2^n -1
+ * 2 = 129 .. 192 bytes
+ * n = 2^(n-1)+1 .. 2^n
  */
 static __always_inline int kmalloc_index(size_t size)
 {
diff --git a/include/linux/smpboot.h b/include/linux/smpboot.h
index d600afb21926..da3c593f9845 100644
--- a/include/linux/smpboot.h
+++ b/include/linux/smpboot.h
@@ -27,6 +27,8 @@ struct smpboot_thread_data;
  * @pre_unpark:         Optional unpark function, called before the thread is
  *                      unparked (cpu online). This is not guaranteed to be
  *                      called on the target cpu of the thread. Careful!
+ * @cpumask:            Internal state.  To update which threads are unparked,
+ *                      call smpboot_update_cpumask_percpu_thread().
  * @selfparking:        Thread is not parked by the park function.
  * @thread_comm:        The base name of the thread
  */
@@ -41,11 +43,14 @@ struct smp_hotplug_thread {
         void                            (*park)(unsigned int cpu);
         void                            (*unpark)(unsigned int cpu);
         void                            (*pre_unpark)(unsigned int cpu);
+        cpumask_var_t                   cpumask;
         bool                            selfparking;
         const char                      *thread_comm;
 };
 
 int smpboot_register_percpu_thread(struct smp_hotplug_thread *plug_thread);
 void smpboot_unregister_percpu_thread(struct smp_hotplug_thread *plug_thread);
+int smpboot_update_cpumask_percpu_thread(struct smp_hotplug_thread *plug_thread,
+                                         const struct cpumask *);
 
 #endif
diff --git a/include/linux/soc/sunxi/sunxi_sram.h b/include/linux/soc/sunxi/sunxi_sram.h
new file mode 100644
index 000000000000..c5f663bba9c2
--- /dev/null
+++ b/include/linux/soc/sunxi/sunxi_sram.h
@@ -0,0 +1,19 @@
+/*
+ * Allwinner SoCs SRAM Controller Driver
+ *
+ * Copyright (C) 2015 Maxime Ripard
+ *
+ * Author: Maxime Ripard <maxime.ripard@free-electrons.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef _SUNXI_SRAM_H_
+#define _SUNXI_SRAM_H_
+
+int sunxi_sram_claim(struct device *dev);
+int sunxi_sram_release(struct device *dev);
+
+#endif /* _SUNXI_SRAM_H_ */
diff --git a/include/linux/sock_diag.h b/include/linux/sock_diag.h
index 083ac388098e..fddebc617469 100644
--- a/include/linux/sock_diag.h
+++ b/include/linux/sock_diag.h
@@ -1,7 +1,10 @@
 #ifndef __SOCK_DIAG_H__
 #define __SOCK_DIAG_H__
 
+#include <linux/netlink.h>
 #include <linux/user_namespace.h>
+#include <net/net_namespace.h>
+#include <net/sock.h>
 #include <uapi/linux/sock_diag.h>
 
 struct sk_buff;
@@ -11,6 +14,7 @@ struct sock;
 struct sock_diag_handler {
         __u8 family;
         int (*dump)(struct sk_buff *skb, struct nlmsghdr *nlh);
+        int (*get_info)(struct sk_buff *skb, struct sock *sk);
 };
 
 int sock_diag_register(const struct sock_diag_handler *h);
@@ -26,4 +30,42 @@ int sock_diag_put_meminfo(struct sock *sk, struct sk_buff *skb, int attr);
 int sock_diag_put_filterinfo(bool may_report_filterinfo, struct sock *sk,
                              struct sk_buff *skb, int attrtype);
 
+static inline
+enum sknetlink_groups sock_diag_destroy_group(const struct sock *sk)
+{
+        switch (sk->sk_family) {
+        case AF_INET:
+                switch (sk->sk_protocol) {
+                case IPPROTO_TCP:
+                        return SKNLGRP_INET_TCP_DESTROY;
+                case IPPROTO_UDP:
+                        return SKNLGRP_INET_UDP_DESTROY;
+                default:
+                        return SKNLGRP_NONE;
+                }
+        case AF_INET6:
+                switch (sk->sk_protocol) {
+                case IPPROTO_TCP:
+                        return SKNLGRP_INET6_TCP_DESTROY;
+                case IPPROTO_UDP:
+                        return SKNLGRP_INET6_UDP_DESTROY;
+                default:
+                        return SKNLGRP_NONE;
+                }
+        default:
+                return SKNLGRP_NONE;
+        }
+}
+
+static inline
+bool sock_diag_has_destroy_listeners(const struct sock *sk)
+{
+        const struct net *n = sock_net(sk);
+        const enum sknetlink_groups group = sock_diag_destroy_group(sk);
+
+        return group != SKNLGRP_NONE && n->diag_nlsk &&
+                netlink_has_listeners(n->diag_nlsk, group);
+}
+void sock_diag_broadcast_destroy(struct sock *sk);
+
 #endif
diff --git a/include/linux/spi/cc2520.h b/include/linux/spi/cc2520.h
index e741e8baad92..85b8ee67e937 100644
--- a/include/linux/spi/cc2520.h
+++ b/include/linux/spi/cc2520.h
@@ -21,7 +21,6 @@ struct cc2520_platform_data {
         int sfd;
         int reset;
         int vreg;
-        bool amplified;
 };
 
 #endif
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 4568a5cc9ab8..c3d1a525bacc 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -29,10 +29,13 @@ struct ssb_sprom {
         u8 il0mac[6] __aligned(sizeof(u16));    /* MAC address for 802.11b/g */
         u8 et0mac[6] __aligned(sizeof(u16));    /* MAC address for Ethernet */
         u8 et1mac[6] __aligned(sizeof(u16));    /* MAC address for 802.11a */
+        u8 et2mac[6] __aligned(sizeof(u16));    /* MAC address for extra Ethernet */
         u8 et0phyaddr;          /* MII address for enet0 */
         u8 et1phyaddr;          /* MII address for enet1 */
+        u8 et2phyaddr;          /* MII address for enet2 */
         u8 et0mdcport;          /* MDIO for enet0 */
         u8 et1mdcport;          /* MDIO for enet1 */
+        u8 et2mdcport;          /* MDIO for enet2 */
         u16 dev_id;             /* Device ID overriding e.g. PCI ID */
         u16 board_rev;          /* Board revision number from SPROM. */
         u16 board_num;          /* Board number from SPROM. */
@@ -88,11 +91,14 @@ struct ssb_sprom {
         u32 ofdm5glpo;          /* 5.2GHz OFDM power offset */
         u32 ofdm5gpo;           /* 5.3GHz OFDM power offset */
         u32 ofdm5ghpo;          /* 5.8GHz OFDM power offset */
+        u32 boardflags;
+        u32 boardflags2;
+        u32 boardflags3;
+        /* TODO: Switch all drivers to new u32 fields and drop below ones */
         u16 boardflags_lo;      /* Board flags (bits 0-15) */
         u16 boardflags_hi;      /* Board flags (bits 16-31) */
         u16 boardflags2_lo;     /* Board flags (bits 32-47) */
         u16 boardflags2_hi;     /* Board flags (bits 48-63) */
-        /* TODO store board flags in a single u64 */
 
         struct ssb_sprom_core_pwr_info core_pwr_info[4];
 
diff --git a/include/linux/stddef.h b/include/linux/stddef.h
index 076af437284d..9c61c7cda936 100644
--- a/include/linux/stddef.h
+++ b/include/linux/stddef.h
@@ -3,7 +3,6 @@
 
 #include <uapi/linux/stddef.h>
 
-
 #undef NULL
 #define NULL ((void *)0)
 
@@ -14,10 +13,9 @@ enum {
 
 #undef offsetof
 #ifdef __compiler_offsetof
-#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
+#define offsetof(TYPE, MEMBER)  __compiler_offsetof(TYPE, MEMBER)
 #else
-#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-#endif
+#define offsetof(TYPE, MEMBER)  ((size_t)&((TYPE *)0)->MEMBER)
 #endif
 
 /**
@@ -28,3 +26,5 @@ enum {
  */
 #define offsetofend(TYPE, MEMBER) \
         (offsetof(TYPE, MEMBER) + sizeof(((TYPE *)0)->MEMBER))
+
+#endif
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index 7f484a239f53..c735f5c91eea 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -99,6 +99,7 @@ struct plat_stmmacenet_data {
         int phy_addr;
         int interface;
         struct stmmac_mdio_bus_data *mdio_bus_data;
+        struct device_node *phy_node;
         struct stmmac_dma_cfg *dma_cfg;
         int clk_csr;
         int has_gmac;
diff --git a/include/linux/string.h b/include/linux/string.h
index e40099e585c9..a8d90db9c4b0 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -111,6 +111,7 @@ extern int memcmp(const void *,const void *,__kernel_size_t);
 extern void * memchr(const void *,int,__kernel_size_t);
 #endif
 void *memchr_inv(const void *s, int c, size_t n);
+char *strreplace(char *s, char old, char new);
 
 extern void kfree_const(const void *x);
 
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h
index 2ca67b55e0fe..8df43c9f11dc 100644
--- a/include/linux/sunrpc/bc_xprt.h
+++ b/include/linux/sunrpc/bc_xprt.h
@@ -37,7 +37,6 @@ void xprt_complete_bc_request(struct rpc_rqst *req, uint32_t copied);
 void xprt_free_bc_request(struct rpc_rqst *req);
 int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs);
 void xprt_destroy_backchannel(struct rpc_xprt *, unsigned int max_reqs);
-int bc_send(struct rpc_rqst *req);
 
 /*
  * Determine if a shared backchannel is in use
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 598ba80ec30c..131032f15cc1 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -56,6 +56,7 @@ struct rpc_clnt {
         struct rpc_rtt *        cl_rtt;         /* RTO estimator data */
         const struct rpc_timeout *cl_timeout;   /* Timeout strategy */
 
+        atomic_t                cl_swapper;     /* swapfile count */
         int                     cl_nodelen;     /* nodename length */
         char                    cl_nodename[UNX_MAXNODENAME+1];
         struct rpc_pipe_dir_head cl_pipedir_objects;
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 5f1e6bd4c316..d703f0ef37d8 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -205,8 +205,7 @@ struct rpc_wait_queue {
  */
 struct rpc_task *rpc_new_task(const struct rpc_task_setup *);
 struct rpc_task *rpc_run_task(const struct rpc_task_setup *);
-struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
-                                const struct rpc_call_ops *ops);
+struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req);
 void            rpc_put_task(struct rpc_task *);
 void            rpc_put_task_async(struct rpc_task *);
 void            rpc_exit_task(struct rpc_task *);
@@ -269,4 +268,20 @@ static inline void rpc_assign_waitqueue_name(struct rpc_wait_queue *q,
 }
 #endif
 
+#if IS_ENABLED(CONFIG_SUNRPC_SWAP)
+int rpc_clnt_swap_activate(struct rpc_clnt *clnt);
+void rpc_clnt_swap_deactivate(struct rpc_clnt *clnt);
+#else
+static inline int
+rpc_clnt_swap_activate(struct rpc_clnt *clnt)
+{
+        return -EINVAL;
+}
+
+static inline void
+rpc_clnt_swap_deactivate(struct rpc_clnt *clnt)
+{
+}
+#endif /* CONFIG_SUNRPC_SWAP */
+
 #endif /* _LINUX_SUNRPC_SCHED_H_ */
diff --git a/include/linux/sunrpc/svc_rdma.h b/include/linux/sunrpc/svc_rdma.h
index df8edf8ec914..cb94ee4181d4 100644
--- a/include/linux/sunrpc/svc_rdma.h
+++ b/include/linux/sunrpc/svc_rdma.h
@@ -172,6 +172,13 @@ struct svcxprt_rdma {
 #define RDMAXPRT_SQ_PENDING     2
 #define RDMAXPRT_CONN_PENDING   3
 
+#define RPCRDMA_MAX_SVC_SEGS    (64)    /* server max scatter/gather */
+#if RPCSVC_MAXPAYLOAD < (RPCRDMA_MAX_SVC_SEGS << PAGE_SHIFT)
+#define RPCRDMA_MAXPAYLOAD      RPCSVC_MAXPAYLOAD
+#else
+#define RPCRDMA_MAXPAYLOAD      (RPCRDMA_MAX_SVC_SEGS << PAGE_SHIFT)
+#endif
+
 #define RPCRDMA_LISTEN_BACKLOG  10
 /* The default ORD value is based on two outstanding full-size writes with a
  * page size of 4k, or 32k * 2 ops / 4k = 16 outstanding RDMA_READ.  */
@@ -182,10 +189,9 @@ struct svcxprt_rdma {
 
 /* svc_rdma_marshal.c */
 extern int svc_rdma_xdr_decode_req(struct rpcrdma_msg **, struct svc_rqst *);
-extern int svc_rdma_xdr_decode_deferred_req(struct svc_rqst *);
 extern int svc_rdma_xdr_encode_error(struct svcxprt_rdma *,
                                      struct rpcrdma_msg *,
-                                     enum rpcrdma_errcode, u32 *);
+                                     enum rpcrdma_errcode, __be32 *);
 extern void svc_rdma_xdr_encode_write_list(struct rpcrdma_msg *, int);
 extern void svc_rdma_xdr_encode_reply_array(struct rpcrdma_write_array *, int);
 extern void svc_rdma_xdr_encode_array_chunk(struct rpcrdma_write_array *, int,
@@ -212,7 +218,6 @@ extern int svc_rdma_sendto(struct svc_rqst *);
 extern int svc_rdma_send(struct svcxprt_rdma *, struct ib_send_wr *);
 extern void svc_rdma_send_error(struct svcxprt_rdma *, struct rpcrdma_msg *,
                                 enum rpcrdma_errcode);
-struct page *svc_rdma_get_page(void);
 extern int svc_rdma_post_recv(struct svcxprt_rdma *);
 extern int svc_rdma_create_listen(struct svc_serv *, int, struct sockaddr *);
 extern struct svc_rdma_op_ctxt *svc_rdma_get_context(struct svcxprt_rdma *);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 8b93ef53df3c..0fb9acbb4780 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -133,6 +133,9 @@ struct rpc_xprt_ops {
         void            (*close)(struct rpc_xprt *xprt);
         void            (*destroy)(struct rpc_xprt *xprt);
         void            (*print_stats)(struct rpc_xprt *xprt, struct seq_file *seq);
+        int             (*enable_swap)(struct rpc_xprt *xprt);
+        void            (*disable_swap)(struct rpc_xprt *xprt);
+        void            (*inject_disconnect)(struct rpc_xprt *xprt);
 };
 
 /*
@@ -180,7 +183,7 @@ struct rpc_xprt {
         atomic_t                num_reqs;       /* total slots */
         unsigned long           state;          /* transport state */
         unsigned char           resvport   : 1; /* use a reserved port */
-        unsigned int            swapper;        /* we're swapping over this
+        atomic_t                swapper;        /* we're swapping over this
                                                    transport */
         unsigned int            bind_index;     /* bind function index */
 
@@ -212,7 +215,8 @@ struct rpc_xprt {
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct svc_serv         *bc_serv;       /* The RPC service which will */
                                                 /* process the callback */
-        unsigned int            bc_alloc_count; /* Total number of preallocs */
+        int                     bc_alloc_count; /* Total number of preallocs */
+        atomic_t                bc_free_slots;
         spinlock_t              bc_pa_lock;     /* Protects the preallocated
                                                  * items */
         struct list_head        bc_pa_list;     /* List of preallocated
@@ -241,6 +245,7 @@ struct rpc_xprt {
         const char              *address_strings[RPC_DISPLAY_MAX];
 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
         struct dentry           *debugfs;               /* debugfs directory */
+        atomic_t                inject_disconnect;
 #endif
 };
 
@@ -327,6 +332,18 @@ static inline __be32 *xprt_skip_transport_header(struct rpc_xprt *xprt, __be32 *
         return p + xprt->tsh_size;
 }
 
+static inline int
+xprt_enable_swap(struct rpc_xprt *xprt)
+{
+        return xprt->ops->enable_swap(xprt);
+}
+
+static inline void
+xprt_disable_swap(struct rpc_xprt *xprt)
+{
+        xprt->ops->disable_swap(xprt);
+}
+
 /*
  * Transport switch helper functions
  */
@@ -345,7 +362,6 @@ void			xprt_release_rqst_cong(struct rpc_task *task);
 void                    xprt_disconnect_done(struct rpc_xprt *xprt);
 void                    xprt_force_disconnect(struct rpc_xprt *xprt);
 void                    xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
-int                     xs_swapper(struct rpc_xprt *xprt, int enable);
 
 bool                    xprt_lock_connect(struct rpc_xprt *, struct rpc_task *, void *);
 void                    xprt_unlock_connect(struct rpc_xprt *, void *);
@@ -431,6 +447,23 @@ static inline int xprt_test_and_set_binding(struct rpc_xprt *xprt)
         return test_and_set_bit(XPRT_BINDING, &xprt->state);
 }
 
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+extern unsigned int rpc_inject_disconnect;
+static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
+{
+        if (!rpc_inject_disconnect)
+                return;
+        if (atomic_dec_return(&xprt->inject_disconnect))
+                return;
+        atomic_set(&xprt->inject_disconnect, rpc_inject_disconnect);
+        xprt->ops->inject_disconnect(xprt);
+}
+#else
+static inline void xprt_inject_disconnect(struct rpc_xprt *xprt)
+{
+}
+#endif
+
 #endif /* __KERNEL__*/
 
 #endif /* _LINUX_SUNRPC_XPRT_H */
diff --git a/include/linux/sunrpc/xprtrdma.h b/include/linux/sunrpc/xprtrdma.h
index c984c85981ea..b17613052cc3 100644
--- a/include/linux/sunrpc/xprtrdma.h
+++ b/include/linux/sunrpc/xprtrdma.h
@@ -56,7 +56,8 @@
 
 #define RPCRDMA_INLINE_PAD_THRESH  (512)/* payload threshold to pad (bytes) */
 
-/* memory registration strategies */
+/* Memory registration strategies, by number.
+ * This is part of a kernel / user space API. Do not remove. */
 enum rpcrdma_memreg {
         RPCRDMA_BOUNCEBUFFERS = 0,
         RPCRDMA_REGISTER,
diff --git a/include/linux/swap.h b/include/linux/swap.h
index cee108cbe2d5..38874729dc5f 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -377,7 +377,6 @@ extern void end_swap_bio_write(struct bio *bio, int err);
 extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
         void (*end_write_func)(struct bio *, int));
 extern int swap_set_page_dirty(struct page *page);
-extern void end_swap_bio_read(struct bio *bio, int err);
 
 int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
                 unsigned long nr_pages, sector_t start_block);
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 76d1e38aabe1..b45c45b8c829 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -111,14 +111,14 @@ union bpf_attr;
 #define __SC_STR_ADECL(t, a)    #a
 #define __SC_STR_TDECL(t, a)    #t
 
-extern struct ftrace_event_class event_class_syscall_enter;
-extern struct ftrace_event_class event_class_syscall_exit;
+extern struct trace_event_class event_class_syscall_enter;
+extern struct trace_event_class event_class_syscall_exit;
 extern struct trace_event_functions enter_syscall_print_funcs;
 extern struct trace_event_functions exit_syscall_print_funcs;
 
 #define SYSCALL_TRACE_ENTER_EVENT(sname)                                \
         static struct syscall_metadata __syscall_meta_##sname;          \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           event_enter_##sname = {                                       \
                 .class                  = &event_class_syscall_enter,   \
                 {                                                       \
@@ -128,13 +128,13 @@ extern struct trace_event_functions exit_syscall_print_funcs;
                 .data                   = (void *)&__syscall_meta_##sname,\
                 .flags                  = TRACE_EVENT_FL_CAP_ANY,       \
         };                                                              \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           __attribute__((section("_ftrace_events")))                    \
          *__event_enter_##sname = &event_enter_##sname;
 
 #define SYSCALL_TRACE_EXIT_EVENT(sname)                                 \
         static struct syscall_metadata __syscall_meta_##sname;          \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           event_exit_##sname = {                                        \
                 .class                  = &event_class_syscall_exit,    \
                 {                                                       \
@@ -144,7 +144,7 @@ extern struct trace_event_functions exit_syscall_print_funcs;
                 .data                   = (void *)&__syscall_meta_##sname,\
                 .flags                  = TRACE_EVENT_FL_CAP_ANY,       \
         };                                                              \
-        static struct ftrace_event_call __used                          \
+        static struct trace_event_call __used                           \
           __attribute__((section("_ftrace_events")))                    \
         *__event_exit_##sname = &event_exit_##sname;
 
@@ -827,15 +827,15 @@ asmlinkage long sys_syncfs(int fd);
 asmlinkage long sys_fork(void);
 asmlinkage long sys_vfork(void);
 #ifdef CONFIG_CLONE_BACKWARDS
-asmlinkage long sys_clone(unsigned long, unsigned long, int __user *, int,
+asmlinkage long sys_clone(unsigned long, unsigned long, int __user *, unsigned long,
                int __user *);
 #else
 #ifdef CONFIG_CLONE_BACKWARDS3
 asmlinkage long sys_clone(unsigned long, unsigned long, int, int __user *,
-                          int __user *, int);
+                          int __user *, unsigned long);
 #else
 asmlinkage long sys_clone(unsigned long, unsigned long, int __user *,
-               int __user *, int);
+               int __user *, unsigned long);
 #endif
 #endif
 
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 795d5fea5697..fa7bc29925c9 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -188,6 +188,9 @@ struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
 void unregister_sysctl_table(struct ctl_table_header * table);
 
 extern int sysctl_init(void);
+
+extern struct ctl_table sysctl_mount_point[];
+
 #else /* CONFIG_SYSCTL */
 static inline struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
 {
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 99382c0df17e..9f65758311a4 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -210,6 +210,10 @@ int __must_check sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
 int __must_check sysfs_move_dir_ns(struct kobject *kobj,
                                    struct kobject *new_parent_kobj,
                                    const void *new_ns);
+int __must_check sysfs_create_mount_point(struct kobject *parent_kobj,
+                                          const char *name);
+void sysfs_remove_mount_point(struct kobject *parent_kobj,
+                              const char *name);
 
 int __must_check sysfs_create_file_ns(struct kobject *kobj,
                                       const struct attribute *attr,
@@ -298,6 +302,17 @@ static inline int sysfs_move_dir_ns(struct kobject *kobj,
         return 0;
 }
 
+static inline int sysfs_create_mount_point(struct kobject *parent_kobj,
+                                           const char *name)
+{
+        return 0;
+}
+
+static inline void sysfs_remove_mount_point(struct kobject *parent_kobj,
+                                            const char *name)
+{
+}
+
 static inline int sysfs_create_file_ns(struct kobject *kobj,
                                        const struct attribute *attr,
                                        const void *ns)
diff --git a/include/linux/syslog.h b/include/linux/syslog.h
index 4b7b875a7ce1..c3a7f0cc3a27 100644
--- a/include/linux/syslog.h
+++ b/include/linux/syslog.h
@@ -47,12 +47,12 @@
 #define SYSLOG_FROM_READER           0
 #define SYSLOG_FROM_PROC             1
 
-int do_syslog(int type, char __user *buf, int count, bool from_file);
+int do_syslog(int type, char __user *buf, int count, int source);
 
 #ifdef CONFIG_PRINTK
-int check_syslog_permissions(int type, bool from_file);
+int check_syslog_permissions(int type, int source);
 #else
-static inline int check_syslog_permissions(int type, bool from_file)
+static inline int check_syslog_permissions(int type, int source)
 {
         return 0;
 }
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index e8bbf403618f..48c3696e8645 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -149,11 +149,16 @@ struct tcp_sock {
                                  * sum(delta(rcv_nxt)), or how many bytes
                                  * were acked.
                                  */
+        u32     segs_in;        /* RFC4898 tcpEStatsPerfSegsIn
+                                 * total number of segments in.
+                                 */
         u32     rcv_nxt;        /* What we want to receive next         */
         u32     copied_seq;     /* Head of yet unread data              */
         u32     rcv_wup;        /* rcv_nxt on last window update sent   */
         u32     snd_nxt;        /* Next sequence we send                */
-
+        u32     segs_out;       /* RFC4898 tcpEStatsPerfSegsOut
+                                 * The total number of segments sent.
+                                 */
         u64     bytes_acked;    /* RFC4898 tcpEStatsAppHCThruOctetsAcked
                                  * sum(delta(snd_una)), or how many bytes
                                  * were acked.
@@ -201,6 +206,7 @@ struct tcp_sock {
                 syn_fastopen:1, /* SYN includes Fast Open option */
                 syn_fastopen_exp:1,/* SYN includes Fast Open exp. option */
                 syn_data_acked:1,/* data in SYN is acked by SYN-ACK */
+                save_syn:1,     /* Save headers of SYN packet */
                 is_cwnd_limited:1;/* forward progress limited by snd_cwnd? */
         u32     tlp_high_seq;   /* snd_nxt at the time of TLP retransmit. */
 
@@ -328,6 +334,7 @@ struct tcp_sock {
          * socket. Used to retransmit SYNACKs etc.
          */
         struct request_sock *fastopen_rsk;
+        u32     *saved_syn;
 };
 
 enum tsq_flags {
@@ -395,4 +402,10 @@ static inline int fastopen_init_queue(struct sock *sk, int backlog)
         return 0;
 }
 
+static inline void tcp_saved_syn_free(struct tcp_sock *tp)
+{
+        kfree(tp->saved_syn);
+        tp->saved_syn = NULL;
+}
+
 #endif  /* _LINUX_TCP_H */
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index 5eac316490ea..037e9df2f610 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -40,6 +40,9 @@
 /* No upper/lower limit requirement */
 #define THERMAL_NO_LIMIT        ((u32)~0)
 
+/* Default weight of a bound cooling device */
+#define THERMAL_WEIGHT_DEFAULT 0
+
 /* Unit conversion macros */
 #define KELVIN_TO_CELSIUS(t)    (long)(((long)t-2732 >= 0) ?    \
                                 ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
@@ -56,10 +59,13 @@
 #define DEFAULT_THERMAL_GOVERNOR       "fair_share"
 #elif defined(CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE)
 #define DEFAULT_THERMAL_GOVERNOR       "user_space"
+#elif defined(CONFIG_THERMAL_DEFAULT_GOV_POWER_ALLOCATOR)
+#define DEFAULT_THERMAL_GOVERNOR       "power_allocator"
 #endif
 
 struct thermal_zone_device;
 struct thermal_cooling_device;
+struct thermal_instance;
 
 enum thermal_device_mode {
         THERMAL_DEVICE_DISABLED = 0,
@@ -113,6 +119,12 @@ struct thermal_cooling_device_ops {
         int (*get_max_state) (struct thermal_cooling_device *, unsigned long *);
         int (*get_cur_state) (struct thermal_cooling_device *, unsigned long *);
         int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
+        int (*get_requested_power)(struct thermal_cooling_device *,
+                                   struct thermal_zone_device *, u32 *);
+        int (*state2power)(struct thermal_cooling_device *,
+                           struct thermal_zone_device *, unsigned long, u32 *);
+        int (*power2state)(struct thermal_cooling_device *,
+                           struct thermal_zone_device *, u32, unsigned long *);
 };
 
 struct thermal_cooling_device {
@@ -144,8 +156,7 @@ struct thermal_attr {
  * @devdata:    private pointer for device private data
  * @trips:      number of trip points the thermal zone supports
  * @passive_delay:      number of milliseconds to wait between polls when
- *                      performing passive cooling.  Currenty only used by the
- *                      step-wise governor
+ *                      performing passive cooling.
  * @polling_delay:      number of milliseconds to wait between polls when
  *                      checking whether trip points have been crossed (0 for
  *                      interrupt driven systems)
@@ -155,13 +166,13 @@ struct thermal_attr {
  * @last_temperature:   previous temperature read
  * @emul_temperature:   emulated temperature when using CONFIG_THERMAL_EMULATION
  * @passive:            1 if you've crossed a passive trip point, 0 otherwise.
- *                      Currenty only used by the step-wise governor.
  * @forced_passive:     If > 0, temperature at which to switch on all ACPI
  *                      processor cooling devices.  Currently only used by the
  *                      step-wise governor.
  * @ops:        operations this &thermal_zone_device supports
  * @tzp:        thermal zone parameters
  * @governor:   pointer to the governor for this thermal zone
+ * @governor_data:      private pointer for governor data
  * @thermal_instances:  list of &struct thermal_instance of this thermal zone
  * @idr:        &struct idr to generate unique id for this zone's cooling
  *              devices
@@ -186,8 +197,9 @@ struct thermal_zone_device {
         int passive;
         unsigned int forced_passive;
         struct thermal_zone_device_ops *ops;
-        const struct thermal_zone_params *tzp;
+        struct thermal_zone_params *tzp;
         struct thermal_governor *governor;
+        void *governor_data;
         struct list_head thermal_instances;
         struct idr idr;
         struct mutex lock;
@@ -198,12 +210,19 @@ struct thermal_zone_device {
 /**
  * struct thermal_governor - structure that holds thermal governor information
  * @name:       name of the governor
+ * @bind_to_tz: callback called when binding to a thermal zone.  If it
+ *              returns 0, the governor is bound to the thermal zone,
+ *              otherwise it fails.
+ * @unbind_from_tz:     callback called when a governor is unbound from a
+ *                      thermal zone.
  * @throttle:   callback called for every trip point even if temperature is
  *              below the trip point temperature
  * @governor_list:      node in thermal_governor_list (in thermal_core.c)
  */
 struct thermal_governor {
         char name[THERMAL_NAME_LENGTH];
+        int (*bind_to_tz)(struct thermal_zone_device *tz);
+        void (*unbind_from_tz)(struct thermal_zone_device *tz);
         int (*throttle)(struct thermal_zone_device *tz, int trip);
         struct list_head        governor_list;
 };
@@ -214,9 +233,12 @@ struct thermal_bind_params {
 
         /*
          * This is a measure of 'how effectively these devices can
-         * cool 'this' thermal zone. The shall be determined by platform
-         * characterization. This is on a 'percentage' scale.
-         * See Documentation/thermal/sysfs-api.txt for more information.
+         * cool 'this' thermal zone. It shall be determined by
+         * platform characterization. This value is relative to the
+         * rest of the weights so a cooling device whose weight is
+         * double that of another cooling device is twice as
+         * effective. See Documentation/thermal/sysfs-api.txt for more
+         * information.
          */
         int weight;
 
@@ -253,6 +275,44 @@ struct thermal_zone_params {
 
         int num_tbps;   /* Number of tbp entries */
         struct thermal_bind_params *tbp;
+
+        /*
+         * Sustainable power (heat) that this thermal zone can dissipate in
+         * mW
+         */
+        u32 sustainable_power;
+
+        /*
+         * Proportional parameter of the PID controller when
+         * overshooting (i.e., when temperature is below the target)
+         */
+        s32 k_po;
+
+        /*
+         * Proportional parameter of the PID controller when
+         * undershooting
+         */
+        s32 k_pu;
+
+        /* Integral parameter of the PID controller */
+        s32 k_i;
+
+        /* Derivative parameter of the PID controller */
+        s32 k_d;
+
+        /* threshold below which the error is no longer accumulated */
+        s32 integral_cutoff;
+
+        /*
+         * @slope:      slope of a linear temperature adjustment curve.
+         *              Used by thermal zone drivers.
+         */
+        int slope;
+        /*
+         * @offset:     offset of a linear temperature adjustment curve.
+         *              Used by thermal zone drivers (default 0).
+         */
+        int offset;
 };
 
 struct thermal_genl_event {
@@ -316,14 +376,25 @@ void thermal_zone_of_sensor_unregister(struct device *dev,
 #endif
 
 #if IS_ENABLED(CONFIG_THERMAL)
+static inline bool cdev_is_power_actor(struct thermal_cooling_device *cdev)
+{
+        return cdev->ops->get_requested_power && cdev->ops->state2power &&
+                cdev->ops->power2state;
+}
+
+int power_actor_get_max_power(struct thermal_cooling_device *,
+                              struct thermal_zone_device *tz, u32 *max_power);
+int power_actor_set_power(struct thermal_cooling_device *,
+                          struct thermal_instance *, u32);
 struct thermal_zone_device *thermal_zone_device_register(const char *, int, int,
                 void *, struct thermal_zone_device_ops *,
-                const struct thermal_zone_params *, int, int);
+                struct thermal_zone_params *, int, int);
 void thermal_zone_device_unregister(struct thermal_zone_device *);
 
 int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
                                      struct thermal_cooling_device *,
-                                     unsigned long, unsigned long);
+                                     unsigned long, unsigned long,
+                                     unsigned int);
 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
                                        struct thermal_cooling_device *);
 void thermal_zone_device_update(struct thermal_zone_device *);
@@ -343,6 +414,14 @@ struct thermal_instance *get_thermal_instance(struct thermal_zone_device *,
 void thermal_cdev_update(struct thermal_cooling_device *);
 void thermal_notify_framework(struct thermal_zone_device *, int);
 #else
+static inline bool cdev_is_power_actor(struct thermal_cooling_device *cdev)
+{ return false; }
+static inline int power_actor_get_max_power(struct thermal_cooling_device *cdev,
+                              struct thermal_zone_device *tz, u32 *max_power)
+{ return 0; }
+static inline int power_actor_set_power(struct thermal_cooling_device *cdev,
+                          struct thermal_instance *tz, u32 power)
+{ return 0; }
 static inline struct thermal_zone_device *thermal_zone_device_register(
         const char *type, int trips, int mask, void *devdata,
         struct thermal_zone_device_ops *ops,
diff --git a/include/linux/tick.h b/include/linux/tick.h
index 4191b5623a28..edbfc9a5293e 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -13,8 +13,6 @@
 
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 extern void __init tick_init(void);
-extern void tick_freeze(void);
-extern void tick_unfreeze(void);
 /* Should be core only, but ARM BL switcher requires it */
 extern void tick_suspend_local(void);
 /* Should be core only, but XEN resume magic and ARM BL switcher require it */
@@ -23,14 +21,20 @@ extern void tick_handover_do_timer(void);
 extern void tick_cleanup_dead_cpu(int cpu);
 #else /* CONFIG_GENERIC_CLOCKEVENTS */
 static inline void tick_init(void) { }
-static inline void tick_freeze(void) { }
-static inline void tick_unfreeze(void) { }
 static inline void tick_suspend_local(void) { }
 static inline void tick_resume_local(void) { }
 static inline void tick_handover_do_timer(void) { }
 static inline void tick_cleanup_dead_cpu(int cpu) { }
 #endif /* !CONFIG_GENERIC_CLOCKEVENTS */
 
+#if defined(CONFIG_GENERIC_CLOCKEVENTS) && defined(CONFIG_SUSPEND)
+extern void tick_freeze(void);
+extern void tick_unfreeze(void);
+#else
+static inline void tick_freeze(void) { }
+static inline void tick_unfreeze(void) { }
+#endif
+
 #ifdef CONFIG_TICK_ONESHOT
 extern void tick_irq_enter(void);
 #  ifndef arch_needs_cpu
@@ -63,10 +67,13 @@ extern void tick_broadcast_control(enum tick_broadcast_mode mode);
 static inline void tick_broadcast_control(enum tick_broadcast_mode mode) { }
 #endif /* BROADCAST */
 
-#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) && defined(CONFIG_TICK_ONESHOT)
+#ifdef CONFIG_GENERIC_CLOCKEVENTS
 extern int tick_broadcast_oneshot_control(enum tick_broadcast_state state);
 #else
-static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state) { return 0; }
+static inline int tick_broadcast_oneshot_control(enum tick_broadcast_state state)
+{
+        return 0;
+}
 #endif
 
 static inline void tick_broadcast_enable(void)
diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index 3aa72e648650..6e191e4e6ab6 100644
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -145,7 +145,6 @@ static inline void getboottime(struct timespec *ts)
 }
 #endif
 
-#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
 #define ktime_get_real_ts64(ts) getnstimeofday64(ts)
 
 /*
diff --git a/include/linux/ftrace_event.h b/include/linux/trace_events.h
index f9ecf63d47f1..1063c850dbab 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/trace_events.h
@@ -1,6 +1,6 @@
 
-#ifndef _LINUX_FTRACE_EVENT_H
-#define _LINUX_FTRACE_EVENT_H
+#ifndef _LINUX_TRACE_EVENT_H
+#define _LINUX_TRACE_EVENT_H
 
 #include <linux/ring_buffer.h>
 #include <linux/trace_seq.h>
@@ -25,35 +25,35 @@ struct trace_print_flags_u64 {
         const char              *name;
 };
 
-const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
-                                   unsigned long flags,
-                                   const struct trace_print_flags *flag_array);
+const char *trace_print_flags_seq(struct trace_seq *p, const char *delim,
+                                  unsigned long flags,
+                                  const struct trace_print_flags *flag_array);
 
-const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
-                                     const struct trace_print_flags *symbol_array);
+const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val,
+                                    const struct trace_print_flags *symbol_array);
 
 #if BITS_PER_LONG == 32
-const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
-                                         unsigned long long val,
-                                         const struct trace_print_flags_u64
+const char *trace_print_symbols_seq_u64(struct trace_seq *p,
+                                        unsigned long long val,
+                                        const struct trace_print_flags_u64
                                                                  *symbol_array);
 #endif
 
-const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
-                                     unsigned int bitmask_size);
+const char *trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
+                                    unsigned int bitmask_size);
 
-const char *ftrace_print_hex_seq(struct trace_seq *p,
-                                 const unsigned char *buf, int len);
+const char *trace_print_hex_seq(struct trace_seq *p,
+                                const unsigned char *buf, int len);
 
-const char *ftrace_print_array_seq(struct trace_seq *p,
+const char *trace_print_array_seq(struct trace_seq *p,
                                    const void *buf, int count,
                                    size_t el_size);
 
 struct trace_iterator;
 struct trace_event;
 
-int ftrace_raw_output_prep(struct trace_iterator *iter,
-                           struct trace_event *event);
+int trace_raw_output_prep(struct trace_iterator *iter,
+                          struct trace_event *event);
 
 /*
  * The trace entry - the most basic unit of tracing. This is what
@@ -68,7 +68,7 @@ struct trace_entry {
         int                     pid;
 };
 
-#define FTRACE_MAX_EVENT                                                \
+#define TRACE_EVENT_TYPE_MAX                                            \
         ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)
 
 /*
@@ -132,8 +132,8 @@ struct trace_event {
         struct trace_event_functions    *funcs;
 };
 
-extern int register_ftrace_event(struct trace_event *event);
-extern int unregister_ftrace_event(struct trace_event *event);
+extern int register_trace_event(struct trace_event *event);
+extern int unregister_trace_event(struct trace_event *event);
 
 /* Return values for print_line callback */
 enum print_line_t {
@@ -157,11 +157,11 @@ static inline enum print_line_t trace_handle_return(struct trace_seq *s)
 void tracing_generic_entry_update(struct trace_entry *entry,
                                   unsigned long flags,
                                   int pc);
-struct ftrace_event_file;
+struct trace_event_file;
 
 struct ring_buffer_event *
 trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer,
-                                struct ftrace_event_file *ftrace_file,
+                                struct trace_event_file *trace_file,
                                 int type, unsigned long len,
                                 unsigned long flags, int pc);
 struct ring_buffer_event *
@@ -183,7 +183,7 @@ void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
 
 void tracing_record_cmdline(struct task_struct *tsk);
 
-int ftrace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);
+int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);
 
 struct event_filter;
 
@@ -200,50 +200,39 @@ enum trace_reg {
 #endif
 };
 
-struct ftrace_event_call;
+struct trace_event_call;
 
-struct ftrace_event_class {
+struct trace_event_class {
         const char              *system;
         void                    *probe;
 #ifdef CONFIG_PERF_EVENTS
         void                    *perf_probe;
 #endif
-        int                     (*reg)(struct ftrace_event_call *event,
+        int                     (*reg)(struct trace_event_call *event,
                                        enum trace_reg type, void *data);
-        int                     (*define_fields)(struct ftrace_event_call *);
-        struct list_head        *(*get_fields)(struct ftrace_event_call *);
+        int                     (*define_fields)(struct trace_event_call *);
+        struct list_head        *(*get_fields)(struct trace_event_call *);
         struct list_head        fields;
-        int                     (*raw_init)(struct ftrace_event_call *);
+        int                     (*raw_init)(struct trace_event_call *);
 };
 
-extern int ftrace_event_reg(struct ftrace_event_call *event,
+extern int trace_event_reg(struct trace_event_call *event,
                             enum trace_reg type, void *data);
 
-int ftrace_output_event(struct trace_iterator *iter, struct ftrace_event_call *event,
-                        char *fmt, ...);
-
-int ftrace_event_define_field(struct ftrace_event_call *call,
-                              char *type, int len, char *item, int offset,
-                              int field_size, int sign, int filter);
-
-struct ftrace_event_buffer {
+struct trace_event_buffer {
         struct ring_buffer              *buffer;
         struct ring_buffer_event        *event;
-        struct ftrace_event_file        *ftrace_file;
+        struct trace_event_file         *trace_file;
         void                            *entry;
         unsigned long                   flags;
         int                             pc;
 };
 
-void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer,
-                                  struct ftrace_event_file *ftrace_file,
+void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
+                                  struct trace_event_file *trace_file,
                                   unsigned long len);
 
-void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer);
-
-int ftrace_event_define_field(struct ftrace_event_call *call,
-                              char *type, int len, char *item, int offset,
-                              int field_size, int sign, int filter);
+void trace_event_buffer_commit(struct trace_event_buffer *fbuffer);
 
 enum {
         TRACE_EVENT_FL_FILTERED_BIT,
@@ -261,11 +250,11 @@ enum {
  *  FILTERED      - The event has a filter attached
  *  CAP_ANY       - Any user can enable for perf
  *  NO_SET_FILTER - Set when filter has error and is to be ignored
- *  IGNORE_ENABLE - For ftrace internal events, do not enable with debugfs file
+ *  IGNORE_ENABLE - For trace internal events, do not enable with debugfs file
  *  WAS_ENABLED   - Set and stays set when an event was ever enabled
  *                    (used for module unloading, if a module event is enabled,
  *                     it is best to clear the buffers that used it).
- *  USE_CALL_FILTER - For ftrace internal events, don't use file filter
+ *  USE_CALL_FILTER - For trace internal events, don't use file filter
  *  TRACEPOINT    - Event is a tracepoint
  *  KPROBE        - Event is a kprobe
  */
@@ -280,9 +269,9 @@ enum {
         TRACE_EVENT_FL_KPROBE           = (1 << TRACE_EVENT_FL_KPROBE_BIT),
 };
 
-struct ftrace_event_call {
+struct trace_event_call {
         struct list_head        list;
-        struct ftrace_event_class *class;
+        struct trace_event_class *class;
         union {
                 char                    *name;
                 /* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */
@@ -297,7 +286,7 @@ struct ftrace_event_call {
          *   bit 0:             filter_active
          *   bit 1:             allow trace by non root (cap any)
          *   bit 2:             failed to apply filter
-         *   bit 3:             ftrace internal event (do not enable)
+         *   bit 3:             trace internal event (do not enable)
          *   bit 4:             Event was enabled by module
          *   bit 5:             use call filter rather than file filter
          *   bit 6:             Event is a tracepoint
@@ -309,13 +298,13 @@ struct ftrace_event_call {
         struct hlist_head __percpu      *perf_events;
         struct bpf_prog                 *prog;
 
-        int     (*perf_perm)(struct ftrace_event_call *,
+        int     (*perf_perm)(struct trace_event_call *,
                              struct perf_event *);
 #endif
 };
 
 static inline const char *
-ftrace_event_name(struct ftrace_event_call *call)
+trace_event_name(struct trace_event_call *call)
 {
         if (call->flags & TRACE_EVENT_FL_TRACEPOINT)
                 return call->tp ? call->tp->name : NULL;
@@ -324,21 +313,21 @@ ftrace_event_name(struct ftrace_event_call *call)
 }
 
 struct trace_array;
-struct ftrace_subsystem_dir;
+struct trace_subsystem_dir;
 
 enum {
-        FTRACE_EVENT_FL_ENABLED_BIT,
-        FTRACE_EVENT_FL_RECORDED_CMD_BIT,
-        FTRACE_EVENT_FL_FILTERED_BIT,
-        FTRACE_EVENT_FL_NO_SET_FILTER_BIT,
-        FTRACE_EVENT_FL_SOFT_MODE_BIT,
-        FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
-        FTRACE_EVENT_FL_TRIGGER_MODE_BIT,
-        FTRACE_EVENT_FL_TRIGGER_COND_BIT,
+        EVENT_FILE_FL_ENABLED_BIT,
+        EVENT_FILE_FL_RECORDED_CMD_BIT,
+        EVENT_FILE_FL_FILTERED_BIT,
+        EVENT_FILE_FL_NO_SET_FILTER_BIT,
+        EVENT_FILE_FL_SOFT_MODE_BIT,
+        EVENT_FILE_FL_SOFT_DISABLED_BIT,
+        EVENT_FILE_FL_TRIGGER_MODE_BIT,
+        EVENT_FILE_FL_TRIGGER_COND_BIT,
 };
 
 /*
- * Ftrace event file flags:
+ * Event file flags:
  *  ENABLED       - The event is enabled
  *  RECORDED_CMD  - The comms should be recorded at sched_switch
  *  FILTERED      - The event has a filter attached
@@ -350,23 +339,23 @@ enum {
  *  TRIGGER_COND  - When set, one or more triggers has an associated filter
  */
 enum {
-        FTRACE_EVENT_FL_ENABLED         = (1 << FTRACE_EVENT_FL_ENABLED_BIT),
-        FTRACE_EVENT_FL_RECORDED_CMD    = (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT),
-        FTRACE_EVENT_FL_FILTERED        = (1 << FTRACE_EVENT_FL_FILTERED_BIT),
-        FTRACE_EVENT_FL_NO_SET_FILTER   = (1 << FTRACE_EVENT_FL_NO_SET_FILTER_BIT),
-        FTRACE_EVENT_FL_SOFT_MODE       = (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT),
-        FTRACE_EVENT_FL_SOFT_DISABLED   = (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT),
-        FTRACE_EVENT_FL_TRIGGER_MODE    = (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT),
-        FTRACE_EVENT_FL_TRIGGER_COND    = (1 << FTRACE_EVENT_FL_TRIGGER_COND_BIT),
+        EVENT_FILE_FL_ENABLED           = (1 << EVENT_FILE_FL_ENABLED_BIT),
+        EVENT_FILE_FL_RECORDED_CMD      = (1 << EVENT_FILE_FL_RECORDED_CMD_BIT),
+        EVENT_FILE_FL_FILTERED          = (1 << EVENT_FILE_FL_FILTERED_BIT),
+        EVENT_FILE_FL_NO_SET_FILTER     = (1 << EVENT_FILE_FL_NO_SET_FILTER_BIT),
+        EVENT_FILE_FL_SOFT_MODE         = (1 << EVENT_FILE_FL_SOFT_MODE_BIT),
+        EVENT_FILE_FL_SOFT_DISABLED     = (1 << EVENT_FILE_FL_SOFT_DISABLED_BIT),
+        EVENT_FILE_FL_TRIGGER_MODE      = (1 << EVENT_FILE_FL_TRIGGER_MODE_BIT),
+        EVENT_FILE_FL_TRIGGER_COND      = (1 << EVENT_FILE_FL_TRIGGER_COND_BIT),
 };
 
-struct ftrace_event_file {
+struct trace_event_file {
         struct list_head                list;
-        struct ftrace_event_call        *event_call;
+        struct trace_event_call         *event_call;
         struct event_filter             *filter;
         struct dentry                   *dir;
         struct trace_array              *tr;
-        struct ftrace_subsystem_dir     *system;
+        struct trace_subsystem_dir      *system;
         struct list_head                triggers;
 
         /*
@@ -399,7 +388,7 @@ struct ftrace_event_file {
         early_initcall(trace_init_flags_##name);
 
 #define __TRACE_EVENT_PERF_PERM(name, expr...)                          \
-        static int perf_perm_##name(struct ftrace_event_call *tp_event, \
+        static int perf_perm_##name(struct trace_event_call *tp_event, \
                                     struct perf_event *p_event)         \
         {                                                               \
                 return ({ expr; });                                     \
@@ -425,19 +414,19 @@ enum event_trigger_type {
 
 extern int filter_match_preds(struct event_filter *filter, void *rec);
 
-extern int filter_check_discard(struct ftrace_event_file *file, void *rec,
+extern int filter_check_discard(struct trace_event_file *file, void *rec,
                                 struct ring_buffer *buffer,
                                 struct ring_buffer_event *event);
-extern int call_filter_check_discard(struct ftrace_event_call *call, void *rec,
+extern int call_filter_check_discard(struct trace_event_call *call, void *rec,
                                      struct ring_buffer *buffer,
                                      struct ring_buffer_event *event);
-extern enum event_trigger_type event_triggers_call(struct ftrace_event_file *file,
+extern enum event_trigger_type event_triggers_call(struct trace_event_file *file,
                                                    void *rec);
-extern void event_triggers_post_call(struct ftrace_event_file *file,
+extern void event_triggers_post_call(struct trace_event_file *file,
                                      enum event_trigger_type tt);
 
 /**
- * ftrace_trigger_soft_disabled - do triggers and test if soft disabled
+ * trace_trigger_soft_disabled - do triggers and test if soft disabled
  * @file: The file pointer of the event to test
  *
  * If any triggers without filters are attached to this event, they
@@ -446,14 +435,14 @@ extern void event_triggers_post_call(struct ftrace_event_file *file,
  * otherwise false.
  */
 static inline bool
-ftrace_trigger_soft_disabled(struct ftrace_event_file *file)
+trace_trigger_soft_disabled(struct trace_event_file *file)
 {
         unsigned long eflags = file->flags;
 
-        if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
-                if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
+        if (!(eflags & EVENT_FILE_FL_TRIGGER_COND)) {
+                if (eflags & EVENT_FILE_FL_TRIGGER_MODE)
                         event_triggers_call(file, NULL);
-                if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
+                if (eflags & EVENT_FILE_FL_SOFT_DISABLED)
                         return true;
         }
         return false;
@@ -473,7 +462,7 @@ ftrace_trigger_soft_disabled(struct ftrace_event_file *file)
  * Returns true if the event is discarded, false otherwise.
  */
 static inline bool
-__event_trigger_test_discard(struct ftrace_event_file *file,
+__event_trigger_test_discard(struct trace_event_file *file,
                              struct ring_buffer *buffer,
                              struct ring_buffer_event *event,
                              void *entry,
@@ -481,10 +470,10 @@ __event_trigger_test_discard(struct ftrace_event_file *file,
 {
         unsigned long eflags = file->flags;
 
-        if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
+        if (eflags & EVENT_FILE_FL_TRIGGER_COND)
                 *tt = event_triggers_call(file, entry);
 
-        if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags))
+        if (test_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags))
                 ring_buffer_discard_commit(buffer, event);
         else if (!filter_check_discard(file, entry, buffer, event))
                 return false;
@@ -506,7 +495,7 @@ __event_trigger_test_discard(struct ftrace_event_file *file,
  * if the event is soft disabled and should be discarded.
  */
 static inline void
-event_trigger_unlock_commit(struct ftrace_event_file *file,
+event_trigger_unlock_commit(struct trace_event_file *file,
                             struct ring_buffer *buffer,
                             struct ring_buffer_event *event,
                             void *entry, unsigned long irq_flags, int pc)
@@ -537,7 +526,7 @@ event_trigger_unlock_commit(struct ftrace_event_file *file,
  * trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
  */
 static inline void
-event_trigger_unlock_commit_regs(struct ftrace_event_file *file,
+event_trigger_unlock_commit_regs(struct trace_event_file *file,
                                  struct ring_buffer *buffer,
                                  struct ring_buffer_event *event,
                                  void *entry, unsigned long irq_flags, int pc,
@@ -570,12 +559,12 @@ enum {
         FILTER_TRACE_FN,
 };
 
-extern int trace_event_raw_init(struct ftrace_event_call *call);
-extern int trace_define_field(struct ftrace_event_call *call, const char *type,
+extern int trace_event_raw_init(struct trace_event_call *call);
+extern int trace_define_field(struct trace_event_call *call, const char *type,
                               const char *name, int offset, int size,
                               int is_signed, int filter_type);
-extern int trace_add_event_call(struct ftrace_event_call *call);
-extern int trace_remove_event_call(struct ftrace_event_call *call);
+extern int trace_add_event_call(struct trace_event_call *call);
+extern int trace_remove_event_call(struct trace_event_call *call);
 
 #define is_signed_type(type)    (((type)(-1)) < (type)1)
 
@@ -624,4 +613,4 @@ perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
 }
 #endif
 
-#endif /* _LINUX_FTRACE_EVENT_H */
+#endif /* _LINUX_TRACE_EVENT_H */
diff --git a/include/linux/tty.h b/include/linux/tty.h
index d76631f615c2..ad6c8913aa3e 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -422,7 +422,7 @@ static inline struct tty_struct *tty_kref_get(struct tty_struct *tty)
 
 extern int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
                               const char *routine);
-extern char *tty_name(struct tty_struct *tty, char *buf);
+extern const char *tty_name(const struct tty_struct *tty);
 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);
diff --git a/include/linux/u64_stats_sync.h b/include/linux/u64_stats_sync.h
index 4b4439e75f45..df89c9bcba7d 100644
--- a/include/linux/u64_stats_sync.h
+++ b/include/linux/u64_stats_sync.h
@@ -68,11 +68,12 @@ struct u64_stats_sync {
 };
 
 
+static inline void u64_stats_init(struct u64_stats_sync *syncp)
+{
 #if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
-# define u64_stats_init(syncp)  seqcount_init(syncp.seq)
-#else
-# define u64_stats_init(syncp)  do { } while (0)
+        seqcount_init(&syncp->seq);
 #endif
+}
 
 static inline void u64_stats_update_begin(struct u64_stats_sync *syncp)
 {
diff --git a/include/linux/ulpi/driver.h b/include/linux/ulpi/driver.h
new file mode 100644
index 000000000000..388f6e08b9d4
--- /dev/null
+++ b/include/linux/ulpi/driver.h
@@ -0,0 +1,60 @@
+#ifndef __LINUX_ULPI_DRIVER_H
+#define __LINUX_ULPI_DRIVER_H
+
+#include <linux/mod_devicetable.h>
+
+#include <linux/device.h>
+
+struct ulpi_ops;
+
+/**
+ * struct ulpi - describes ULPI PHY device
+ * @id: vendor and product ids for ULPI device
+ * @ops: I/O access
+ * @dev: device interface
+ */
+struct ulpi {
+        struct ulpi_device_id id;
+        struct ulpi_ops *ops;
+        struct device dev;
+};
+
+#define to_ulpi_dev(d) container_of(d, struct ulpi, dev)
+
+static inline void ulpi_set_drvdata(struct ulpi *ulpi, void *data)
+{
+        dev_set_drvdata(&ulpi->dev, data);
+}
+
+static inline void *ulpi_get_drvdata(struct ulpi *ulpi)
+{
+        return dev_get_drvdata(&ulpi->dev);
+}
+
+/**
+ * struct ulpi_driver - describes a ULPI PHY driver
+ * @id_table: array of device identifiers supported by this driver
+ * @probe: binds this driver to ULPI device
+ * @remove: unbinds this driver from ULPI device
+ * @driver: the name and owner members must be initialized by the drivers
+ */
+struct ulpi_driver {
+        const struct ulpi_device_id *id_table;
+        int (*probe)(struct ulpi *ulpi);
+        void (*remove)(struct ulpi *ulpi);
+        struct device_driver driver;
+};
+
+#define to_ulpi_driver(d) container_of(d, struct ulpi_driver, driver)
+
+int ulpi_register_driver(struct ulpi_driver *drv);
+void ulpi_unregister_driver(struct ulpi_driver *drv);
+
+#define module_ulpi_driver(__ulpi_driver) \
+        module_driver(__ulpi_driver, ulpi_register_driver, \
+                      ulpi_unregister_driver)
+
+int ulpi_read(struct ulpi *ulpi, u8 addr);
+int ulpi_write(struct ulpi *ulpi, u8 addr, u8 val);
+
+#endif /* __LINUX_ULPI_DRIVER_H */
diff --git a/include/linux/ulpi/interface.h b/include/linux/ulpi/interface.h
new file mode 100644
index 000000000000..4de8ab491038
--- /dev/null
+++ b/include/linux/ulpi/interface.h
@@ -0,0 +1,23 @@
+#ifndef __LINUX_ULPI_INTERFACE_H
+#define __LINUX_ULPI_INTERFACE_H
+
+#include <linux/types.h>
+
+struct ulpi;
+
+/**
+ * struct ulpi_ops - ULPI register access
+ * @dev: the interface provider
+ * @read: read operation for ULPI register access
+ * @write: write operation for ULPI register access
+ */
+struct ulpi_ops {
+        struct device *dev;
+        int (*read)(struct ulpi_ops *ops, u8 addr);
+        int (*write)(struct ulpi_ops *ops, u8 addr, u8 val);
+};
+
+struct ulpi *ulpi_register_interface(struct device *, struct ulpi_ops *);
+void ulpi_unregister_interface(struct ulpi *);
+
+#endif /* __LINUX_ULPI_INTERFACE_H */
diff --git a/include/linux/ulpi/regs.h b/include/linux/ulpi/regs.h
new file mode 100644
index 000000000000..b5b8b8804560
--- /dev/null
+++ b/include/linux/ulpi/regs.h
@@ -0,0 +1,130 @@
+#ifndef __LINUX_ULPI_REGS_H
+#define __LINUX_ULPI_REGS_H
+
+/*
+ * Macros for Set and Clear
+ * See ULPI 1.1 specification to find the registers with Set and Clear offsets
+ */
+#define ULPI_SET(a)                             (a + 1)
+#define ULPI_CLR(a)                             (a + 2)
+
+/*
+ * Register Map
+ */
+#define ULPI_VENDOR_ID_LOW                      0x00
+#define ULPI_VENDOR_ID_HIGH                     0x01
+#define ULPI_PRODUCT_ID_LOW                     0x02
+#define ULPI_PRODUCT_ID_HIGH                    0x03
+#define ULPI_FUNC_CTRL                          0x04
+#define ULPI_IFC_CTRL                           0x07
+#define ULPI_OTG_CTRL                           0x0a
+#define ULPI_USB_INT_EN_RISE                    0x0d
+#define ULPI_USB_INT_EN_FALL                    0x10
+#define ULPI_USB_INT_STS                        0x13
+#define ULPI_USB_INT_LATCH                      0x14
+#define ULPI_DEBUG                              0x15
+#define ULPI_SCRATCH                            0x16
+/* Optional Carkit Registers */
+#define ULPI_CARKIT_CTRL                        0x19
+#define ULPI_CARKIT_INT_DELAY                   0x1c
+#define ULPI_CARKIT_INT_EN                      0x1d
+#define ULPI_CARKIT_INT_STS                     0x20
+#define ULPI_CARKIT_INT_LATCH                   0x21
+#define ULPI_CARKIT_PLS_CTRL                    0x22
+/* Other Optional Registers */
+#define ULPI_TX_POS_WIDTH                       0x25
+#define ULPI_TX_NEG_WIDTH                       0x26
+#define ULPI_POLARITY_RECOVERY                  0x27
+/* Access Extended Register Set */
+#define ULPI_ACCESS_EXTENDED                    0x2f
+/* Vendor Specific */
+#define ULPI_VENDOR_SPECIFIC                    0x30
+/* Extended Registers */
+#define ULPI_EXT_VENDOR_SPECIFIC                0x80
+
+/*
+ * Register Bits
+ */
+
+/* Function Control */
+#define ULPI_FUNC_CTRL_XCVRSEL                  BIT(0)
+#define  ULPI_FUNC_CTRL_XCVRSEL_MASK            0x3
+#define  ULPI_FUNC_CTRL_HIGH_SPEED              0x0
+#define  ULPI_FUNC_CTRL_FULL_SPEED              0x1
+#define  ULPI_FUNC_CTRL_LOW_SPEED               0x2
+#define  ULPI_FUNC_CTRL_FS4LS                   0x3
+#define ULPI_FUNC_CTRL_TERMSELECT               BIT(2)
+#define ULPI_FUNC_CTRL_OPMODE                   BIT(3)
+#define  ULPI_FUNC_CTRL_OPMODE_MASK             (0x3 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NORMAL           (0x0 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NONDRIVING       (0x1 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI     (0x2 << 3)
+#define  ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP     (0x3 << 3)
+#define ULPI_FUNC_CTRL_RESET                    BIT(5)
+#define ULPI_FUNC_CTRL_SUSPENDM                 BIT(6)
+
+/* Interface Control */
+#define ULPI_IFC_CTRL_6_PIN_SERIAL_MODE         BIT(0)
+#define ULPI_IFC_CTRL_3_PIN_SERIAL_MODE         BIT(1)
+#define ULPI_IFC_CTRL_CARKITMODE                BIT(2)
+#define ULPI_IFC_CTRL_CLOCKSUSPENDM             BIT(3)
+#define ULPI_IFC_CTRL_AUTORESUME                BIT(4)
+#define ULPI_IFC_CTRL_EXTERNAL_VBUS             BIT(5)
+#define ULPI_IFC_CTRL_PASSTHRU                  BIT(6)
+#define ULPI_IFC_CTRL_PROTECT_IFC_DISABLE       BIT(7)
+
+/* OTG Control */
+#define ULPI_OTG_CTRL_ID_PULLUP                 BIT(0)
+#define ULPI_OTG_CTRL_DP_PULLDOWN               BIT(1)
+#define ULPI_OTG_CTRL_DM_PULLDOWN               BIT(2)
+#define ULPI_OTG_CTRL_DISCHRGVBUS               BIT(3)
+#define ULPI_OTG_CTRL_CHRGVBUS                  BIT(4)
+#define ULPI_OTG_CTRL_DRVVBUS                   BIT(5)
+#define ULPI_OTG_CTRL_DRVVBUS_EXT               BIT(6)
+#define ULPI_OTG_CTRL_EXTVBUSIND                BIT(7)
+
+/* USB Interrupt Enable Rising,
+ * USB Interrupt Enable Falling,
+ * USB Interrupt Status and
+ * USB Interrupt Latch
+ */
+#define ULPI_INT_HOST_DISCONNECT                BIT(0)
+#define ULPI_INT_VBUS_VALID                     BIT(1)
+#define ULPI_INT_SESS_VALID                     BIT(2)
+#define ULPI_INT_SESS_END                       BIT(3)
+#define ULPI_INT_IDGRD                          BIT(4)
+
+/* Debug */
+#define ULPI_DEBUG_LINESTATE0                   BIT(0)
+#define ULPI_DEBUG_LINESTATE1                   BIT(1)
+
+/* Carkit Control */
+#define ULPI_CARKIT_CTRL_CARKITPWR              BIT(0)
+#define ULPI_CARKIT_CTRL_IDGNDDRV               BIT(1)
+#define ULPI_CARKIT_CTRL_TXDEN                  BIT(2)
+#define ULPI_CARKIT_CTRL_RXDEN                  BIT(3)
+#define ULPI_CARKIT_CTRL_SPKLEFTEN              BIT(4)
+#define ULPI_CARKIT_CTRL_SPKRIGHTEN             BIT(5)
+#define ULPI_CARKIT_CTRL_MICEN                  BIT(6)
+
+/* Carkit Interrupt Enable */
+#define ULPI_CARKIT_INT_EN_IDFLOAT_RISE         BIT(0)
+#define ULPI_CARKIT_INT_EN_IDFLOAT_FALL         BIT(1)
+#define ULPI_CARKIT_INT_EN_CARINTDET            BIT(2)
+#define ULPI_CARKIT_INT_EN_DP_RISE              BIT(3)
+#define ULPI_CARKIT_INT_EN_DP_FALL              BIT(4)
+
+/* Carkit Interrupt Status and
+ * Carkit Interrupt Latch
+ */
+#define ULPI_CARKIT_INT_IDFLOAT                 BIT(0)
+#define ULPI_CARKIT_INT_CARINTDET               BIT(1)
+#define ULPI_CARKIT_INT_DP                      BIT(2)
+
+/* Carkit Pulse Control*/
+#define ULPI_CARKIT_PLS_CTRL_TXPLSEN            BIT(0)
+#define ULPI_CARKIT_PLS_CTRL_RXPLSEN            BIT(1)
+#define ULPI_CARKIT_PLS_CTRL_SPKRLEFT_BIASEN    BIT(2)
+#define ULPI_CARKIT_PLS_CTRL_SPKRRIGHT_BIASEN   BIT(3)
+
+#endif /* __LINUX_ULPI_REGS_H */
diff --git a/include/linux/usb/cdc_ncm.h b/include/linux/usb/cdc_ncm.h
index 7c9b484735c5..1f6526c76ee8 100644
--- a/include/linux/usb/cdc_ncm.h
+++ b/include/linux/usb/cdc_ncm.h
@@ -80,6 +80,9 @@
 #define CDC_NCM_TIMER_INTERVAL_MIN              5UL
 #define CDC_NCM_TIMER_INTERVAL_MAX              (U32_MAX / NSEC_PER_USEC)
 
+/* Driver flags */
+#define CDC_NCM_FLAG_NDP_TO_END 0x02            /* NDP is placed at end of frame */
+
 #define cdc_ncm_comm_intf_is_mbim(x)  ((x)->desc.bInterfaceSubClass == USB_CDC_SUBCLASS_MBIM && \
                                        (x)->desc.bInterfaceProtocol == USB_CDC_PROTO_NONE)
 #define cdc_ncm_data_intf_is_mbim(x)  ((x)->desc.bInterfaceProtocol == USB_CDC_MBIM_PROTO_NTB)
@@ -103,9 +106,11 @@ struct cdc_ncm_ctx {
 
         spinlock_t mtx;
         atomic_t stop;
+        int drvflags;
 
         u32 timer_interval;
         u32 max_ndp_size;
+        struct usb_cdc_ncm_ndp16 *delayed_ndp16;
 
         u32 tx_timer_pending;
         u32 tx_curr_frame_num;
@@ -133,7 +138,7 @@ struct cdc_ncm_ctx {
 };
 
 u8 cdc_ncm_select_altsetting(struct usb_interface *intf);
-int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting);
+int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting, int drvflags);
 void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf);
 struct sk_buff *cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign);
 int cdc_ncm_rx_verify_nth16(struct cdc_ncm_ctx *ctx, struct sk_buff *skb_in);
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 68b1e836dff1..c9aa7792de10 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -622,8 +622,6 @@ extern struct list_head usb_bus_list;
 extern struct mutex usb_bus_list_lock;
 extern wait_queue_head_t usb_kill_urb_queue;
 
-extern int usb_find_interface_driver(struct usb_device *dev,
-        struct usb_interface *interface);
 
 #define usb_endpoint_out(ep_dir)        (!((ep_dir) & USB_DIR_IN))
 
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 7dbecf9a4656..e55a1504266e 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -18,6 +18,7 @@
 #ifndef __ASM_ARCH_MSM_HSUSB_H
 #define __ASM_ARCH_MSM_HSUSB_H
 
+#include <linux/extcon.h>
 #include <linux/types.h>
 #include <linux/usb/otg.h>
 #include <linux/clk.h>
@@ -120,6 +121,17 @@ struct msm_otg_platform_data {
 };
 
 /**
+ * struct msm_usb_cable - structure for exteternal connector cable
+ *                        state tracking
+ * @nb: hold event notification callback
+ * @conn: used for notification registration
+ */
+struct msm_usb_cable {
+        struct notifier_block           nb;
+        struct extcon_specific_cable_nb conn;
+};
+
+/**
  * struct msm_otg: OTG driver data. Shared by HCD and DCD.
  * @otg: USB OTG Transceiver structure.
  * @pdata: otg device platform data.
@@ -138,6 +150,11 @@ struct msm_otg_platform_data {
  * @chg_type: The type of charger attached.
  * @dcd_retires: The retry count used to track Data contact
  *               detection process.
+ * @manual_pullup: true if VBUS is not routed to USB controller/phy
+ *      and controller driver therefore enables pull-up explicitly before
+ *      starting controller using usbcmd run/stop bit.
+ * @vbus: VBUS signal state trakining, using extcon framework
+ * @id: ID signal state trakining, using extcon framework
  */
 struct msm_otg {
         struct usb_phy phy;
@@ -166,6 +183,11 @@ struct msm_otg {
         struct reset_control *phy_rst;
         struct reset_control *link_rst;
         int vdd_levels[3];
+
+        bool manual_pullup;
+
+        struct msm_usb_cable vbus;
+        struct msm_usb_cable id;
 };
 
 #endif
diff --git a/include/linux/usb/msm_hsusb_hw.h b/include/linux/usb/msm_hsusb_hw.h
index a29f6030afb1..e159b39f67a2 100644
--- a/include/linux/usb/msm_hsusb_hw.h
+++ b/include/linux/usb/msm_hsusb_hw.h
@@ -21,6 +21,8 @@
 
 #define USB_AHBBURST         (MSM_USB_BASE + 0x0090)
 #define USB_AHBMODE          (MSM_USB_BASE + 0x0098)
+#define USB_GENCONFIG_2      (MSM_USB_BASE + 0x00a0)
+
 #define USB_CAPLENGTH        (MSM_USB_BASE + 0x0100) /* 8 bit */
 
 #define USB_USBCMD           (MSM_USB_BASE + 0x0140)
@@ -30,6 +32,9 @@
 #define USB_PHY_CTRL         (MSM_USB_BASE + 0x0240)
 #define USB_PHY_CTRL2        (MSM_USB_BASE + 0x0278)
 
+#define GENCONFIG_2_SESS_VLD_CTRL_EN    BIT(7)
+#define USBCMD_SESS_VLD_CTRL            BIT(25)
+
 #define USBCMD_RESET   2
 #define USB_USBINTR          (MSM_USB_BASE + 0x0148)
 
@@ -50,6 +55,10 @@
 #define ULPI_PWR_CLK_MNG_REG    0x88
 #define OTG_COMP_DISABLE        BIT(0)
 
+#define ULPI_MISC_A                     0x96
+#define ULPI_MISC_A_VBUSVLDEXTSEL       BIT(1)
+#define ULPI_MISC_A_VBUSVLDEXT          BIT(0)
+
 #define ASYNC_INTR_CTRL         (1 << 29) /* Enable async interrupt */
 #define ULPI_STP_CTRL           (1 << 30) /* Block communication with PHY */
 #define PHY_RETEN               (1 << 1) /* PHY retention enable/disable */
diff --git a/include/linux/usb/net2280.h b/include/linux/usb/net2280.h
index 148b8fa5b1a2..725120224472 100644
--- a/include/linux/usb/net2280.h
+++ b/include/linux/usb/net2280.h
@@ -168,6 +168,9 @@ struct net2280_regs {
 #define     ENDPOINT_B_INTERRUPT                                2
 #define     ENDPOINT_A_INTERRUPT                                1
 #define     ENDPOINT_0_INTERRUPT                                0
+#define     USB3380_IRQSTAT0_EP_INTR_MASK_IN (0xF << 17)
+#define     USB3380_IRQSTAT0_EP_INTR_MASK_OUT (0xF << 1)
+
         u32             irqstat1;
 #define     POWER_STATE_CHANGE_INTERRUPT                        27
 #define     PCI_ARBITER_TIMEOUT_INTERRUPT                       26
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index bc91b5d380fd..e39f251cf861 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -205,6 +205,8 @@ extern struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index);
 extern struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index);
 extern struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
         const char *phandle, u8 index);
+extern struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
+        struct device_node *node, struct notifier_block *nb);
 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,
@@ -238,6 +240,12 @@ static inline struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
         return ERR_PTR(-ENXIO);
 }
 
+static inline struct usb_phy *devm_usb_get_phy_by_node(struct device *dev,
+        struct device_node *node, struct notifier_block *nb)
+{
+        return ERR_PTR(-ENXIO);
+}
+
 static inline void usb_put_phy(struct usb_phy *x)
 {
 }
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
index f06529c14141..3dd5a781da99 100644
--- a/include/linux/usb/renesas_usbhs.h
+++ b/include/linux/usb/renesas_usbhs.h
@@ -169,8 +169,7 @@ struct renesas_usbhs_driver_param {
 #define USBHS_USB_DMAC_XFER_SIZE        32      /* hardcode the xfer size */
 };
 
-#define USBHS_TYPE_R8A7790 1
-#define USBHS_TYPE_R8A7791 2
+#define USBHS_TYPE_RCAR_GEN2    1
 
 /*
  * option:
diff --git a/include/linux/usb/ulpi.h b/include/linux/usb/ulpi.h
index 5c295c26ad37..5f07407a367a 100644
--- a/include/linux/usb/ulpi.h
+++ b/include/linux/usb/ulpi.h
@@ -12,6 +12,8 @@
 #define __LINUX_USB_ULPI_H
 
 #include <linux/usb/otg.h>
+#include <linux/ulpi/regs.h>
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -49,138 +51,6 @@
 
 /*-------------------------------------------------------------------------*/
 
-/*
- * Macros for Set and Clear
- * See ULPI 1.1 specification to find the registers with Set and Clear offsets
- */
-#define ULPI_SET(a)                             (a + 1)
-#define ULPI_CLR(a)                             (a + 2)
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * Register Map
- */
-#define ULPI_VENDOR_ID_LOW                      0x00
-#define ULPI_VENDOR_ID_HIGH                     0x01
-#define ULPI_PRODUCT_ID_LOW                     0x02
-#define ULPI_PRODUCT_ID_HIGH                    0x03
-#define ULPI_FUNC_CTRL                          0x04
-#define ULPI_IFC_CTRL                           0x07
-#define ULPI_OTG_CTRL                           0x0a
-#define ULPI_USB_INT_EN_RISE                    0x0d
-#define ULPI_USB_INT_EN_FALL                    0x10
-#define ULPI_USB_INT_STS                        0x13
-#define ULPI_USB_INT_LATCH                      0x14
-#define ULPI_DEBUG                              0x15
-#define ULPI_SCRATCH                            0x16
-/* Optional Carkit Registers */
-#define ULPI_CARCIT_CTRL                        0x19
-#define ULPI_CARCIT_INT_DELAY                   0x1c
-#define ULPI_CARCIT_INT_EN                      0x1d
-#define ULPI_CARCIT_INT_STS                     0x20
-#define ULPI_CARCIT_INT_LATCH                   0x21
-#define ULPI_CARCIT_PLS_CTRL                    0x22
-/* Other Optional Registers */
-#define ULPI_TX_POS_WIDTH                       0x25
-#define ULPI_TX_NEG_WIDTH                       0x26
-#define ULPI_POLARITY_RECOVERY                  0x27
-/* Access Extended Register Set */
-#define ULPI_ACCESS_EXTENDED                    0x2f
-/* Vendor Specific */
-#define ULPI_VENDOR_SPECIFIC                    0x30
-/* Extended Registers */
-#define ULPI_EXT_VENDOR_SPECIFIC                0x80
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * Register Bits
- */
-
-/* Function Control */
-#define ULPI_FUNC_CTRL_XCVRSEL                  (1 << 0)
-#define  ULPI_FUNC_CTRL_XCVRSEL_MASK            (3 << 0)
-#define  ULPI_FUNC_CTRL_HIGH_SPEED              (0 << 0)
-#define  ULPI_FUNC_CTRL_FULL_SPEED              (1 << 0)
-#define  ULPI_FUNC_CTRL_LOW_SPEED               (2 << 0)
-#define  ULPI_FUNC_CTRL_FS4LS                   (3 << 0)
-#define ULPI_FUNC_CTRL_TERMSELECT               (1 << 2)
-#define ULPI_FUNC_CTRL_OPMODE                   (1 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_MASK             (3 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_NORMAL           (0 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_NONDRIVING       (1 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_DISABLE_NRZI     (2 << 3)
-#define  ULPI_FUNC_CTRL_OPMODE_NOSYNC_NOEOP     (3 << 3)
-#define ULPI_FUNC_CTRL_RESET                    (1 << 5)
-#define ULPI_FUNC_CTRL_SUSPENDM                 (1 << 6)
-
-/* Interface Control */
-#define ULPI_IFC_CTRL_6_PIN_SERIAL_MODE         (1 << 0)
-#define ULPI_IFC_CTRL_3_PIN_SERIAL_MODE         (1 << 1)
-#define ULPI_IFC_CTRL_CARKITMODE                (1 << 2)
-#define ULPI_IFC_CTRL_CLOCKSUSPENDM             (1 << 3)
-#define ULPI_IFC_CTRL_AUTORESUME                (1 << 4)
-#define ULPI_IFC_CTRL_EXTERNAL_VBUS             (1 << 5)
-#define ULPI_IFC_CTRL_PASSTHRU                  (1 << 6)
-#define ULPI_IFC_CTRL_PROTECT_IFC_DISABLE       (1 << 7)
-
-/* OTG Control */
-#define ULPI_OTG_CTRL_ID_PULLUP                 (1 << 0)
-#define ULPI_OTG_CTRL_DP_PULLDOWN               (1 << 1)
-#define ULPI_OTG_CTRL_DM_PULLDOWN               (1 << 2)
-#define ULPI_OTG_CTRL_DISCHRGVBUS               (1 << 3)
-#define ULPI_OTG_CTRL_CHRGVBUS                  (1 << 4)
-#define ULPI_OTG_CTRL_DRVVBUS                   (1 << 5)
-#define ULPI_OTG_CTRL_DRVVBUS_EXT               (1 << 6)
-#define ULPI_OTG_CTRL_EXTVBUSIND                (1 << 7)
-
-/* USB Interrupt Enable Rising,
- * USB Interrupt Enable Falling,
- * USB Interrupt Status and
- * USB Interrupt Latch
- */
-#define ULPI_INT_HOST_DISCONNECT                (1 << 0)
-#define ULPI_INT_VBUS_VALID                     (1 << 1)
-#define ULPI_INT_SESS_VALID                     (1 << 2)
-#define ULPI_INT_SESS_END                       (1 << 3)
-#define ULPI_INT_IDGRD                          (1 << 4)
-
-/* Debug */
-#define ULPI_DEBUG_LINESTATE0                   (1 << 0)
-#define ULPI_DEBUG_LINESTATE1                   (1 << 1)
-
-/* Carkit Control */
-#define ULPI_CARKIT_CTRL_CARKITPWR              (1 << 0)
-#define ULPI_CARKIT_CTRL_IDGNDDRV               (1 << 1)
-#define ULPI_CARKIT_CTRL_TXDEN                  (1 << 2)
-#define ULPI_CARKIT_CTRL_RXDEN                  (1 << 3)
-#define ULPI_CARKIT_CTRL_SPKLEFTEN              (1 << 4)
-#define ULPI_CARKIT_CTRL_SPKRIGHTEN             (1 << 5)
-#define ULPI_CARKIT_CTRL_MICEN                  (1 << 6)
-
-/* Carkit Interrupt Enable */
-#define ULPI_CARKIT_INT_EN_IDFLOAT_RISE         (1 << 0)
-#define ULPI_CARKIT_INT_EN_IDFLOAT_FALL         (1 << 1)
-#define ULPI_CARKIT_INT_EN_CARINTDET            (1 << 2)
-#define ULPI_CARKIT_INT_EN_DP_RISE              (1 << 3)
-#define ULPI_CARKIT_INT_EN_DP_FALL              (1 << 4)
-
-/* Carkit Interrupt Status and
- * Carkit Interrupt Latch
- */
-#define ULPI_CARKIT_INT_IDFLOAT                 (1 << 0)
-#define ULPI_CARKIT_INT_CARINTDET               (1 << 1)
-#define ULPI_CARKIT_INT_DP                      (1 << 2)
-
-/* Carkit Pulse Control*/
-#define ULPI_CARKIT_PLS_CTRL_TXPLSEN            (1 << 0)
-#define ULPI_CARKIT_PLS_CTRL_RXPLSEN            (1 << 1)
-#define ULPI_CARKIT_PLS_CTRL_SPKRLEFT_BIASEN    (1 << 2)
-#define ULPI_CARKIT_PLS_CTRL_SPKRRIGHT_BIASEN   (1 << 3)
-
-/*-------------------------------------------------------------------------*/
-
 #if IS_ENABLED(CONFIG_USB_ULPI)
 struct usb_phy *otg_ulpi_create(struct usb_phy_io_ops *ops,
                                         unsigned int flags);
diff --git a/include/linux/usb/usb338x.h b/include/linux/usb/usb338x.h
index f92eb635b9d3..11525d8d89a7 100644
--- a/include/linux/usb/usb338x.h
+++ b/include/linux/usb/usb338x.h
@@ -43,6 +43,10 @@
 #define     IN_ENDPOINT_TYPE                    12
 #define     OUT_ENDPOINT_ENABLE                 10
 #define     OUT_ENDPOINT_TYPE                    8
+#define USB3380_EP_CFG_MASK_IN ((0x3 << IN_ENDPOINT_TYPE) | \
+                                BIT(IN_ENDPOINT_ENABLE))
+#define USB3380_EP_CFG_MASK_OUT ((0x3 << OUT_ENDPOINT_TYPE) | \
+                                BIT(OUT_ENDPOINT_ENABLE))
 
 struct usb338x_usb_ext_regs {
         u32     usbclass;
diff --git a/include/linux/virtio_byteorder.h b/include/linux/virtio_byteorder.h
index 51865d05b267..ce63a2c3a612 100644
--- a/include/linux/virtio_byteorder.h
+++ b/include/linux/virtio_byteorder.h
@@ -3,17 +3,21 @@
 #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 bool virtio_legacy_is_little_endian(void)
+{
+#ifdef __LITTLE_ENDIAN
+        return true;
+#else
+        return false;
+#endif
+}
 
 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;
+                return be16_to_cpu((__force __be16)val);
 }
 
 static inline __virtio16 __cpu_to_virtio16(bool little_endian, u16 val)
@@ -21,7 +25,7 @@ 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;
+                return (__force __virtio16)cpu_to_be16(val);
 }
 
 static inline u32 __virtio32_to_cpu(bool little_endian, __virtio32 val)
@@ -29,7 +33,7 @@ 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;
+                return be32_to_cpu((__force __be32)val);
 }
 
 static inline __virtio32 __cpu_to_virtio32(bool little_endian, u32 val)
@@ -37,7 +41,7 @@ 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;
+                return (__force __virtio32)cpu_to_be32(val);
 }
 
 static inline u64 __virtio64_to_cpu(bool little_endian, __virtio64 val)
@@ -45,7 +49,7 @@ 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;
+                return be64_to_cpu((__force __be64)val);
 }
 
 static inline __virtio64 __cpu_to_virtio64(bool little_endian, u64 val)
@@ -53,7 +57,7 @@ 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;
+                return (__force __virtio64)cpu_to_be64(val);
 }
 
 #endif /* _LINUX_VIRTIO_BYTEORDER */
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 1e306f727edc..e5ce8ab0b8b0 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -205,35 +205,41 @@ int virtqueue_set_affinity(struct virtqueue *vq, int cpu)
         return 0;
 }
 
+static inline bool virtio_is_little_endian(struct virtio_device *vdev)
+{
+        return virtio_has_feature(vdev, VIRTIO_F_VERSION_1) ||
+                virtio_legacy_is_little_endian();
+}
+
 /* 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);
+        return __virtio16_to_cpu(virtio_is_little_endian(vdev), 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);
+        return __cpu_to_virtio16(virtio_is_little_endian(vdev), 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);
+        return __virtio32_to_cpu(virtio_is_little_endian(vdev), 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);
+        return __cpu_to_virtio32(virtio_is_little_endian(vdev), 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);
+        return __virtio64_to_cpu(virtio_is_little_endian(vdev), 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);
+        return __cpu_to_virtio64(virtio_is_little_endian(vdev), val);
 }
 
 /* Config space accessors. */
diff --git a/include/linux/vme.h b/include/linux/vme.h
index 79242e9c06b8..c0131358f351 100644
--- a/include/linux/vme.h
+++ b/include/linux/vme.h
@@ -120,6 +120,8 @@ void vme_free_consistent(struct vme_resource *, size_t,  void *,
         dma_addr_t);
 
 size_t vme_get_size(struct vme_resource *);
+int vme_check_window(u32 aspace, unsigned long long vme_base,
+                     unsigned long long size);
 
 struct vme_resource *vme_slave_request(struct vme_dev *, u32, u32);
 int vme_slave_set(struct vme_resource *, int, unsigned long long,
diff --git a/include/linux/vringh.h b/include/linux/vringh.h
index a3fa537e717a..bc6c28d04263 100644
--- a/include/linux/vringh.h
+++ b/include/linux/vringh.h
@@ -226,33 +226,39 @@ static inline void vringh_notify(struct vringh *vrh)
                 vrh->notify(vrh);
 }
 
+static inline bool vringh_is_little_endian(const struct vringh *vrh)
+{
+        return vrh->little_endian ||
+                virtio_legacy_is_little_endian();
+}
+
 static inline u16 vringh16_to_cpu(const struct vringh *vrh, __virtio16 val)
 {
-        return __virtio16_to_cpu(vrh->little_endian, val);
+        return __virtio16_to_cpu(vringh_is_little_endian(vrh), val);
 }
 
 static inline __virtio16 cpu_to_vringh16(const struct vringh *vrh, u16 val)
 {
-        return __cpu_to_virtio16(vrh->little_endian, val);
+        return __cpu_to_virtio16(vringh_is_little_endian(vrh), val);
 }
 
 static inline u32 vringh32_to_cpu(const struct vringh *vrh, __virtio32 val)
 {
-        return __virtio32_to_cpu(vrh->little_endian, val);
+        return __virtio32_to_cpu(vringh_is_little_endian(vrh), val);
 }
 
 static inline __virtio32 cpu_to_vringh32(const struct vringh *vrh, u32 val)
 {
-        return __cpu_to_virtio32(vrh->little_endian, val);
+        return __cpu_to_virtio32(vringh_is_little_endian(vrh), val);
 }
 
 static inline u64 vringh64_to_cpu(const struct vringh *vrh, __virtio64 val)
 {
-        return __virtio64_to_cpu(vrh->little_endian, val);
+        return __virtio64_to_cpu(vringh_is_little_endian(vrh), val);
 }
 
 static inline __virtio64 cpu_to_vringh64(const struct vringh *vrh, u64 val)
 {
-        return __cpu_to_virtio64(vrh->little_endian, val);
+        return __cpu_to_virtio64(vringh_is_little_endian(vrh), val);
 }
 #endif /* _LINUX_VRINGH_H */
diff --git a/include/linux/wait.h b/include/linux/wait.h
index d69ac4ecc88b..1e1bf9f963a9 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -358,6 +358,19 @@ do {									\
         __ret;                                                          \
 })
 
+#define __wait_event_exclusive_cmd(wq, condition, cmd1, cmd2)           \
+        (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 1, 0,  \
+                            cmd1; schedule(); cmd2)
+/*
+ * Just like wait_event_cmd(), except it sets exclusive flag
+ */
+#define wait_event_exclusive_cmd(wq, condition, cmd1, cmd2)             \
+do {                                                                    \
+        if (condition)                                                  \
+                break;                                                  \
+        __wait_event_exclusive_cmd(wq, condition, cmd1, cmd2);          \
+} while (0)
+
 #define __wait_event_cmd(wq, condition, cmd1, cmd2)                     \
         (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,  \
                             cmd1; schedule(); cmd2)
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index a746bf5216f8..f47feada5b42 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -65,6 +65,8 @@ struct watchdog_ops {
  * @driver-data:Pointer to the drivers private data.
  * @lock:       Lock for watchdog core internal use only.
  * @status:     Field that contains the devices internal status bits.
+ * @deferred: entry in wtd_deferred_reg_list which is used to
+ *                         register early initialized watchdogs.
  *
  * The watchdog_device structure contains all information about a
  * watchdog timer device.
@@ -95,6 +97,7 @@ struct watchdog_device {
 #define WDOG_ALLOW_RELEASE      2       /* Did we receive the magic char ? */
 #define WDOG_NO_WAY_OUT         3       /* Is 'nowayout' feature set ? */
 #define WDOG_UNREGISTERED       4       /* Has the device been unregistered */
+        struct list_head deferred;
 };
 
 #define WATCHDOG_NOWAYOUT               IS_BUILTIN(CONFIG_WATCHDOG_NOWAYOUT)
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index deee212af8e0..738b30b39b68 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -424,6 +424,7 @@ struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask);
 void free_workqueue_attrs(struct workqueue_attrs *attrs);
 int apply_workqueue_attrs(struct workqueue_struct *wq,
                           const struct workqueue_attrs *attrs);
+int workqueue_set_unbound_cpumask(cpumask_var_t cpumask);
 
 extern bool queue_work_on(int cpu, struct workqueue_struct *wq,
                         struct work_struct *work);
@@ -434,7 +435,6 @@ extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
 
 extern void flush_workqueue(struct workqueue_struct *wq);
 extern void drain_workqueue(struct workqueue_struct *wq);
-extern void flush_scheduled_work(void);
 
 extern int schedule_on_each_cpu(work_func_t func);
 
@@ -531,6 +531,35 @@ static inline bool schedule_work(struct work_struct *work)
 }
 
 /**
+ * flush_scheduled_work - ensure that any scheduled work has run to completion.
+ *
+ * Forces execution of the kernel-global workqueue and blocks until its
+ * completion.
+ *
+ * Think twice before calling this function!  It's very easy to get into
+ * trouble if you don't take great care.  Either of the following situations
+ * will lead to deadlock:
+ *
+ *      One of the work items currently on the workqueue needs to acquire
+ *      a lock held by your code or its caller.
+ *
+ *      Your code is running in the context of a work routine.
+ *
+ * They will be detected by lockdep when they occur, but the first might not
+ * occur very often.  It depends on what work items are on the workqueue and
+ * what locks they need, which you have no control over.
+ *
+ * In most situations flushing the entire workqueue is overkill; you merely
+ * need to know that a particular work item isn't queued and isn't running.
+ * In such cases you should use cancel_delayed_work_sync() or
+ * cancel_work_sync() instead.
+ */
+static inline void flush_scheduled_work(void)
+{
+        flush_workqueue(system_wq);
+}
+
+/**
  * schedule_delayed_work_on - queue work in global workqueue on CPU after delay
  * @cpu: cpu to use
  * @dwork: job to be done
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index b2dd371ec0ca..b333c945e571 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -7,6 +7,8 @@
 #include <linux/sched.h>
 #include <linux/workqueue.h>
 #include <linux/fs.h>
+#include <linux/flex_proportions.h>
+#include <linux/backing-dev-defs.h>
 
 DECLARE_PER_CPU(int, dirty_throttle_leaks);
 
@@ -84,18 +86,95 @@ struct writeback_control {
         unsigned for_reclaim:1;         /* Invoked from the page allocator */
         unsigned range_cyclic:1;        /* range_start is cyclic */
         unsigned for_sync:1;            /* sync(2) WB_SYNC_ALL writeback */
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct bdi_writeback *wb;       /* wb this writeback is issued under */
+        struct inode *inode;            /* inode being written out */
+
+        /* foreign inode detection, see wbc_detach_inode() */
+        int wb_id;                      /* current wb id */
+        int wb_lcand_id;                /* last foreign candidate wb id */
+        int wb_tcand_id;                /* this foreign candidate wb id */
+        size_t wb_bytes;                /* bytes written by current wb */
+        size_t wb_lcand_bytes;          /* bytes written by last candidate */
+        size_t wb_tcand_bytes;          /* bytes written by this candidate */
+#endif
 };
 
 /*
+ * A wb_domain represents a domain that wb's (bdi_writeback's) belong to
+ * and are measured against each other in.  There always is one global
+ * domain, global_wb_domain, that every wb in the system is a member of.
+ * This allows measuring the relative bandwidth of each wb to distribute
+ * dirtyable memory accordingly.
+ */
+struct wb_domain {
+        spinlock_t lock;
+
+        /*
+         * Scale the writeback cache size proportional to the relative
+         * writeout speed.
+         *
+         * We do this by keeping a floating proportion between BDIs, based
+         * on page writeback completions [end_page_writeback()]. Those
+         * devices that write out pages fastest will get the larger share,
+         * while the slower will get a smaller share.
+         *
+         * We use page writeout completions because we are interested in
+         * getting rid of dirty pages. Having them written out is the
+         * primary goal.
+         *
+         * We introduce a concept of time, a period over which we measure
+         * these events, because demand can/will vary over time. The length
+         * of this period itself is measured in page writeback completions.
+         */
+        struct fprop_global completions;
+        struct timer_list period_timer; /* timer for aging of completions */
+        unsigned long period_time;
+
+        /*
+         * The dirtyable memory and dirty threshold could be suddenly
+         * knocked down by a large amount (eg. on the startup of KVM in a
+         * swapless system). This may throw the system into deep dirty
+         * exceeded state and throttle heavy/light dirtiers alike. To
+         * retain good responsiveness, maintain global_dirty_limit for
+         * tracking slowly down to the knocked down dirty threshold.
+         *
+         * Both fields are protected by ->lock.
+         */
+        unsigned long dirty_limit_tstamp;
+        unsigned long dirty_limit;
+};
+
+/**
+ * wb_domain_size_changed - memory available to a wb_domain has changed
+ * @dom: wb_domain of interest
+ *
+ * This function should be called when the amount of memory available to
+ * @dom has changed.  It resets @dom's dirty limit parameters to prevent
+ * the past values which don't match the current configuration from skewing
+ * dirty throttling.  Without this, when memory size of a wb_domain is
+ * greatly reduced, the dirty throttling logic may allow too many pages to
+ * be dirtied leading to consecutive unnecessary OOMs and may get stuck in
+ * that situation.
+ */
+static inline void wb_domain_size_changed(struct wb_domain *dom)
+{
+        spin_lock(&dom->lock);
+        dom->dirty_limit_tstamp = jiffies;
+        dom->dirty_limit = 0;
+        spin_unlock(&dom->lock);
+}
+
+/*
  * fs/fs-writeback.c
  */     
 struct bdi_writeback;
 void writeback_inodes_sb(struct super_block *, enum wb_reason reason);
 void writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
                                                         enum wb_reason reason);
-int try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason);
-int try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
-                                  enum wb_reason reason);
+bool try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason);
+bool try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
+                                   enum wb_reason reason);
 void sync_inodes_sb(struct super_block *);
 void wakeup_flusher_threads(long nr_pages, enum wb_reason reason);
 void inode_wait_for_writeback(struct inode *inode);
@@ -107,6 +186,123 @@ static inline void wait_on_inode(struct inode *inode)
         wait_on_bit(&inode->i_state, __I_NEW, TASK_UNINTERRUPTIBLE);
 }
 
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+#include <linux/cgroup.h>
+#include <linux/bio.h>
+
+void __inode_attach_wb(struct inode *inode, struct page *page);
+void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
+                                 struct inode *inode)
+        __releases(&inode->i_lock);
+void wbc_detach_inode(struct writeback_control *wbc);
+void wbc_account_io(struct writeback_control *wbc, struct page *page,
+                    size_t bytes);
+
+/**
+ * inode_attach_wb - associate an inode with its wb
+ * @inode: inode of interest
+ * @page: page being dirtied (may be NULL)
+ *
+ * If @inode doesn't have its wb, associate it with the wb matching the
+ * memcg of @page or, if @page is NULL, %current.  May be called w/ or w/o
+ * @inode->i_lock.
+ */
+static inline void inode_attach_wb(struct inode *inode, struct page *page)
+{
+        if (!inode->i_wb)
+                __inode_attach_wb(inode, page);
+}
+
+/**
+ * inode_detach_wb - disassociate an inode from its wb
+ * @inode: inode of interest
+ *
+ * @inode is being freed.  Detach from its wb.
+ */
+static inline void inode_detach_wb(struct inode *inode)
+{
+        if (inode->i_wb) {
+                wb_put(inode->i_wb);
+                inode->i_wb = NULL;
+        }
+}
+
+/**
+ * wbc_attach_fdatawrite_inode - associate wbc and inode for fdatawrite
+ * @wbc: writeback_control of interest
+ * @inode: target inode
+ *
+ * This function is to be used by __filemap_fdatawrite_range(), which is an
+ * alternative entry point into writeback code, and first ensures @inode is
+ * associated with a bdi_writeback and attaches it to @wbc.
+ */
+static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
+                                               struct inode *inode)
+{
+        spin_lock(&inode->i_lock);
+        inode_attach_wb(inode, NULL);
+        wbc_attach_and_unlock_inode(wbc, inode);
+}
+
+/**
+ * wbc_init_bio - writeback specific initializtion of bio
+ * @wbc: writeback_control for the writeback in progress
+ * @bio: bio to be initialized
+ *
+ * @bio is a part of the writeback in progress controlled by @wbc.  Perform
+ * writeback specific initialization.  This is used to apply the cgroup
+ * writeback context.
+ */
+static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
+{
+        /*
+         * pageout() path doesn't attach @wbc to the inode being written
+         * out.  This is intentional as we don't want the function to block
+         * behind a slow cgroup.  Ultimately, we want pageout() to kick off
+         * regular writeback instead of writing things out itself.
+         */
+        if (wbc->wb)
+                bio_associate_blkcg(bio, wbc->wb->blkcg_css);
+}
+
+#else   /* CONFIG_CGROUP_WRITEBACK */
+
+static inline void inode_attach_wb(struct inode *inode, struct page *page)
+{
+}
+
+static inline void inode_detach_wb(struct inode *inode)
+{
+}
+
+static inline void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
+                                               struct inode *inode)
+        __releases(&inode->i_lock)
+{
+        spin_unlock(&inode->i_lock);
+}
+
+static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
+                                               struct inode *inode)
+{
+}
+
+static inline void wbc_detach_inode(struct writeback_control *wbc)
+{
+}
+
+static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
+{
+}
+
+static inline void wbc_account_io(struct writeback_control *wbc,
+                                  struct page *page, size_t bytes)
+{
+}
+
+#endif  /* CONFIG_CGROUP_WRITEBACK */
+
 /*
  * mm/page-writeback.c
  */
@@ -120,8 +316,12 @@ static inline void laptop_sync_completion(void) { }
 #endif
 void throttle_vm_writeout(gfp_t gfp_mask);
 bool zone_dirty_ok(struct zone *zone);
+int wb_domain_init(struct wb_domain *dom, gfp_t gfp);
+#ifdef CONFIG_CGROUP_WRITEBACK
+void wb_domain_exit(struct wb_domain *dom);
+#endif
 
-extern unsigned long global_dirty_limit;
+extern struct wb_domain global_wb_domain;
 
 /* These are exported to sysctl. */
 extern int dirty_background_ratio;
@@ -155,19 +355,12 @@ int dirty_writeback_centisecs_handler(struct ctl_table *, int,
                                       void __user *, size_t *, loff_t *);
 
 void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
-unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
-                               unsigned long dirty);
-
-void __bdi_update_bandwidth(struct backing_dev_info *bdi,
-                            unsigned long thresh,
-                            unsigned long bg_thresh,
-                            unsigned long dirty,
-                            unsigned long bdi_thresh,
-                            unsigned long bdi_dirty,
-                            unsigned long start_time);
+unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh);
 
+void wb_update_bandwidth(struct bdi_writeback *wb, unsigned long start_time);
 void page_writeback_init(void);
 void balance_dirty_pages_ratelimited(struct address_space *mapping);
+bool wb_over_bg_thresh(struct bdi_writeback *wb);
 
 typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
                                 void *data);
diff --git a/include/linux/zpool.h b/include/linux/zpool.h
index 56529b34dc63..d30eff3d84d5 100644
--- a/include/linux/zpool.h
+++ b/include/linux/zpool.h
@@ -81,7 +81,8 @@ struct zpool_driver {
         atomic_t refcount;
         struct list_head list;
 
-        void *(*create)(char *name, gfp_t gfp, struct zpool_ops *ops);
+        void *(*create)(char *name, gfp_t gfp, struct zpool_ops *ops,
+                        struct zpool *zpool);
         void (*destroy)(void *pool);
 
         int (*malloc)(void *pool, size_t size, gfp_t gfp,
@@ -102,6 +103,4 @@ void zpool_register_driver(struct zpool_driver *driver);
 
 int zpool_unregister_driver(struct zpool_driver *driver);
 
-int zpool_evict(void *pool, unsigned long handle);
-
 #endif