208 files changed, 11706 insertions, 2427 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index e4da5e35e29c..c187817471fb 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -158,6 +158,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,50 +253,12 @@ 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_get_node(acpi_handle handle);
@@ -332,6 +304,9 @@ int acpi_check_region(resource_size_t start, resource_size_t n,
 
 int acpi_resources_are_enforced(void);
 
+int acpi_reserve_region(u64 start, unsigned int length, u8 space_id,
+                        unsigned long flags, char *desc);
+
 #ifdef CONFIG_HIBERNATION
 void __init acpi_no_s4_hw_signature(void);
 #endif
@@ -440,6 +415,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);
 
@@ -494,6 +470,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)
 {
@@ -525,6 +502,13 @@ static inline int acpi_check_region(resource_size_t start, resource_size_t n,
         return 0;
 }
 
+static inline int acpi_reserve_region(u64 start, unsigned int length,
+                                      u8 space_id, unsigned long flags,
+                                      char *desc)
+{
+        return -ENXIO;
+}
+
 struct acpi_table_header;
 static inline int acpi_table_parse(char *id,
                                 int (*handler)(struct acpi_table_header *))
@@ -569,6 +553,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 */
@@ -721,6 +710,8 @@ static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev)
         if (adev)
                 adev->driver_gpios = NULL;
 }
+
+int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index);
 #else
 static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
                               const struct acpi_gpio_mapping *gpios)
@@ -728,6 +719,11 @@ static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
         return -ENXIO;
 }
 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
+
+static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
+{
+        return -ENXIO;
+}
 #endif
 
 /* Device properties */
diff --git a/include/linux/alarmtimer.h b/include/linux/alarmtimer.h
index a899402a5a0e..52f3b7da4f2d 100644
--- a/include/linux/alarmtimer.h
+++ b/include/linux/alarmtimer.h
@@ -43,8 +43,8 @@ struct alarm {
 
 void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
                 enum alarmtimer_restart (*function)(struct alarm *, ktime_t));
-int alarm_start(struct alarm *alarm, ktime_t start);
-int alarm_start_relative(struct alarm *alarm, ktime_t start);
+void alarm_start(struct alarm *alarm, ktime_t start);
+void alarm_start_relative(struct alarm *alarm, ktime_t start);
 void alarm_restart(struct alarm *alarm);
 int alarm_try_to_cancel(struct alarm *alarm);
 int alarm_cancel(struct alarm *alarm);
diff --git a/include/linux/ata.h b/include/linux/ata.h
index b666b773e111..fed36418dd1c 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -704,9 +704,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..a48d90e3bcbb
--- /dev/null
+++ b/include/linux/backing-dev-defs.h
@@ -0,0 +1,255 @@
+#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 */
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+        struct backing_dev_info *bdi;   /* the associated bdi */
+        atomic_t refcnt;                /* nr of attached wb's and blkg */
+        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 */
+        struct bdi_writeback_congested wb_congested; /* its congested state */
+#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 */
+#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 aff923ae8c4b..0e6d4828a77a 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -8,106 +8,13 @@
 #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>
 
 int __must_check bdi_init(struct backing_dev_info *bdi);
 void bdi_destroy(struct backing_dev_info *bdi);
@@ -116,99 +23,100 @@ __printf(3, 4)
 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);
-void bdi_unregister(struct backing_dev_info *bdi);
 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
@@ -232,50 +140,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,
@@ -319,4 +234,333 @@ 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)
+{
+        return bdi->wb.congested;
+}
+
+static inline void wb_congested_put(struct bdi_writeback_congested *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/basic_mmio_gpio.h b/include/linux/basic_mmio_gpio.h
index 0e97856b2cff..14eea946e640 100644
--- a/include/linux/basic_mmio_gpio.h
+++ b/include/linux/basic_mmio_gpio.h
@@ -74,5 +74,6 @@ int bgpio_init(struct bgpio_chip *bgc, struct device *dev,
 #define BGPIOF_UNREADABLE_REG_SET       BIT(1) /* reg_set is unreadable */
 #define BGPIOF_UNREADABLE_REG_DIR       BIT(2) /* reg_dir is unreadable */
 #define BGPIOF_BIG_ENDIAN_BYTE_ORDER    BIT(3)
+#define BGPIOF_READ_OUTPUT_REG_SET     BIT(4) /* reg_set stores output value */
 
 #endif /* __BASIC_MMIO_GPIO_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..58cfab80dd70
--- /dev/null
+++ b/include/linux/blk-cgroup.h
@@ -0,0 +1,655 @@
+#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];
+
+#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. blkcg core allocates
+ * policy-specific per-blkcg structures lazily the first time
+ * they are actually needed, so it handles them together with
+ * blkgs. 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;
+
+        /* used during policy activation */
+        struct list_head                alloc_node;
+};
+
+/* 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..6ab9d12d1f17 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
@@ -193,6 +192,7 @@ enum rq_flag_bits {
         __REQ_HASHED,           /* on IO scheduler merge hash */
         __REQ_MQ_INFLIGHT,      /* track inflight for MQ */
         __REQ_NO_TIMEOUT,       /* requests may never expire */
+        __REQ_CLONE,            /* cloned bios */
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -247,5 +247,6 @@ enum rq_flag_bits {
 #define REQ_HASHED              (1ULL << __REQ_HASHED)
 #define REQ_MQ_INFLIGHT         (1ULL << __REQ_MQ_INFLIGHT)
 #define REQ_NO_TIMEOUT          (1ULL << __REQ_NO_TIMEOUT)
+#define REQ_CLONE               (1ULL << __REQ_CLONE)
 
 #endif /* __LINUX_BLK_TYPES_H */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 5d93a6645e88..7f2f54b4587f 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() */
@@ -804,11 +774,7 @@ extern void blk_add_request_payload(struct request *rq, struct page *page,
                 unsigned int len);
 extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
 extern int blk_lld_busy(struct request_queue *q);
-extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
-                             struct bio_set *bs, gfp_t gfp_mask,
-                             int (*bio_ctr)(struct bio *, struct bio *, void *),
-                             void *data);
-extern void blk_rq_unprep_clone(struct request *rq);
+extern void blk_rq_prep_clone(struct request *rq, struct request *rq_src);
 extern int blk_insert_cloned_request(struct request_queue *q,
                                      struct request *rq);
 extern void blk_delay_queue(struct request_queue *, unsigned long);
@@ -821,30 +787,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 +881,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 +1002,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/bottom_half.h b/include/linux/bottom_half.h
index 86c12c93e3cf..8fdcb783197d 100644
--- a/include/linux/bottom_half.h
+++ b/include/linux/bottom_half.h
@@ -2,7 +2,6 @@
 #define _LINUX_BH_H
 
 #include <linux/preempt.h>
-#include <linux/preempt_mask.h>
 
 #ifdef CONFIG_TRACE_IRQFLAGS
 extern void __local_bh_disable_ip(unsigned long ip, unsigned int cnt);
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/cgroup.h b/include/linux/cgroup.h
index b9cb94c3102a..e7da0aa65b2d 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -774,6 +774,31 @@ static inline struct cgroup_subsys_state *task_css(struct task_struct *task,
 }
 
 /**
+ * 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;
+}
+
+/**
  * task_css_is_root - test whether a task belongs to the root css
  * @task: the target task
  * @subsys_id: the target subsystem ID
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..a240b18e86fa 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)    \
@@ -37,8 +38,11 @@ struct clk_lookup *clkdev_alloc(struct clk *clk, const char *con_id,
 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, ...);
+
 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_clkdevs(struct clk *, struct clk_lookup *, size_t);
diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h
index 96c280b2c263..597a1e836f22 100644
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -37,12 +37,15 @@ enum clock_event_mode {
  *              reached from DETACHED or SHUTDOWN.
  * ONESHOT:     Device is programmed to generate event only once. Can be reached
  *              from DETACHED or SHUTDOWN.
+ * ONESHOT_STOPPED: Device was programmed in ONESHOT mode and is temporarily
+ *                  stopped.
  */
 enum clock_event_state {
         CLOCK_EVT_STATE_DETACHED,
         CLOCK_EVT_STATE_SHUTDOWN,
         CLOCK_EVT_STATE_PERIODIC,
         CLOCK_EVT_STATE_ONESHOT,
+        CLOCK_EVT_STATE_ONESHOT_STOPPED,
 };
 
 /*
@@ -84,12 +87,13 @@ enum clock_event_state {
  * @mult:               nanosecond to cycles multiplier
  * @shift:              nanoseconds to cycles divisor (power of two)
  * @mode:               operating mode, relevant only to ->set_mode(), OBSOLETE
- * @state:              current state of the device, assigned by the core code
+ * @state_use_accessors:current state of the device, assigned by the core code
  * @features:           features
  * @retries:            number of forced programming retries
  * @set_mode:           legacy set mode function, only for modes <= CLOCK_EVT_MODE_RESUME.
  * @set_state_periodic: switch state to periodic, if !set_mode
  * @set_state_oneshot:  switch state to oneshot, if !set_mode
+ * @set_state_oneshot_stopped: switch state to oneshot_stopped, if !set_mode
  * @set_state_shutdown: switch state to shutdown, if !set_mode
  * @tick_resume:        resume clkevt device, if !set_mode
  * @broadcast:          function to broadcast events
@@ -113,7 +117,7 @@ struct clock_event_device {
         u32                     mult;
         u32                     shift;
         enum clock_event_mode   mode;
-        enum clock_event_state  state;
+        enum clock_event_state  state_use_accessors;
         unsigned int            features;
         unsigned long           retries;
 
@@ -121,11 +125,12 @@ struct clock_event_device {
          * State transition callback(s): Only one of the two groups should be
          * defined:
          * - set_mode(), only for modes <= CLOCK_EVT_MODE_RESUME.
-         * - set_state_{shutdown|periodic|oneshot}(), tick_resume().
+         * - set_state_{shutdown|periodic|oneshot|oneshot_stopped}(), tick_resume().
          */
         void                    (*set_mode)(enum clock_event_mode mode, struct clock_event_device *);
         int                     (*set_state_periodic)(struct clock_event_device *);
         int                     (*set_state_oneshot)(struct clock_event_device *);
+        int                     (*set_state_oneshot_stopped)(struct clock_event_device *);
         int                     (*set_state_shutdown)(struct clock_event_device *);
         int                     (*tick_resume)(struct clock_event_device *);
 
@@ -144,6 +149,32 @@ struct clock_event_device {
         struct module           *owner;
 } ____cacheline_aligned;
 
+/* Helpers to verify state of a clockevent device */
+static inline bool clockevent_state_detached(struct clock_event_device *dev)
+{
+        return dev->state_use_accessors == CLOCK_EVT_STATE_DETACHED;
+}
+
+static inline bool clockevent_state_shutdown(struct clock_event_device *dev)
+{
+        return dev->state_use_accessors == CLOCK_EVT_STATE_SHUTDOWN;
+}
+
+static inline bool clockevent_state_periodic(struct clock_event_device *dev)
+{
+        return dev->state_use_accessors == CLOCK_EVT_STATE_PERIODIC;
+}
+
+static inline bool clockevent_state_oneshot(struct clock_event_device *dev)
+{
+        return dev->state_use_accessors == CLOCK_EVT_STATE_ONESHOT;
+}
+
+static inline bool clockevent_state_oneshot_stopped(struct clock_event_device *dev)
+{
+        return dev->state_use_accessors == CLOCK_EVT_STATE_ONESHOT_STOPPED;
+}
+
 /*
  * Calculate a multiplication factor for scaled math, which is used to convert
  * nanoseconds based values to clock ticks:
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index d27d0152271f..278dd279a7a8 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -181,7 +181,6 @@ static inline s64 clocksource_cyc2ns(cycle_t cycles, u32 mult, u32 shift)
 
 extern int clocksource_unregister(struct clocksource*);
 extern void clocksource_touch_watchdog(void);
-extern struct clocksource* clocksource_get_next(void);
 extern void clocksource_change_rating(struct clocksource *cs, int rating);
 extern void clocksource_suspend(void);
 extern void clocksource_resume(void);
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 867722591be2..05be2352fef8 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -250,7 +250,23 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
         ({ union { typeof(x) __val; char __c[1]; } __u; __read_once_size(&(x), __u.__c, sizeof(x)); __u.__val; })
 
 #define WRITE_ONCE(x, val) \
-        ({ typeof(x) __val = (val); __write_once_size(&(x), &__val, sizeof(__val)); __val; })
+        ({ union { typeof(x) __val; char __c[1]; } __u = { .__val = (val) }; __write_once_size(&(x), __u.__c, sizeof(x)); __u.__val; })
+
+/**
+ * READ_ONCE_CTRL - Read a value heading a control dependency
+ * @x: The value to be read, heading the control dependency
+ *
+ * Control dependencies are tricky.  See Documentation/memory-barriers.txt
+ * for important information on how to use them.  Note that in many cases,
+ * use of smp_load_acquire() will be much simpler.  Control dependencies
+ * should be avoided except on the hottest of hotpaths.
+ */
+#define READ_ONCE_CTRL(x) \
+({ \
+        typeof(x) __val = READ_ONCE(x); \
+        smp_read_barrier_depends(); /* Enforce control dependency. */ \
+        __val; \
+})
 
 #endif /* __KERNEL__ */
 
@@ -450,7 +466,7 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
  * with an explicit memory barrier or atomic instruction that provides the
  * required ordering.
  *
- * If possible use READ_ONCE/ASSIGN_ONCE instead.
+ * If possible use READ_ONCE()/WRITE_ONCE() instead.
  */
 #define __ACCESS_ONCE(x) ({ \
          __maybe_unused typeof(x) __var = (__force typeof(x)) 0; \
diff --git a/include/linux/configfs.h b/include/linux/configfs.h
index 34025df61829..c9e5c57e4edf 100644
--- a/include/linux/configfs.h
+++ b/include/linux/configfs.h
@@ -71,7 +71,6 @@ 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/context_tracking.h b/include/linux/context_tracking.h
index 2821838256b4..b96bd299966f 100644
--- a/include/linux/context_tracking.h
+++ b/include/linux/context_tracking.h
@@ -14,8 +14,6 @@ extern void context_tracking_enter(enum ctx_state state);
 extern void context_tracking_exit(enum ctx_state state);
 extern void context_tracking_user_enter(void);
 extern void context_tracking_user_exit(void);
-extern void __context_tracking_task_switch(struct task_struct *prev,
-                                           struct task_struct *next);
 
 static inline void user_enter(void)
 {
@@ -51,19 +49,11 @@ static inline void exception_exit(enum ctx_state prev_ctx)
         }
 }
 
-static inline void context_tracking_task_switch(struct task_struct *prev,
-                                                struct task_struct *next)
-{
-        if (context_tracking_is_enabled())
-                __context_tracking_task_switch(prev, next);
-}
 #else
 static inline void user_enter(void) { }
 static inline void user_exit(void) { }
 static inline enum ctx_state exception_enter(void) { return 0; }
 static inline void exception_exit(enum ctx_state prev_ctx) { }
-static inline void context_tracking_task_switch(struct task_struct *prev,
-                                                struct task_struct *next) { }
 #endif /* !CONFIG_CONTEXT_TRACKING */
 
 
diff --git a/include/linux/context_tracking_state.h b/include/linux/context_tracking_state.h
index 6b7b96a32b75..678ecdf90cf6 100644
--- a/include/linux/context_tracking_state.h
+++ b/include/linux/context_tracking_state.h
@@ -12,6 +12,7 @@ struct context_tracking {
          * may be further optimized using static keys.
          */
         bool active;
+        int recursion;
         enum ctx_state {
                 CONTEXT_KERNEL = 0,
                 CONTEXT_USER,
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..29ad97c34fd5 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -65,7 +65,9 @@ struct cpufreq_policy {
 
         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 +82,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/crypto.h b/include/linux/crypto.h
index 10df5d2d093a..81ef938b0a8e 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -53,6 +53,7 @@
 #define CRYPTO_ALG_TYPE_SHASH           0x00000009
 #define CRYPTO_ALG_TYPE_AHASH           0x0000000a
 #define CRYPTO_ALG_TYPE_RNG             0x0000000c
+#define CRYPTO_ALG_TYPE_AKCIPHER        0x0000000d
 #define CRYPTO_ALG_TYPE_PCOMPRESS       0x0000000f
 
 #define CRYPTO_ALG_TYPE_HASH_MASK       0x0000000e
@@ -101,6 +102,12 @@
 #define CRYPTO_ALG_INTERNAL             0x00002000
 
 /*
+ * Temporary flag used to prevent legacy AEAD implementations from
+ * being used by user-space.
+ */
+#define CRYPTO_ALG_AEAD_NEW             0x00004000
+
+/*
  * Transform masks and values (for crt_flags).
  */
 #define CRYPTO_TFM_REQ_MASK             0x000fff00
@@ -138,9 +145,9 @@ struct crypto_async_request;
 struct crypto_aead;
 struct crypto_blkcipher;
 struct crypto_hash;
-struct crypto_rng;
 struct crypto_tfm;
 struct crypto_type;
+struct aead_request;
 struct aead_givcrypt_request;
 struct skcipher_givcrypt_request;
 
@@ -175,32 +182,6 @@ struct ablkcipher_request {
         void *__ctx[] CRYPTO_MINALIGN_ATTR;
 };
 
-/**
- *      struct aead_request - AEAD request
- *      @base: Common attributes for async crypto requests
- *      @assoclen: Length in bytes of associated data for authentication
- *      @cryptlen: Length of data to be encrypted or decrypted
- *      @iv: Initialisation vector
- *      @assoc: Associated data
- *      @src: Source data
- *      @dst: Destination data
- *      @__ctx: Start of private context data
- */
-struct aead_request {
-        struct crypto_async_request base;
-
-        unsigned int assoclen;
-        unsigned int cryptlen;
-
-        u8 *iv;
-
-        struct scatterlist *assoc;
-        struct scatterlist *src;
-        struct scatterlist *dst;
-
-        void *__ctx[] CRYPTO_MINALIGN_ATTR;
-};
-
 struct blkcipher_desc {
         struct crypto_blkcipher *tfm;
         void *info;
@@ -294,7 +275,7 @@ struct ablkcipher_alg {
 };
 
 /**
- * struct aead_alg - AEAD cipher definition
+ * struct old_aead_alg - AEAD cipher definition
  * @maxauthsize: Set the maximum authentication tag size supported by the
  *               transformation. A transformation may support smaller tag sizes.
  *               As the authentication tag is a message digest to ensure the
@@ -319,7 +300,7 @@ struct ablkcipher_alg {
  * All fields except @givencrypt , @givdecrypt , @geniv and @ivsize are
  * mandatory and must be filled.
  */
-struct aead_alg {
+struct old_aead_alg {
         int (*setkey)(struct crypto_aead *tfm, const u8 *key,
                       unsigned int keylen);
         int (*setauthsize)(struct crypto_aead *tfm, unsigned int authsize);
@@ -426,40 +407,12 @@ struct compress_alg {
                               unsigned int slen, u8 *dst, unsigned int *dlen);
 };
 
-/**
- * struct rng_alg - random number generator definition
- * @rng_make_random: The function defined by this variable obtains a random
- *                   number. The random number generator transform must generate
- *                   the random number out of the context provided with this
- *                   call.
- * @rng_reset: Reset of the random number generator by clearing the entire state.
- *             With the invocation of this function call, the random number
- *             generator shall completely reinitialize its state. If the random
- *             number generator requires a seed for setting up a new state,
- *             the seed must be provided by the consumer while invoking this
- *             function. The required size of the seed is defined with
- *             @seedsize .
- * @seedsize: The seed size required for a random number generator
- *            initialization defined with this variable. Some random number
- *            generators like the SP800-90A DRBG does not require a seed as the
- *            seeding is implemented internally without the need of support by
- *            the consumer. In this case, the seed size is set to zero.
- */
-struct rng_alg {
-        int (*rng_make_random)(struct crypto_rng *tfm, u8 *rdata,
-                               unsigned int dlen);
-        int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen);
-
-        unsigned int seedsize;
-};
-
 
 #define cra_ablkcipher  cra_u.ablkcipher
 #define cra_aead        cra_u.aead
 #define cra_blkcipher   cra_u.blkcipher
 #define cra_cipher      cra_u.cipher
 #define cra_compress    cra_u.compress
-#define cra_rng         cra_u.rng
 
 /**
  * struct crypto_alg - definition of a cryptograpic cipher algorithm
@@ -505,7 +458,7 @@ struct rng_alg {
  *                   transformation algorithm.
  * @cra_type: Type of the cryptographic transformation. This is a pointer to
  *            struct crypto_type, which implements callbacks common for all
- *            trasnformation types. There are multiple options:
+ *            transformation types. There are multiple options:
  *            &crypto_blkcipher_type, &crypto_ablkcipher_type,
  *            &crypto_ahash_type, &crypto_aead_type, &crypto_rng_type.
  *            This field might be empty. In that case, there are no common
@@ -555,11 +508,10 @@ struct crypto_alg {
 
         union {
                 struct ablkcipher_alg ablkcipher;
-                struct aead_alg aead;
+                struct old_aead_alg aead;
                 struct blkcipher_alg blkcipher;
                 struct cipher_alg cipher;
                 struct compress_alg compress;
-                struct rng_alg rng;
         } cra_u;
 
         int (*cra_init)(struct crypto_tfm *tfm);
@@ -567,7 +519,7 @@ struct crypto_alg {
         void (*cra_destroy)(struct crypto_alg *alg);
         
         struct module *cra_module;
-};
+} CRYPTO_MINALIGN_ATTR;
 
 /*
  * Algorithm registration interface.
@@ -602,21 +554,6 @@ struct ablkcipher_tfm {
         unsigned int reqsize;
 };
 
-struct aead_tfm {
-        int (*setkey)(struct crypto_aead *tfm, const u8 *key,
-                      unsigned int keylen);
-        int (*encrypt)(struct aead_request *req);
-        int (*decrypt)(struct aead_request *req);
-        int (*givencrypt)(struct aead_givcrypt_request *req);
-        int (*givdecrypt)(struct aead_givcrypt_request *req);
-
-        struct crypto_aead *base;
-
-        unsigned int ivsize;
-        unsigned int authsize;
-        unsigned int reqsize;
-};
-
 struct blkcipher_tfm {
         void *iv;
         int (*setkey)(struct crypto_tfm *tfm, const u8 *key,
@@ -655,19 +592,11 @@ struct compress_tfm {
                               u8 *dst, unsigned int *dlen);
 };
 
-struct rng_tfm {
-        int (*rng_gen_random)(struct crypto_rng *tfm, u8 *rdata,
-                              unsigned int dlen);
-        int (*rng_reset)(struct crypto_rng *tfm, u8 *seed, unsigned int slen);
-};
-
 #define crt_ablkcipher  crt_u.ablkcipher
-#define crt_aead        crt_u.aead
 #define crt_blkcipher   crt_u.blkcipher
 #define crt_cipher      crt_u.cipher
 #define crt_hash        crt_u.hash
 #define crt_compress    crt_u.compress
-#define crt_rng         crt_u.rng
 
 struct crypto_tfm {
 
@@ -675,12 +604,10 @@ struct crypto_tfm {
         
         union {
                 struct ablkcipher_tfm ablkcipher;
-                struct aead_tfm aead;
                 struct blkcipher_tfm blkcipher;
                 struct cipher_tfm cipher;
                 struct hash_tfm hash;
                 struct compress_tfm compress;
-                struct rng_tfm rng;
         } crt_u;
 
         void (*exit)(struct crypto_tfm *tfm);
@@ -694,10 +621,6 @@ struct crypto_ablkcipher {
         struct crypto_tfm base;
 };
 
-struct crypto_aead {
-        struct crypto_tfm base;
-};
-
 struct crypto_blkcipher {
         struct crypto_tfm base;
 };
@@ -714,10 +637,6 @@ struct crypto_hash {
         struct crypto_tfm base;
 };
 
-struct crypto_rng {
-        struct crypto_tfm base;
-};
-
 enum {
         CRYPTOA_UNSPEC,
         CRYPTOA_ALG,
@@ -1194,400 +1113,6 @@ static inline void ablkcipher_request_set_crypt(
 }
 
 /**
- * DOC: Authenticated Encryption With Associated Data (AEAD) Cipher API
- *
- * The AEAD cipher API is used with the ciphers of type CRYPTO_ALG_TYPE_AEAD
- * (listed as type "aead" in /proc/crypto)
- *
- * The most prominent examples for this type of encryption is GCM and CCM.
- * However, the kernel supports other types of AEAD ciphers which are defined
- * with the following cipher string:
- *
- *      authenc(keyed message digest, block cipher)
- *
- * For example: authenc(hmac(sha256), cbc(aes))
- *
- * The example code provided for the asynchronous block cipher operation
- * applies here as well. Naturally all *ablkcipher* symbols must be exchanged
- * the *aead* pendants discussed in the following. In addtion, for the AEAD
- * operation, the aead_request_set_assoc function must be used to set the
- * pointer to the associated data memory location before performing the
- * encryption or decryption operation. In case of an encryption, the associated
- * data memory is filled during the encryption operation. For decryption, the
- * associated data memory must contain data that is used to verify the integrity
- * of the decrypted data. Another deviation from the asynchronous block cipher
- * operation is that the caller should explicitly check for -EBADMSG of the
- * crypto_aead_decrypt. That error indicates an authentication error, i.e.
- * a breach in the integrity of the message. In essence, that -EBADMSG error
- * code is the key bonus an AEAD cipher has over "standard" block chaining
- * modes.
- */
-
-static inline struct crypto_aead *__crypto_aead_cast(struct crypto_tfm *tfm)
-{
-        return (struct crypto_aead *)tfm;
-}
-
-/**
- * crypto_alloc_aead() - allocate AEAD cipher handle
- * @alg_name: is the cra_name / name or cra_driver_name / driver name of the
- *           AEAD cipher
- * @type: specifies the type of the cipher
- * @mask: specifies the mask for the cipher
- *
- * Allocate a cipher handle for an AEAD. The returned struct
- * crypto_aead is the cipher handle that is required for any subsequent
- * API invocation for that AEAD.
- *
- * Return: allocated cipher handle in case of success; IS_ERR() is true in case
- *         of an error, PTR_ERR() returns the error code.
- */
-struct crypto_aead *crypto_alloc_aead(const char *alg_name, u32 type, u32 mask);
-
-static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm)
-{
-        return &tfm->base;
-}
-
-/**
- * crypto_free_aead() - zeroize and free aead handle
- * @tfm: cipher handle to be freed
- */
-static inline void crypto_free_aead(struct crypto_aead *tfm)
-{
-        crypto_free_tfm(crypto_aead_tfm(tfm));
-}
-
-static inline struct aead_tfm *crypto_aead_crt(struct crypto_aead *tfm)
-{
-        return &crypto_aead_tfm(tfm)->crt_aead;
-}
-
-/**
- * crypto_aead_ivsize() - obtain IV size
- * @tfm: cipher handle
- *
- * The size of the IV for the aead referenced by the cipher handle is
- * returned. This IV size may be zero if the cipher does not need an IV.
- *
- * Return: IV size in bytes
- */
-static inline unsigned int crypto_aead_ivsize(struct crypto_aead *tfm)
-{
-        return crypto_aead_crt(tfm)->ivsize;
-}
-
-/**
- * crypto_aead_authsize() - obtain maximum authentication data size
- * @tfm: cipher handle
- *
- * The maximum size of the authentication data for the AEAD cipher referenced
- * by the AEAD cipher handle is returned. The authentication data size may be
- * zero if the cipher implements a hard-coded maximum.
- *
- * The authentication data may also be known as "tag value".
- *
- * Return: authentication data size / tag size in bytes
- */
-static inline unsigned int crypto_aead_authsize(struct crypto_aead *tfm)
-{
-        return crypto_aead_crt(tfm)->authsize;
-}
-
-/**
- * crypto_aead_blocksize() - obtain block size of cipher
- * @tfm: cipher handle
- *
- * The block size for the AEAD referenced with the cipher handle is returned.
- * The caller may use that information to allocate appropriate memory for the
- * data returned by the encryption or decryption operation
- *
- * Return: block size of cipher
- */
-static inline unsigned int crypto_aead_blocksize(struct crypto_aead *tfm)
-{
-        return crypto_tfm_alg_blocksize(crypto_aead_tfm(tfm));
-}
-
-static inline unsigned int crypto_aead_alignmask(struct crypto_aead *tfm)
-{
-        return crypto_tfm_alg_alignmask(crypto_aead_tfm(tfm));
-}
-
-static inline u32 crypto_aead_get_flags(struct crypto_aead *tfm)
-{
-        return crypto_tfm_get_flags(crypto_aead_tfm(tfm));
-}
-
-static inline void crypto_aead_set_flags(struct crypto_aead *tfm, u32 flags)
-{
-        crypto_tfm_set_flags(crypto_aead_tfm(tfm), flags);
-}
-
-static inline void crypto_aead_clear_flags(struct crypto_aead *tfm, u32 flags)
-{
-        crypto_tfm_clear_flags(crypto_aead_tfm(tfm), flags);
-}
-
-/**
- * crypto_aead_setkey() - set key for cipher
- * @tfm: cipher handle
- * @key: buffer holding the key
- * @keylen: length of the key in bytes
- *
- * The caller provided key is set for the AEAD referenced by the cipher
- * handle.
- *
- * Note, the key length determines the cipher type. Many block ciphers implement
- * different cipher modes depending on the key size, such as AES-128 vs AES-192
- * vs. AES-256. When providing a 16 byte key for an AES cipher handle, AES-128
- * is performed.
- *
- * Return: 0 if the setting of the key was successful; < 0 if an error occurred
- */
-static inline int crypto_aead_setkey(struct crypto_aead *tfm, const u8 *key,
-                                     unsigned int keylen)
-{
-        struct aead_tfm *crt = crypto_aead_crt(tfm);
-
-        return crt->setkey(crt->base, key, keylen);
-}
-
-/**
- * crypto_aead_setauthsize() - set authentication data size
- * @tfm: cipher handle
- * @authsize: size of the authentication data / tag in bytes
- *
- * Set the authentication data size / tag size. AEAD requires an authentication
- * tag (or MAC) in addition to the associated data.
- *
- * Return: 0 if the setting of the key was successful; < 0 if an error occurred
- */
-int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize);
-
-static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
-{
-        return __crypto_aead_cast(req->base.tfm);
-}
-
-/**
- * crypto_aead_encrypt() - encrypt plaintext
- * @req: reference to the aead_request handle that holds all information
- *       needed to perform the cipher operation
- *
- * Encrypt plaintext data using the aead_request handle. That data structure
- * and how it is filled with data is discussed with the aead_request_*
- * functions.
- *
- * IMPORTANT NOTE The encryption operation creates the authentication data /
- *                tag. That data is concatenated with the created ciphertext.
- *                The ciphertext memory size is therefore the given number of
- *                block cipher blocks + the size defined by the
- *                crypto_aead_setauthsize invocation. The caller must ensure
- *                that sufficient memory is available for the ciphertext and
- *                the authentication tag.
- *
- * Return: 0 if the cipher operation was successful; < 0 if an error occurred
- */
-static inline int crypto_aead_encrypt(struct aead_request *req)
-{
-        return crypto_aead_crt(crypto_aead_reqtfm(req))->encrypt(req);
-}
-
-/**
- * crypto_aead_decrypt() - decrypt ciphertext
- * @req: reference to the ablkcipher_request handle that holds all information
- *       needed to perform the cipher operation
- *
- * Decrypt ciphertext data using the aead_request handle. That data structure
- * and how it is filled with data is discussed with the aead_request_*
- * functions.
- *
- * IMPORTANT NOTE The caller must concatenate the ciphertext followed by the
- *                authentication data / tag. That authentication data / tag
- *                must have the size defined by the crypto_aead_setauthsize
- *                invocation.
- *
- *
- * Return: 0 if the cipher operation was successful; -EBADMSG: The AEAD
- *         cipher operation performs the authentication of the data during the
- *         decryption operation. Therefore, the function returns this error if
- *         the authentication of the ciphertext was unsuccessful (i.e. the
- *         integrity of the ciphertext or the associated data was violated);
- *         < 0 if an error occurred.
- */
-static inline int crypto_aead_decrypt(struct aead_request *req)
-{
-        if (req->cryptlen < crypto_aead_authsize(crypto_aead_reqtfm(req)))
-                return -EINVAL;
-
-        return crypto_aead_crt(crypto_aead_reqtfm(req))->decrypt(req);
-}
-
-/**
- * DOC: Asynchronous AEAD Request Handle
- *
- * The aead_request data structure contains all pointers to data required for
- * the AEAD cipher operation. This includes the cipher handle (which can be
- * used by multiple aead_request instances), pointer to plaintext and
- * ciphertext, asynchronous callback function, etc. It acts as a handle to the
- * aead_request_* API calls in a similar way as AEAD handle to the
- * crypto_aead_* API calls.
- */
-
-/**
- * crypto_aead_reqsize() - obtain size of the request data structure
- * @tfm: cipher handle
- *
- * Return: number of bytes
- */
-static inline unsigned int crypto_aead_reqsize(struct crypto_aead *tfm)
-{
-        return crypto_aead_crt(tfm)->reqsize;
-}
-
-/**
- * aead_request_set_tfm() - update cipher handle reference in request
- * @req: request handle to be modified
- * @tfm: cipher handle that shall be added to the request handle
- *
- * Allow the caller to replace the existing aead handle in the request
- * data structure with a different one.
- */
-static inline void aead_request_set_tfm(struct aead_request *req,
-                                        struct crypto_aead *tfm)
-{
-        req->base.tfm = crypto_aead_tfm(crypto_aead_crt(tfm)->base);
-}
-
-/**
- * aead_request_alloc() - allocate request data structure
- * @tfm: cipher handle to be registered with the request
- * @gfp: memory allocation flag that is handed to kmalloc by the API call.
- *
- * Allocate the request data structure that must be used with the AEAD
- * encrypt and decrypt API calls. During the allocation, the provided aead
- * handle is registered in the request data structure.
- *
- * Return: allocated request handle in case of success; IS_ERR() is true in case
- *         of an error, PTR_ERR() returns the error code.
- */
-static inline struct aead_request *aead_request_alloc(struct crypto_aead *tfm,
-                                                      gfp_t gfp)
-{
-        struct aead_request *req;
-
-        req = kmalloc(sizeof(*req) + crypto_aead_reqsize(tfm), gfp);
-
-        if (likely(req))
-                aead_request_set_tfm(req, tfm);
-
-        return req;
-}
-
-/**
- * aead_request_free() - zeroize and free request data structure
- * @req: request data structure cipher handle to be freed
- */
-static inline void aead_request_free(struct aead_request *req)
-{
-        kzfree(req);
-}
-
-/**
- * aead_request_set_callback() - set asynchronous callback function
- * @req: request handle
- * @flags: specify zero or an ORing of the flags
- *         CRYPTO_TFM_REQ_MAY_BACKLOG the request queue may back log and
- *         increase the wait queue beyond the initial maximum size;
- *         CRYPTO_TFM_REQ_MAY_SLEEP the request processing may sleep
- * @compl: callback function pointer to be registered with the request handle
- * @data: The data pointer refers to memory that is not used by the kernel
- *        crypto API, but provided to the callback function for it to use. Here,
- *        the caller can provide a reference to memory the callback function can
- *        operate on. As the callback function is invoked asynchronously to the
- *        related functionality, it may need to access data structures of the
- *        related functionality which can be referenced using this pointer. The
- *        callback function can access the memory via the "data" field in the
- *        crypto_async_request data structure provided to the callback function.
- *
- * Setting the callback function that is triggered once the cipher operation
- * completes
- *
- * The callback function is registered with the aead_request handle and
- * must comply with the following template
- *
- *      void callback_function(struct crypto_async_request *req, int error)
- */
-static inline void aead_request_set_callback(struct aead_request *req,
-                                             u32 flags,
-                                             crypto_completion_t compl,
-                                             void *data)
-{
-        req->base.complete = compl;
-        req->base.data = data;
-        req->base.flags = flags;
-}
-
-/**
- * aead_request_set_crypt - set data buffers
- * @req: request handle
- * @src: source scatter / gather list
- * @dst: destination scatter / gather list
- * @cryptlen: number of bytes to process from @src
- * @iv: IV for the cipher operation which must comply with the IV size defined
- *      by crypto_aead_ivsize()
- *
- * Setting the source data and destination data scatter / gather lists.
- *
- * For encryption, the source is treated as the plaintext and the
- * destination is the ciphertext. For a decryption operation, the use is
- * reversed - the source is the ciphertext and the destination is the plaintext.
- *
- * IMPORTANT NOTE AEAD requires an authentication tag (MAC). For decryption,
- *                the caller must concatenate the ciphertext followed by the
- *                authentication tag and provide the entire data stream to the
- *                decryption operation (i.e. the data length used for the
- *                initialization of the scatterlist and the data length for the
- *                decryption operation is identical). For encryption, however,
- *                the authentication tag is created while encrypting the data.
- *                The destination buffer must hold sufficient space for the
- *                ciphertext and the authentication tag while the encryption
- *                invocation must only point to the plaintext data size. The
- *                following code snippet illustrates the memory usage
- *                buffer = kmalloc(ptbuflen + (enc ? authsize : 0));
- *                sg_init_one(&sg, buffer, ptbuflen + (enc ? authsize : 0));
- *                aead_request_set_crypt(req, &sg, &sg, ptbuflen, iv);
- */
-static inline void aead_request_set_crypt(struct aead_request *req,
-                                          struct scatterlist *src,
-                                          struct scatterlist *dst,
-                                          unsigned int cryptlen, u8 *iv)
-{
-        req->src = src;
-        req->dst = dst;
-        req->cryptlen = cryptlen;
-        req->iv = iv;
-}
-
-/**
- * aead_request_set_assoc() - set the associated data scatter / gather list
- * @req: request handle
- * @assoc: associated data scatter / gather list
- * @assoclen: number of bytes to process from @assoc
- *
- * For encryption, the memory is filled with the associated data. For
- * decryption, the memory must point to the associated data.
- */
-static inline void aead_request_set_assoc(struct aead_request *req,
-                                          struct scatterlist *assoc,
-                                          unsigned int assoclen)
-{
-        req->assoc = assoc;
-        req->assoclen = assoclen;
-}
-
-/**
  * DOC: Synchronous Block Cipher API
  *
  * The synchronous block cipher API is used with the ciphers of type
diff --git a/include/linux/cryptouser.h b/include/linux/cryptouser.h
deleted file mode 100644
index 4abf2ea6a887..000000000000
--- a/include/linux/cryptouser.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Crypto user configuration API.
- *
- * Copyright (C) 2011 secunet Security Networks AG
- * Copyright (C) 2011 Steffen Klassert <steffen.klassert@secunet.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-/* Netlink configuration messages.  */
-enum {
-        CRYPTO_MSG_BASE = 0x10,
-        CRYPTO_MSG_NEWALG = 0x10,
-        CRYPTO_MSG_DELALG,
-        CRYPTO_MSG_UPDATEALG,
-        CRYPTO_MSG_GETALG,
-        __CRYPTO_MSG_MAX
-};
-#define CRYPTO_MSG_MAX (__CRYPTO_MSG_MAX - 1)
-#define CRYPTO_NR_MSGTYPES (CRYPTO_MSG_MAX + 1 - CRYPTO_MSG_BASE)
-
-#define CRYPTO_MAX_NAME CRYPTO_MAX_ALG_NAME
-
-/* Netlink message attributes.  */
-enum crypto_attr_type_t {
-        CRYPTOCFGA_UNSPEC,
-        CRYPTOCFGA_PRIORITY_VAL,        /* __u32 */
-        CRYPTOCFGA_REPORT_LARVAL,       /* struct crypto_report_larval */
-        CRYPTOCFGA_REPORT_HASH,         /* struct crypto_report_hash */
-        CRYPTOCFGA_REPORT_BLKCIPHER,    /* struct crypto_report_blkcipher */
-        CRYPTOCFGA_REPORT_AEAD,         /* struct crypto_report_aead */
-        CRYPTOCFGA_REPORT_COMPRESS,     /* struct crypto_report_comp */
-        CRYPTOCFGA_REPORT_RNG,          /* struct crypto_report_rng */
-        CRYPTOCFGA_REPORT_CIPHER,       /* struct crypto_report_cipher */
-        __CRYPTOCFGA_MAX
-
-#define CRYPTOCFGA_MAX (__CRYPTOCFGA_MAX - 1)
-};
-
-struct crypto_user_alg {
-        char cru_name[CRYPTO_MAX_ALG_NAME];
-        char cru_driver_name[CRYPTO_MAX_ALG_NAME];
-        char cru_module_name[CRYPTO_MAX_ALG_NAME];
-        __u32 cru_type;
-        __u32 cru_mask;
-        __u32 cru_refcnt;
-        __u32 cru_flags;
-};
-
-struct crypto_report_larval {
-        char type[CRYPTO_MAX_NAME];
-};
-
-struct crypto_report_hash {
-        char type[CRYPTO_MAX_NAME];
-        unsigned int blocksize;
-        unsigned int digestsize;
-};
-
-struct crypto_report_cipher {
-        char type[CRYPTO_MAX_ALG_NAME];
-        unsigned int blocksize;
-        unsigned int min_keysize;
-        unsigned int max_keysize;
-};
-
-struct crypto_report_blkcipher {
-        char type[CRYPTO_MAX_NAME];
-        char geniv[CRYPTO_MAX_NAME];
-        unsigned int blocksize;
-        unsigned int min_keysize;
-        unsigned int max_keysize;
-        unsigned int ivsize;
-};
-
-struct crypto_report_aead {
-        char type[CRYPTO_MAX_NAME];
-        char geniv[CRYPTO_MAX_NAME];
-        unsigned int blocksize;
-        unsigned int maxauthsize;
-        unsigned int ivsize;
-};
-
-struct crypto_report_comp {
-        char type[CRYPTO_MAX_NAME];
-};
-
-struct crypto_report_rng {
-        char type[CRYPTO_MAX_NAME];
-        unsigned int seedsize;
-};
-
-#define CRYPTO_REPORT_MAXSIZE (sizeof(struct crypto_user_alg) + \
-                               sizeof(struct crypto_report_blkcipher))
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index cb25af461054..420311bcee38 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -45,7 +45,6 @@ extern struct dentry *arch_debugfs_dir;
 
 /* declared over in file.c */
 extern const struct file_operations debugfs_file_operations;
-extern const struct inode_operations debugfs_link_operations;
 
 struct dentry *debugfs_create_file(const char *name, umode_t mode,
                                    struct dentry *parent, void *data,
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/dmar.h b/include/linux/dmar.h
index 30624954dec5..e9bc9292bd3a 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -185,33 +185,85 @@ static inline int dmar_device_remove(void *handle)
 
 struct irte {
         union {
+                /* Shared between remapped and posted mode*/
                 struct {
-                        __u64   present         : 1,
-                                fpd             : 1,
-                                dst_mode        : 1,
-                                redir_hint      : 1,
-                                trigger_mode    : 1,
-                                dlvry_mode      : 3,
-                                avail           : 4,
-                                __reserved_1    : 4,
-                                vector          : 8,
-                                __reserved_2    : 8,
-                                dest_id         : 32;
+                        __u64   present         : 1,  /*  0      */
+                                fpd             : 1,  /*  1      */
+                                __res0          : 6,  /*  2 -  6 */
+                                avail           : 4,  /*  8 - 11 */
+                                __res1          : 3,  /* 12 - 14 */
+                                pst             : 1,  /* 15      */
+                                vector          : 8,  /* 16 - 23 */
+                                __res2          : 40; /* 24 - 63 */
+                };
+
+                /* Remapped mode */
+                struct {
+                        __u64   r_present       : 1,  /*  0      */
+                                r_fpd           : 1,  /*  1      */
+                                dst_mode        : 1,  /*  2      */
+                                redir_hint      : 1,  /*  3      */
+                                trigger_mode    : 1,  /*  4      */
+                                dlvry_mode      : 3,  /*  5 -  7 */
+                                r_avail         : 4,  /*  8 - 11 */
+                                r_res0          : 4,  /* 12 - 15 */
+                                r_vector        : 8,  /* 16 - 23 */
+                                r_res1          : 8,  /* 24 - 31 */
+                                dest_id         : 32; /* 32 - 63 */
+                };
+
+                /* Posted mode */
+                struct {
+                        __u64   p_present       : 1,  /*  0      */
+                                p_fpd           : 1,  /*  1      */
+                                p_res0          : 6,  /*  2 -  7 */
+                                p_avail         : 4,  /*  8 - 11 */
+                                p_res1          : 2,  /* 12 - 13 */
+                                p_urgent        : 1,  /* 14      */
+                                p_pst           : 1,  /* 15      */
+                                p_vector        : 8,  /* 16 - 23 */
+                                p_res2          : 14, /* 24 - 37 */
+                                pda_l           : 26; /* 38 - 63 */
                 };
                 __u64 low;
         };
 
         union {
+                /* Shared between remapped and posted mode*/
                 struct {
-                        __u64   sid             : 16,
-                                sq              : 2,
-                                svt             : 2,
-                                __reserved_3    : 44;
+                        __u64   sid             : 16,  /* 64 - 79  */
+                                sq              : 2,   /* 80 - 81  */
+                                svt             : 2,   /* 82 - 83  */
+                                __res3          : 44;  /* 84 - 127 */
+                };
+
+                /* Posted mode*/
+                struct {
+                        __u64   p_sid           : 16,  /* 64 - 79  */
+                                p_sq            : 2,   /* 80 - 81  */
+                                p_svt           : 2,   /* 82 - 83  */
+                                p_res3          : 12,  /* 84 - 95  */
+                                pda_h           : 32;  /* 96 - 127 */
                 };
                 __u64 high;
         };
 };
 
+static inline void dmar_copy_shared_irte(struct irte *dst, struct irte *src)
+{
+        dst->present    = src->present;
+        dst->fpd        = src->fpd;
+        dst->avail      = src->avail;
+        dst->pst        = src->pst;
+        dst->vector     = src->vector;
+        dst->sid        = src->sid;
+        dst->sq         = src->sq;
+        dst->svt        = src->svt;
+}
+
+#define PDA_LOW_BIT    26
+#define PDA_HIGH_BIT   32
+
 enum {
         IRQ_REMAP_XAPIC_MODE,
         IRQ_REMAP_X2APIC_MODE,
@@ -227,6 +279,7 @@ extern void dmar_msi_read(int irq, struct msi_msg *msg);
 extern void dmar_msi_write(int irq, struct msi_msg *msg);
 extern int dmar_set_interrupt(struct intel_iommu *iommu);
 extern irqreturn_t dmar_fault(int irq, void *dev_id);
-extern int arch_setup_dmar_msi(unsigned int irq);
+extern int dmar_alloc_hwirq(int id, int node, void *arg);
+extern void dmar_free_hwirq(int irq);
 
 #endif /* __DMAR_H__ */
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 af5be0368dec..5f19efe4eb3f 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -96,6 +96,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
 
@@ -583,6 +585,9 @@ void efi_native_runtime_setup(void);
 #define EFI_FILE_INFO_ID \
     EFI_GUID(  0x9576e92, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b )
 
+#define EFI_SYSTEM_RESOURCE_TABLE_GUID \
+    EFI_GUID(  0xb122a263, 0x3661, 0x4f68, 0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80 )
+
 #define EFI_FILE_SYSTEM_GUID \
     EFI_GUID(  0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b )
 
@@ -823,6 +828,7 @@ extern struct efi {
         unsigned long fw_vendor;        /* fw_vendor */
         unsigned long runtime;          /* runtime table */
         unsigned long config_table;     /* config tables */
+        unsigned long esrt;             /* ESRT table */
         efi_get_time_t *get_time;
         efi_set_time_t *set_time;
         efi_get_wakeup_time_t *get_wakeup_time;
@@ -864,6 +870,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) {}
@@ -875,6 +882,11 @@ static inline efi_status_t efi_query_variable_store(u32 attributes, unsigned lon
 #endif
 extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
 extern int efi_config_init(efi_config_table_type_t *arch_tables);
+#ifdef CONFIG_EFI_ESRT
+extern void __init efi_esrt_init(void);
+#else
+static inline void efi_esrt_init(void) { }
+#endif
 extern int efi_config_parse_tables(void *config_tables, int count, int sz,
                                    efi_config_table_type_t *arch_tables);
 extern u64 efi_get_iobase (void);
@@ -882,12 +894,15 @@ extern u32 efi_mem_type (unsigned long phys_addr);
 extern u64 efi_mem_attributes (unsigned long phys_addr);
 extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);
 extern int __init efi_uart_console_only (void);
+extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
+extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
 extern void efi_initialize_iomem_resources(struct resource *code_resource,
                 struct resource *data_resource, struct resource *bss_resource);
 extern void efi_get_time(struct timespec *now);
 extern void efi_reserve_boot_services(void);
 extern int efi_get_fdt_params(struct efi_fdt_params *params, int verbose);
 extern struct efi_memory_map memmap;
+extern struct kobject *efi_kobj;
 
 extern int efi_reboot_quirk_mode;
 extern bool efi_poweroff_required(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/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/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 35ec87e490b1..e351da4a934f 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -35,10 +35,10 @@
 #include <uapi/linux/fs.h>
 
 struct backing_dev_info;
+struct bdi_writeback;
 struct export_operations;
 struct hd_geometry;
 struct iovec;
-struct nameidata;
 struct kiocb;
 struct kobject;
 struct pipe_inode_info;
@@ -635,6 +635,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 {
@@ -656,6 +664,7 @@ struct inode {
                 struct pipe_inode_info  *i_pipe;
                 struct block_device     *i_bdev;
                 struct cdev             *i_cdev;
+                char                    *i_link;
         };
 
         __u32                   i_generation;
@@ -1232,6 +1241,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 +1281,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;
@@ -1607,12 +1619,12 @@ struct file_operations {
 
 struct inode_operations {
         struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
-        void * (*follow_link) (struct dentry *, struct nameidata *);
+        const char * (*follow_link) (struct dentry *, void **);
         int (*permission) (struct inode *, int);
         struct posix_acl * (*get_acl)(struct inode *, int);
 
         int (*readlink) (struct dentry *, char __user *,int);
-        void (*put_link) (struct dentry *, struct nameidata *, void *);
+        void (*put_link) (struct inode *, void *);
 
         int (*create) (struct inode *,struct dentry *, umode_t, bool);
         int (*link) (struct dentry *,struct inode *,struct dentry *);
@@ -1806,6 +1818,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 +1842,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)
@@ -1879,6 +1897,7 @@ enum file_time_flags {
         S_VERSION = 8,
 };
 
+extern bool atime_needs_update(const struct path *, struct inode *);
 extern void touch_atime(const struct path *);
 static inline void file_accessed(struct file *file)
 {
@@ -2240,7 +2259,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; }
@@ -2279,6 +2304,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,
@@ -2704,13 +2732,14 @@ extern const struct file_operations generic_ro_fops;
 
 extern int readlink_copy(char __user *, int, const char *);
 extern int page_readlink(struct dentry *, char __user *, int);
-extern void *page_follow_link_light(struct dentry *, struct nameidata *);
-extern void page_put_link(struct dentry *, struct nameidata *, void *);
+extern const char *page_follow_link_light(struct dentry *, void **);
+extern void page_put_link(struct inode *, void *);
 extern int __page_symlink(struct inode *inode, const char *symname, int len,
                 int nofs);
 extern int page_symlink(struct inode *inode, const char *symname, int len);
 extern const struct inode_operations page_symlink_inode_operations;
-extern void kfree_put_link(struct dentry *, struct nameidata *, void *);
+extern void kfree_put_link(struct inode *, void *);
+extern void free_page_put_link(struct inode *, void *);
 extern int generic_readlink(struct dentry *, char __user *, int);
 extern void generic_fillattr(struct inode *, struct kstat *);
 int vfs_getattr_nosec(struct path *path, struct kstat *stat);
@@ -2721,6 +2750,8 @@ void __inode_sub_bytes(struct inode *inode, loff_t bytes);
 void inode_sub_bytes(struct inode *inode, loff_t bytes);
 loff_t inode_get_bytes(struct inode *inode);
 void inode_set_bytes(struct inode *inode, loff_t bytes);
+const char *simple_follow_link(struct dentry *, void **);
+extern const struct inode_operations simple_symlink_inode_operations;
 
 extern int iterate_dir(struct file *, struct dir_context *);
 
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/gfp.h b/include/linux/gfp.h
index 15928f0647e4..6ba7cf23748f 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);
 
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index ab81339a8590..d12b5d566e4b 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -196,13 +196,6 @@ static inline int gpio_export_link(struct device *dev, const char *name,
         return -EINVAL;
 }
 
-static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
-{
-        /* GPIO can never have been requested */
-        WARN_ON(1);
-        return -EINVAL;
-}
-
 static inline void gpio_unexport(unsigned gpio)
 {
         /* GPIO can never have been exported */
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index 3a7c9ffd5ab9..fd098169fe87 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -100,24 +100,25 @@ int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
 /* Value get/set from non-sleeping context */
 int gpiod_get_value(const struct gpio_desc *desc);
 void gpiod_set_value(struct gpio_desc *desc, int value);
-void gpiod_set_array(unsigned int array_size,
-                     struct gpio_desc **desc_array, int *value_array);
+void gpiod_set_array_value(unsigned int array_size,
+                           struct gpio_desc **desc_array, int *value_array);
 int gpiod_get_raw_value(const struct gpio_desc *desc);
 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
-void gpiod_set_raw_array(unsigned int array_size,
-                         struct gpio_desc **desc_array, int *value_array);
+void gpiod_set_raw_array_value(unsigned int array_size,
+                               struct gpio_desc **desc_array,
+                               int *value_array);
 
 /* Value get/set from sleeping context */
 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
-void gpiod_set_array_cansleep(unsigned int array_size,
-                              struct gpio_desc **desc_array,
-                              int *value_array);
+void gpiod_set_array_value_cansleep(unsigned int array_size,
+                                    struct gpio_desc **desc_array,
+                                    int *value_array);
 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
-void gpiod_set_raw_array_cansleep(unsigned int array_size,
-                                  struct gpio_desc **desc_array,
-                                  int *value_array);
+void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
+                                        struct gpio_desc **desc_array,
+                                        int *value_array);
 
 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 
@@ -304,9 +305,9 @@ static inline void gpiod_set_value(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_array(unsigned int array_size,
-                                   struct gpio_desc **desc_array,
-                                   int *value_array)
+static inline void gpiod_set_array_value(unsigned int array_size,
+                                         struct gpio_desc **desc_array,
+                                         int *value_array)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
@@ -322,9 +323,9 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_raw_array(unsigned int array_size,
-                                       struct gpio_desc **desc_array,
-                                       int *value_array)
+static inline void gpiod_set_raw_array_value(unsigned int array_size,
+                                             struct gpio_desc **desc_array,
+                                             int *value_array)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
@@ -341,7 +342,7 @@ static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_array_cansleep(unsigned int array_size,
+static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
                                             struct gpio_desc **desc_array,
                                             int *value_array)
 {
@@ -360,7 +361,7 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_raw_array_cansleep(unsigned int array_size,
+static inline void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
                                                 struct gpio_desc **desc_array,
                                                 int *value_array)
 {
@@ -449,7 +450,6 @@ static inline int desc_to_gpio(const struct gpio_desc *desc)
 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 int gpiod_export_link(struct device *dev, const char *name,
                       struct gpio_desc *desc);
-int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
 void gpiod_unexport(struct gpio_desc *desc);
 
 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
@@ -466,11 +466,6 @@ static inline int gpiod_export_link(struct device *dev, const char *name,
         return -ENOSYS;
 }
 
-static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
-{
-        return -ENOSYS;
-}
-
 static inline void gpiod_unexport(struct gpio_desc *desc)
 {
 }
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index f1b36593ec9f..cc7ec129b329 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -20,6 +20,7 @@ struct seq_file;
  * struct gpio_chip - abstract a GPIO controller
  * @label: for diagnostics
  * @dev: optional device providing the GPIOs
+ * @cdev: class device used by sysfs interface (may be NULL)
  * @owner: helps prevent removal of modules exporting active GPIOs
  * @list: links gpio_chips together for traversal
  * @request: optional hook for chip-specific activation, such as
@@ -41,8 +42,12 @@ struct seq_file;
  * @dbg_show: optional routine to show contents in debugfs; default code
  *      will be used when this is omitted, but custom code can show extra
  *      state (such as pullup/pulldown configuration).
- * @base: identifies the first GPIO number handled by this chip; or, if
- *      negative during registration, requests dynamic ID allocation.
+ * @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
+ *      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
  *      handled is (base + ngpio - 1).
  * @desc: array of ngpio descriptors. Private.
@@ -57,7 +62,6 @@ struct seq_file;
  *      implies that if the chip supports IRQs, these IRQs need to be threaded
  *      as the chip access may sleep when e.g. reading out the IRQ status
  *      registers.
- * @exported: flags if the gpiochip is exported for use from sysfs. Private.
  * @irq_not_threaded: flag must be set if @can_sleep is set but the
  *      IRQs don't need to be threaded
  *
@@ -74,6 +78,7 @@ struct seq_file;
 struct gpio_chip {
         const char              *label;
         struct device           *dev;
+        struct device           *cdev;
         struct module           *owner;
         struct list_head        list;
 
@@ -109,7 +114,6 @@ struct gpio_chip {
         const char              *const *names;
         bool                    can_sleep;
         bool                    irq_not_threaded;
-        bool                    exported;
 
 #ifdef CONFIG_GPIOLIB_IRQCHIP
         /*
@@ -121,6 +125,7 @@ struct gpio_chip {
         unsigned int            irq_base;
         irq_flow_handler_t      irq_handler;
         unsigned int            irq_default_type;
+        int                     irq_parent;
 #endif
 
 #if defined(CONFIG_OF_GPIO)
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index f4af03404b97..dfd59d6bc6f0 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -1,7 +1,7 @@
 #ifndef LINUX_HARDIRQ_H
 #define LINUX_HARDIRQ_H
 
-#include <linux/preempt_mask.h>
+#include <linux/preempt.h>
 #include <linux/lockdep.h>
 #include <linux/ftrace_irq.h>
 #include <linux/vtime.h>
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 176b43670e5d..f17980de2662 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -815,6 +815,8 @@ void hid_disconnect(struct hid_device *hid);
 const struct hid_device_id *hid_match_id(struct hid_device *hdev,
                                          const struct hid_device_id *id);
 s32 hid_snto32(__u32 value, unsigned n);
+__u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
+                     unsigned offset, unsigned n);
 
 /**
  * hid_device_io_start - enable HID input during probe, remove
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 9286a46b7d69..6aefcd0031a6 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -65,6 +65,7 @@ static inline void kunmap(struct page *page)
 
 static inline void *kmap_atomic(struct page *page)
 {
+        preempt_disable();
         pagefault_disable();
         return page_address(page);
 }
@@ -73,6 +74,7 @@ static inline void *kmap_atomic(struct page *page)
 static inline void __kunmap_atomic(void *addr)
 {
         pagefault_enable();
+        preempt_enable();
 }
 
 #define kmap_atomic_pfn(pfn)    kmap_atomic(pfn_to_page(pfn))
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 05f6df1fdf5b..76dd4f0da5ca 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -53,34 +53,25 @@ enum hrtimer_restart {
  *
  * 0x00         inactive
  * 0x01         enqueued into rbtree
- * 0x02         callback function running
- * 0x04         timer is migrated to another cpu
  *
- * Special cases:
- * 0x03         callback function running and enqueued
- *              (was requeued on another CPU)
- * 0x05         timer was migrated on CPU hotunplug
+ * The callback state is not part of the timer->state because clearing it would
+ * mean touching the timer after the callback, this makes it impossible to free
+ * the timer from the callback function.
  *
- * The "callback function running and enqueued" status is only possible on
- * SMP. It happens for example when a posix timer expired and the callback
+ * Therefore we track the callback state in:
+ *
+ *      timer->base->cpu_base->running == timer
+ *
+ * On SMP it is possible to have a "callback function running and enqueued"
+ * status. It happens for example when a posix timer expired and the callback
  * queued a signal. Between dropping the lock which protects the posix timer
  * and reacquiring the base lock of the hrtimer, another CPU can deliver the
- * signal and rearm the timer. We have to preserve the callback running state,
- * as otherwise the timer could be removed before the softirq code finishes the
- * the handling of the timer.
- *
- * The HRTIMER_STATE_ENQUEUED bit is always or'ed to the current state
- * to preserve the HRTIMER_STATE_CALLBACK in the above scenario. This
- * also affects HRTIMER_STATE_MIGRATE where the preservation is not
- * necessary. HRTIMER_STATE_MIGRATE is cleared after the timer is
- * enqueued on the new cpu.
+ * signal and rearm the timer.
  *
  * All state transitions are protected by cpu_base->lock.
  */
 #define HRTIMER_STATE_INACTIVE  0x00
 #define HRTIMER_STATE_ENQUEUED  0x01
-#define HRTIMER_STATE_CALLBACK  0x02
-#define HRTIMER_STATE_MIGRATE   0x04
 
 /**
  * struct hrtimer - the basic hrtimer structure
@@ -130,6 +121,12 @@ struct hrtimer_sleeper {
         struct task_struct *task;
 };
 
+#ifdef CONFIG_64BIT
+# define HRTIMER_CLOCK_BASE_ALIGN       64
+#else
+# define HRTIMER_CLOCK_BASE_ALIGN       32
+#endif
+
 /**
  * struct hrtimer_clock_base - the timer base for a specific clock
  * @cpu_base:           per cpu clock base
@@ -137,9 +134,7 @@ struct hrtimer_sleeper {
  *                      timer to a base on another cpu.
  * @clockid:            clock id for per_cpu support
  * @active:             red black tree root node for the active timers
- * @resolution:         the resolution of the clock, in nanoseconds
  * @get_time:           function to retrieve the current time of the clock
- * @softirq_time:       the time when running the hrtimer queue in the softirq
  * @offset:             offset of this clock to the monotonic base
  */
 struct hrtimer_clock_base {
@@ -147,11 +142,9 @@ struct hrtimer_clock_base {
         int                     index;
         clockid_t               clockid;
         struct timerqueue_head  active;
-        ktime_t                 resolution;
         ktime_t                 (*get_time)(void);
-        ktime_t                 softirq_time;
         ktime_t                 offset;
-};
+} __attribute__((__aligned__(HRTIMER_CLOCK_BASE_ALIGN)));
 
 enum  hrtimer_base_type {
         HRTIMER_BASE_MONOTONIC,
@@ -165,11 +158,16 @@ enum  hrtimer_base_type {
  * struct hrtimer_cpu_base - the per cpu clock bases
  * @lock:               lock protecting the base and associated clock bases
  *                      and timers
+ * @seq:                seqcount around __run_hrtimer
+ * @running:            pointer to the currently running hrtimer
  * @cpu:                cpu number
  * @active_bases:       Bitfield to mark bases with active timers
- * @clock_was_set:      Indicates that clock was set from irq context.
+ * @clock_was_set_seq:  Sequence counter of clock was set events
+ * @migration_enabled:  The migration of hrtimers to other cpus is enabled
+ * @nohz_active:        The nohz functionality is enabled
  * @expires_next:       absolute time of the next event which was scheduled
  *                      via clock_set_next_event()
+ * @next_timer:         Pointer to the first expiring timer
  * @in_hrtirq:          hrtimer_interrupt() is currently executing
  * @hres_active:        State of high resolution mode
  * @hang_detected:      The last hrtimer interrupt detected a hang
@@ -178,27 +176,38 @@ enum  hrtimer_base_type {
  * @nr_hangs:           Total number of hrtimer interrupt hangs
  * @max_hang_time:      Maximum time spent in hrtimer_interrupt
  * @clock_base:         array of clock bases for this cpu
+ *
+ * Note: next_timer is just an optimization for __remove_hrtimer().
+ *       Do not dereference the pointer because it is not reliable on
+ *       cross cpu removals.
  */
 struct hrtimer_cpu_base {
         raw_spinlock_t                  lock;
+        seqcount_t                      seq;
+        struct hrtimer                  *running;
         unsigned int                    cpu;
         unsigned int                    active_bases;
-        unsigned int                    clock_was_set;
+        unsigned int                    clock_was_set_seq;
+        bool                            migration_enabled;
+        bool                            nohz_active;
 #ifdef CONFIG_HIGH_RES_TIMERS
+        unsigned int                    in_hrtirq       : 1,
+                                        hres_active     : 1,
+                                        hang_detected   : 1;
         ktime_t                         expires_next;
-        int                             in_hrtirq;
-        int                             hres_active;
-        int                             hang_detected;
-        unsigned long                   nr_events;
-        unsigned long                   nr_retries;
-        unsigned long                   nr_hangs;
-        ktime_t                         max_hang_time;
+        struct hrtimer                  *next_timer;
+        unsigned int                    nr_events;
+        unsigned int                    nr_retries;
+        unsigned int                    nr_hangs;
+        unsigned int                    max_hang_time;
 #endif
         struct hrtimer_clock_base       clock_base[HRTIMER_MAX_CLOCK_BASES];
-};
+} ____cacheline_aligned;
 
 static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
 {
+        BUILD_BUG_ON(sizeof(struct hrtimer_clock_base) > HRTIMER_CLOCK_BASE_ALIGN);
+
         timer->node.expires = time;
         timer->_softexpires = time;
 }
@@ -262,19 +271,16 @@ static inline ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
         return ktime_sub(timer->node.expires, timer->base->get_time());
 }
 
-#ifdef CONFIG_HIGH_RES_TIMERS
-struct clock_event_device;
-
-extern void hrtimer_interrupt(struct clock_event_device *dev);
-
-/*
- * In high resolution mode the time reference must be read accurate
- */
 static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
 {
         return timer->base->get_time();
 }
 
+#ifdef CONFIG_HIGH_RES_TIMERS
+struct clock_event_device;
+
+extern void hrtimer_interrupt(struct clock_event_device *dev);
+
 static inline int hrtimer_is_hres_active(struct hrtimer *timer)
 {
         return timer->base->cpu_base->hres_active;
@@ -295,21 +301,16 @@ extern void hrtimer_peek_ahead_timers(void);
 
 extern void clock_was_set_delayed(void);
 
+extern unsigned int hrtimer_resolution;
+
 #else
 
 # define MONOTONIC_RES_NSEC     LOW_RES_NSEC
 # define KTIME_MONOTONIC_RES    KTIME_LOW_RES
 
-static inline void hrtimer_peek_ahead_timers(void) { }
+#define hrtimer_resolution      (unsigned int)LOW_RES_NSEC
 
-/*
- * In non high resolution mode the time reference is taken from
- * the base softirq time variable.
- */
-static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
-{
-        return timer->base->softirq_time;
-}
+static inline void hrtimer_peek_ahead_timers(void) { }
 
 static inline int hrtimer_is_hres_active(struct hrtimer *timer)
 {
@@ -353,49 +354,47 @@ static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
 #endif
 
 /* Basic timer operations: */
-extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
-                         const enum hrtimer_mode mode);
-extern int hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
+extern void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
                         unsigned long range_ns, const enum hrtimer_mode mode);
-extern int
-__hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
-                         unsigned long delta_ns,
-                         const enum hrtimer_mode mode, int wakeup);
+
+/**
+ * hrtimer_start - (re)start an hrtimer on the current CPU
+ * @timer:      the timer to be added
+ * @tim:        expiry time
+ * @mode:       expiry mode: absolute (HRTIMER_MODE_ABS) or
+ *              relative (HRTIMER_MODE_REL)
+ */
+static inline void hrtimer_start(struct hrtimer *timer, ktime_t tim,
+                                 const enum hrtimer_mode mode)
+{
+        hrtimer_start_range_ns(timer, tim, 0, mode);
+}
 
 extern int hrtimer_cancel(struct hrtimer *timer);
 extern int hrtimer_try_to_cancel(struct hrtimer *timer);
 
-static inline int hrtimer_start_expires(struct hrtimer *timer,
-                                                enum hrtimer_mode mode)
+static inline void hrtimer_start_expires(struct hrtimer *timer,
+                                         enum hrtimer_mode mode)
 {
         unsigned long delta;
         ktime_t soft, hard;
         soft = hrtimer_get_softexpires(timer);
         hard = hrtimer_get_expires(timer);
         delta = ktime_to_ns(ktime_sub(hard, soft));
-        return hrtimer_start_range_ns(timer, soft, delta, mode);
+        hrtimer_start_range_ns(timer, soft, delta, mode);
 }
 
-static inline int hrtimer_restart(struct hrtimer *timer)
+static inline void hrtimer_restart(struct hrtimer *timer)
 {
-        return hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
+        hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
 }
 
 /* Query timers: */
 extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
-extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);
 
-extern ktime_t hrtimer_get_next_event(void);
+extern u64 hrtimer_get_next_event(void);
 
-/*
- * A timer is active, when it is enqueued into the rbtree or the
- * callback function is running or it's in the state of being migrated
- * to another cpu.
- */
-static inline int hrtimer_active(const struct hrtimer *timer)
-{
-        return timer->state != HRTIMER_STATE_INACTIVE;
-}
+extern bool hrtimer_active(const struct hrtimer *timer);
 
 /*
  * Helper function to check, whether the timer is on one of the queues
@@ -411,14 +410,29 @@ static inline int hrtimer_is_queued(struct hrtimer *timer)
  */
 static inline int hrtimer_callback_running(struct hrtimer *timer)
 {
-        return timer->state & HRTIMER_STATE_CALLBACK;
+        return timer->base->cpu_base->running == timer;
 }
 
 /* Forward a hrtimer so it expires after now: */
 extern u64
 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
 
-/* Forward a hrtimer so it expires after the hrtimer's current now */
+/**
+ * hrtimer_forward_now - forward the timer expiry so it expires after now
+ * @timer:      hrtimer to forward
+ * @interval:   the interval to forward
+ *
+ * Forward the timer expiry so it will expire after the current time
+ * of the hrtimer clock base. Returns the number of overruns.
+ *
+ * Can be safely called from the callback function of @timer. If
+ * called from other contexts @timer must neither be enqueued nor
+ * running the callback and the caller needs to take care of
+ * serialization.
+ *
+ * Note: This only updates the timer expiry value and does not requeue
+ * the timer.
+ */
 static inline u64 hrtimer_forward_now(struct hrtimer *timer,
                                       ktime_t interval)
 {
@@ -443,7 +457,6 @@ extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
 
 /* Soft interrupt function to run the hrtimer queues: */
 extern void hrtimer_run_queues(void);
-extern void hrtimer_run_pending(void);
 
 /* Bootup initialization: */
 extern void __init hrtimers_init(void);
diff --git a/include/linux/htirq.h b/include/linux/htirq.h
index 70a1dbbf2093..d4a527e58434 100644
--- a/include/linux/htirq.h
+++ b/include/linux/htirq.h
@@ -1,24 +1,38 @@
 #ifndef LINUX_HTIRQ_H
 #define LINUX_HTIRQ_H
 
+struct pci_dev;
+struct irq_data;
+
 struct ht_irq_msg {
         u32     address_lo;     /* low 32 bits of the ht irq message */
         u32     address_hi;     /* high 32 bits of the it irq message */
 };
 
+typedef void (ht_irq_update_t)(struct pci_dev *dev, int irq,
+                               struct ht_irq_msg *msg);
+
+struct ht_irq_cfg {
+        struct pci_dev *dev;
+         /* Update callback used to cope with buggy hardware */
+        ht_irq_update_t *update;
+        unsigned pos;
+        unsigned idx;
+        struct ht_irq_msg msg;
+};
+
 /* Helper functions.. */
 void fetch_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg);
 void write_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg);
-struct irq_data;
 void mask_ht_irq(struct irq_data *data);
 void unmask_ht_irq(struct irq_data *data);
 
 /* The arch hook for getting things started */
-int arch_setup_ht_irq(unsigned int irq, struct pci_dev *dev);
+int arch_setup_ht_irq(int idx, int pos, struct pci_dev *dev,
+                      ht_irq_update_t *update);
+void arch_teardown_ht_irq(unsigned int irq);
 
 /* For drivers of buggy hardware */
-typedef void (ht_irq_update_t)(struct pci_dev *dev, int irq,
-                               struct ht_irq_msg *msg);
 int __ht_create_irq(struct pci_dev *dev, int idx, ht_irq_update_t *update);
 
 #endif /* LINUX_HTIRQ_H */
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/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_task.h b/include/linux/init_task.h
index 696d22312b31..bb9b075f0eb0 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -50,9 +50,8 @@ extern struct fs_struct init_fs;
         .cpu_timers     = INIT_CPU_TIMERS(sig.cpu_timers),              \
         .rlim           = INIT_RLIMITS,                                 \
         .cputimer       = {                                             \
-                .cputime = INIT_CPUTIME,                                \
-                .running = 0,                                           \
-                .lock = __RAW_SPIN_LOCK_UNLOCKED(sig.cputimer.lock),    \
+                .cputime_atomic = INIT_CPUTIME_ATOMIC,                  \
+                .running        = 0,                                    \
         },                                                              \
         .cred_guard_mutex =                                             \
                  __MUTEX_INITIALIZER(sig.cred_guard_mutex),             \
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index 796ef9645827..d9a366d24e3b 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -87,6 +87,7 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
 /*
  * Decoding Capability Register
  */
+#define cap_pi_support(c)       (((c) >> 59) & 1)
 #define cap_read_drain(c)       (((c) >> 55) & 1)
 #define cap_write_drain(c)      (((c) >> 54) & 1)
 #define cap_max_amask_val(c)    (((c) >> 48) & 0x3f)
@@ -115,13 +116,14 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
  * Extended Capability Register
  */
 
+#define ecap_pasid(e)           ((e >> 40) & 0x1)
 #define ecap_pss(e)             ((e >> 35) & 0x1f)
 #define ecap_eafs(e)            ((e >> 34) & 0x1)
 #define ecap_nwfs(e)            ((e >> 33) & 0x1)
 #define ecap_srs(e)             ((e >> 31) & 0x1)
 #define ecap_ers(e)             ((e >> 30) & 0x1)
 #define ecap_prs(e)             ((e >> 29) & 0x1)
-#define ecap_pasid(e)           ((e >> 28) & 0x1)
+/* PASID support used to be on bit 28 */
 #define ecap_dis(e)             ((e >> 27) & 0x1)
 #define ecap_nest(e)            ((e >> 26) & 0x1)
 #define ecap_mts(e)             ((e >> 25) & 0x1)
@@ -295,9 +297,12 @@ 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
 
+struct irq_domain;
+
 struct ir_table {
         struct irte *base;
         unsigned long *bitmap;
@@ -319,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 */
@@ -347,9 +355,12 @@ struct intel_iommu {
 
 #ifdef CONFIG_IRQ_REMAP
         struct ir_table *ir_table;      /* Interrupt remapping info */
+        struct irq_domain *ir_domain;
+        struct irq_domain *ir_msi_domain;
 #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/interrupt.h b/include/linux/interrupt.h
index 950ae4501826..be7e75c945e9 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -413,7 +413,8 @@ enum
         BLOCK_IOPOLL_SOFTIRQ,
         TASKLET_SOFTIRQ,
         SCHED_SOFTIRQ,
-        HRTIMER_SOFTIRQ,
+        HRTIMER_SOFTIRQ, /* Unused, but kept as tools rely on the
+                            numbering. Sigh! */
         RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
 
         NR_SOFTIRQS
@@ -592,10 +593,10 @@ tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,
                      clockid_t which_clock, enum hrtimer_mode mode);
 
 static inline
-int tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,
-                          const enum hrtimer_mode mode)
+void tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,
+                           const enum hrtimer_mode mode)
 {
-        return hrtimer_start(&ttimer->timer, time, mode);
+        hrtimer_start(&ttimer->timer, time, mode);
 }
 
 static inline
diff --git a/include/linux/io-mapping.h b/include/linux/io-mapping.h
index 657fab4efab3..c27dde7215b5 100644
--- a/include/linux/io-mapping.h
+++ b/include/linux/io-mapping.h
@@ -141,6 +141,7 @@ static inline void __iomem *
 io_mapping_map_atomic_wc(struct io_mapping *mapping,
                          unsigned long offset)
 {
+        preempt_disable();
         pagefault_disable();
         return ((char __force __iomem *) mapping) + offset;
 }
@@ -149,6 +150,7 @@ static inline void
 io_mapping_unmap_atomic(void __iomem *vaddr)
 {
         pagefault_enable();
+        preempt_enable();
 }
 
 /* Non-atomic map/unmap */
diff --git a/include/linux/io.h b/include/linux/io.h
index 986f2bffea1e..fb5a99800e77 100644
--- a/include/linux/io.h
+++ b/include/linux/io.h
@@ -19,6 +19,7 @@
 #define _LINUX_IO_H
 
 #include <linux/types.h>
+#include <linux/init.h>
 #include <asm/io.h>
 #include <asm/page.h>
 
@@ -111,6 +112,13 @@ static inline void arch_phys_wc_del(int handle)
 }
 
 #define arch_phys_wc_add arch_phys_wc_add
+#ifndef arch_phys_wc_index
+static inline int arch_phys_wc_index(int handle)
+{
+        return -1;
+}
+#define arch_phys_wc_index arch_phys_wc_index
+#endif
 #endif
 
 #endif /* _LINUX_IO_H */
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 0546b8710ce3..dc767f7c3704 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);
@@ -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 62c6901cab55..812149160d3b 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -126,13 +126,21 @@ struct msi_desc;
 struct irq_domain;
 
 /**
- * struct irq_data - per irq and irq chip data passed down to chip functions
+ * struct irq_common_data - per irq data shared by all irqchips
+ * @state_use_accessors: status information for irq chip functions.
+ *                      Use accessor functions to deal with it
+ */
+struct irq_common_data {
+        unsigned int            state_use_accessors;
+};
+
+/**
+ * struct irq_data - per irq chip data passed down to chip functions
  * @mask:               precomputed bitmask for accessing the chip registers
  * @irq:                interrupt number
  * @hwirq:              hardware interrupt number, local to the interrupt domain
  * @node:               node index useful for balancing
- * @state_use_accessors: status information for irq chip functions.
- *                      Use accessor functions to deal with it
+ * @common:             point to data shared by all irqchips
  * @chip:               low level interrupt hardware access
  * @domain:             Interrupt translation domain; responsible for mapping
  *                      between hwirq number and linux irq number.
@@ -153,7 +161,7 @@ struct irq_data {
         unsigned int            irq;
         unsigned long           hwirq;
         unsigned int            node;
-        unsigned int            state_use_accessors;
+        struct irq_common_data  *common;
         struct irq_chip         *chip;
         struct irq_domain       *domain;
 #ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
@@ -166,7 +174,7 @@ struct irq_data {
 };
 
 /*
- * Bit masks for irq_data.state
+ * Bit masks for irq_common_data.state_use_accessors
  *
  * IRQD_TRIGGER_MASK            - Mask for the trigger type bits
  * IRQD_SETAFFINITY_PENDING     - Affinity setting is pending
@@ -198,34 +206,36 @@ enum {
         IRQD_WAKEUP_ARMED               = (1 << 19),
 };
 
+#define __irqd_to_state(d)              ((d)->common->state_use_accessors)
+
 static inline bool irqd_is_setaffinity_pending(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_SETAFFINITY_PENDING;
+        return __irqd_to_state(d) & IRQD_SETAFFINITY_PENDING;
 }
 
 static inline bool irqd_is_per_cpu(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_PER_CPU;
+        return __irqd_to_state(d) & IRQD_PER_CPU;
 }
 
 static inline bool irqd_can_balance(struct irq_data *d)
 {
-        return !(d->state_use_accessors & (IRQD_PER_CPU | IRQD_NO_BALANCING));
+        return !(__irqd_to_state(d) & (IRQD_PER_CPU | IRQD_NO_BALANCING));
 }
 
 static inline bool irqd_affinity_was_set(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_AFFINITY_SET;
+        return __irqd_to_state(d) & IRQD_AFFINITY_SET;
 }
 
 static inline void irqd_mark_affinity_was_set(struct irq_data *d)
 {
-        d->state_use_accessors |= IRQD_AFFINITY_SET;
+        __irqd_to_state(d) |= IRQD_AFFINITY_SET;
 }
 
 static inline u32 irqd_get_trigger_type(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_TRIGGER_MASK;
+        return __irqd_to_state(d) & IRQD_TRIGGER_MASK;
 }
 
 /*
@@ -233,43 +243,43 @@ static inline u32 irqd_get_trigger_type(struct irq_data *d)
  */
 static inline void irqd_set_trigger_type(struct irq_data *d, u32 type)
 {
-        d->state_use_accessors &= ~IRQD_TRIGGER_MASK;
-        d->state_use_accessors |= type & IRQD_TRIGGER_MASK;
+        __irqd_to_state(d) &= ~IRQD_TRIGGER_MASK;
+        __irqd_to_state(d) |= type & IRQD_TRIGGER_MASK;
 }
 
 static inline bool irqd_is_level_type(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_LEVEL;
+        return __irqd_to_state(d) & IRQD_LEVEL;
 }
 
 static inline bool irqd_is_wakeup_set(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_WAKEUP_STATE;
+        return __irqd_to_state(d) & IRQD_WAKEUP_STATE;
 }
 
 static inline bool irqd_can_move_in_process_context(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_MOVE_PCNTXT;
+        return __irqd_to_state(d) & IRQD_MOVE_PCNTXT;
 }
 
 static inline bool irqd_irq_disabled(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_IRQ_DISABLED;
+        return __irqd_to_state(d) & IRQD_IRQ_DISABLED;
 }
 
 static inline bool irqd_irq_masked(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_IRQ_MASKED;
+        return __irqd_to_state(d) & IRQD_IRQ_MASKED;
 }
 
 static inline bool irqd_irq_inprogress(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_IRQ_INPROGRESS;
+        return __irqd_to_state(d) & IRQD_IRQ_INPROGRESS;
 }
 
 static inline bool irqd_is_wakeup_armed(struct irq_data *d)
 {
-        return d->state_use_accessors & IRQD_WAKEUP_ARMED;
+        return __irqd_to_state(d) & IRQD_WAKEUP_ARMED;
 }
 
 
@@ -280,12 +290,12 @@ static inline bool irqd_is_wakeup_armed(struct irq_data *d)
  */
 static inline void irqd_set_chained_irq_inprogress(struct irq_data *d)
 {
-        d->state_use_accessors |= IRQD_IRQ_INPROGRESS;
+        __irqd_to_state(d) |= IRQD_IRQ_INPROGRESS;
 }
 
 static inline void irqd_clr_chained_irq_inprogress(struct irq_data *d)
 {
-        d->state_use_accessors &= ~IRQD_IRQ_INPROGRESS;
+        __irqd_to_state(d) &= ~IRQD_IRQ_INPROGRESS;
 }
 
 static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
@@ -327,6 +337,7 @@ static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
  * @irq_write_msi_msg:  optional to write message content for MSI
  * @irq_get_irqchip_state:      return the internal state of an interrupt
  * @irq_set_irqchip_state:      set the internal state of a interrupt
+ * @irq_set_vcpu_affinity:      optional to target a vCPU in a virtual machine
  * @flags:              chip specific flags
  */
 struct irq_chip {
@@ -369,6 +380,8 @@ struct irq_chip {
         int             (*irq_get_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool *state);
         int             (*irq_set_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool state);
 
+        int             (*irq_set_vcpu_affinity)(struct irq_data *data, void *vcpu_info);
+
         unsigned long   flags;
 };
 
@@ -422,6 +435,7 @@ extern void irq_cpu_online(void);
 extern void irq_cpu_offline(void);
 extern int irq_set_affinity_locked(struct irq_data *data,
                                    const struct cpumask *cpumask, bool force);
+extern int irq_set_vcpu_affinity(unsigned int irq, void *vcpu_info);
 
 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
 void irq_move_irq(struct irq_data *data);
@@ -458,6 +472,8 @@ extern void handle_nested_irq(unsigned int irq);
 
 extern int irq_chip_compose_msi_msg(struct irq_data *data, struct msi_msg *msg);
 #ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
+extern void irq_chip_enable_parent(struct irq_data *data);
+extern void irq_chip_disable_parent(struct irq_data *data);
 extern void irq_chip_ack_parent(struct irq_data *data);
 extern int irq_chip_retrigger_hierarchy(struct irq_data *data);
 extern void irq_chip_mask_parent(struct irq_data *data);
@@ -467,6 +483,8 @@ extern int irq_chip_set_affinity_parent(struct irq_data *data,
                                         const struct cpumask *dest,
                                         bool force);
 extern int irq_chip_set_wake_parent(struct irq_data *data, unsigned int on);
+extern int irq_chip_set_vcpu_affinity_parent(struct irq_data *data,
+                                             void *vcpu_info);
 #endif
 
 /* Handling of unhandled and spurious interrupts: */
@@ -517,6 +535,15 @@ irq_set_chained_handler(unsigned int irq, irq_flow_handler_t handle)
         __irq_set_handler(irq, handle, 1, NULL);
 }
 
+/*
+ * Set a highlevel chained flow handler and its data for a given IRQ.
+ * (a chained handler is automatically enabled and set to
+ *  IRQ_NOREQUEST, IRQ_NOPROBE, and IRQ_NOTHREAD)
+ */
+void
+irq_set_chained_handler_and_data(unsigned int irq, irq_flow_handler_t handle,
+                                 void *data);
+
 void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set);
 
 static inline void irq_set_status_flags(unsigned int irq, unsigned long set)
@@ -624,6 +651,23 @@ static inline u32 irq_get_trigger_type(unsigned int irq)
         return d ? irqd_get_trigger_type(d) : 0;
 }
 
+static inline int irq_data_get_node(struct irq_data *d)
+{
+        return d->node;
+}
+
+static inline struct cpumask *irq_get_affinity_mask(int irq)
+{
+        struct irq_data *d = irq_get_irq_data(irq);
+
+        return d ? d->affinity : NULL;
+}
+
+static inline struct cpumask *irq_data_get_affinity_mask(struct irq_data *d)
+{
+        return d->affinity;
+}
+
 unsigned int arch_dynirq_lower_bound(unsigned int from);
 
 int __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index dd1109fb241e..c52d1480f272 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -17,7 +17,7 @@ struct pt_regs;
 
 /**
  * struct irq_desc - interrupt descriptor
- * @irq_data:           per irq and chip data passed down to chip functions
+ * @irq_common_data:    per irq and chip data passed down to chip functions
  * @kstat_irqs:         irq stats per cpu
  * @handle_irq:         highlevel irq-events handler
  * @preflow_handler:    handler called before the flow handler (currently used by sparc)
@@ -47,6 +47,7 @@ struct pt_regs;
  * @name:               flow handler name for /proc/interrupts output
  */
 struct irq_desc {
+        struct irq_common_data  irq_common_data;
         struct irq_data         irq_data;
         unsigned int __percpu   *kstat_irqs;
         irq_flow_handler_t      handle_irq;
@@ -93,6 +94,15 @@ struct irq_desc {
 extern struct irq_desc irq_desc[NR_IRQS];
 #endif
 
+static inline struct irq_desc *irq_data_to_desc(struct irq_data *data)
+{
+#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
+        return irq_to_desc(data->irq);
+#else
+        return container_of(data, struct irq_desc, irq_data);
+#endif
+}
+
 static inline struct irq_data *irq_desc_get_irq_data(struct irq_desc *desc)
 {
         return &desc->irq_data;
diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index 676d7306a360..744ac0ec98eb 100644
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -258,6 +258,10 @@ int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
 /* V2 interfaces to support hierarchy IRQ domains. */
 extern struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
                                                 unsigned int virq);
+extern void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
+                                irq_hw_number_t hwirq, struct irq_chip *chip,
+                                void *chip_data, irq_flow_handler_t handler,
+                                void *handler_data, const char *handler_name);
 #ifdef  CONFIG_IRQ_DOMAIN_HIERARCHY
 extern struct irq_domain *irq_domain_add_hierarchy(struct irq_domain *parent,
                         unsigned int flags, unsigned int size,
@@ -281,10 +285,6 @@ extern int irq_domain_set_hwirq_and_chip(struct irq_domain *domain,
                                          irq_hw_number_t hwirq,
                                          struct irq_chip *chip,
                                          void *chip_data);
-extern void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
-                                irq_hw_number_t hwirq, struct irq_chip *chip,
-                                void *chip_data, irq_flow_handler_t handler,
-                                void *handler_data, const char *handler_name);
 extern void irq_domain_reset_irq_data(struct irq_data *irq_data);
 extern void irq_domain_free_irqs_common(struct irq_domain *domain,
                                         unsigned int virq,
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/jiffies.h b/include/linux/jiffies.h
index c367cbdf73ab..535fd3bb1ba8 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -7,6 +7,7 @@
 #include <linux/time.h>
 #include <linux/timex.h>
 #include <asm/param.h>                  /* for HZ */
+#include <generated/timeconst.h>
 
 /*
  * The following defines establish the engineering parameters of the PLL
@@ -288,8 +289,133 @@ static inline u64 jiffies_to_nsecs(const unsigned long j)
         return (u64)jiffies_to_usecs(j) * NSEC_PER_USEC;
 }
 
-extern unsigned long msecs_to_jiffies(const unsigned int m);
-extern unsigned long usecs_to_jiffies(const unsigned int u);
+extern unsigned long __msecs_to_jiffies(const unsigned int m);
+#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
+/*
+ * HZ is equal to or smaller than 1000, and 1000 is a nice round
+ * multiple of HZ, divide with the factor between them, but round
+ * upwards:
+ */
+static inline unsigned long _msecs_to_jiffies(const unsigned int m)
+{
+        return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
+}
+#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
+/*
+ * HZ is larger than 1000, and HZ is a nice round multiple of 1000 -
+ * simply multiply with the factor between them.
+ *
+ * But first make sure the multiplication result cannot overflow:
+ */
+static inline unsigned long _msecs_to_jiffies(const unsigned int m)
+{
+        if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
+                return MAX_JIFFY_OFFSET;
+        return m * (HZ / MSEC_PER_SEC);
+}
+#else
+/*
+ * Generic case - multiply, round and divide. But first check that if
+ * we are doing a net multiplication, that we wouldn't overflow:
+ */
+static inline unsigned long _msecs_to_jiffies(const unsigned int m)
+{
+        if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
+                return MAX_JIFFY_OFFSET;
+
+        return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32) >> MSEC_TO_HZ_SHR32;
+}
+#endif
+/**
+ * msecs_to_jiffies: - convert milliseconds to jiffies
+ * @m:  time in milliseconds
+ *
+ * conversion is done as follows:
+ *
+ * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
+ *
+ * - 'too large' values [that would result in larger than
+ *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
+ *
+ * - all other values are converted to jiffies by either multiplying
+ *   the input value by a factor or dividing it with a factor and
+ *   handling any 32-bit overflows.
+ *   for the details see __msecs_to_jiffies()
+ *
+ * msecs_to_jiffies() checks for the passed in value being a constant
+ * via __builtin_constant_p() allowing gcc to eliminate most of the
+ * code, __msecs_to_jiffies() is called if the value passed does not
+ * allow constant folding and the actual conversion must be done at
+ * runtime.
+ * the HZ range specific helpers _msecs_to_jiffies() are called both
+ * directly here and from __msecs_to_jiffies() in the case where
+ * constant folding is not possible.
+ */
+static inline unsigned long msecs_to_jiffies(const unsigned int m)
+{
+        if (__builtin_constant_p(m)) {
+                if ((int)m < 0)
+                        return MAX_JIFFY_OFFSET;
+                return _msecs_to_jiffies(m);
+        } else {
+                return __msecs_to_jiffies(m);
+        }
+}
+
+extern unsigned long __usecs_to_jiffies(const unsigned int u);
+#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+        return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
+}
+#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+        return u * (HZ / USEC_PER_SEC);
+}
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+#else
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+        return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
+                >> USEC_TO_HZ_SHR32;
+}
+#endif
+
+/**
+ * usecs_to_jiffies: - convert microseconds to jiffies
+ * @u:  time in microseconds
+ *
+ * conversion is done as follows:
+ *
+ * - 'too large' values [that would result in larger than
+ *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
+ *
+ * - all other values are converted to jiffies by either multiplying
+ *   the input value by a factor or dividing it with a factor and
+ *   handling any 32-bit overflows as for msecs_to_jiffies.
+ *
+ * usecs_to_jiffies() checks for the passed in value being a constant
+ * via __builtin_constant_p() allowing gcc to eliminate most of the
+ * code, __usecs_to_jiffies() is called if the value passed does not
+ * allow constant folding and the actual conversion must be done at
+ * runtime.
+ * the HZ range specific helpers _usecs_to_jiffies() are called both
+ * directly here and from __msecs_to_jiffies() in the case where
+ * constant folding is not possible.
+ */
+static inline unsigned long usecs_to_jiffies(const unsigned int u)
+{
+        if (__builtin_constant_p(u)) {
+                if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
+                        return MAX_JIFFY_OFFSET;
+                return _usecs_to_jiffies(u);
+        } else {
+                return __usecs_to_jiffies(u);
+        }
+}
+
 extern unsigned long timespec_to_jiffies(const struct timespec *value);
 extern void jiffies_to_timespec(const unsigned long jiffies,
                                 struct timespec *value);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 3a5b48e52a9e..060dd7b61c6d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -244,7 +244,8 @@ static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
 
 #if defined(CONFIG_MMU) && \
         (defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP))
-void might_fault(void);
+#define might_fault() __might_fault(__FILE__, __LINE__)
+void __might_fault(const char *file, int line);
 #else
 static inline void might_fault(void) { }
 #endif
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/kvm_host.h b/include/linux/kvm_host.h
index ad45054309a0..9564fd78c547 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);
@@ -762,16 +807,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 +822,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/lglock.h b/include/linux/lglock.h
index 0081f000e34b..c92ebd100d9b 100644
--- a/include/linux/lglock.h
+++ b/include/linux/lglock.h
@@ -52,10 +52,15 @@ struct lglock {
         static struct lglock name = { .lock = &name ## _lock }
 
 void lg_lock_init(struct lglock *lg, char *name);
+
 void lg_local_lock(struct lglock *lg);
 void lg_local_unlock(struct lglock *lg);
 void lg_local_lock_cpu(struct lglock *lg, int cpu);
 void lg_local_unlock_cpu(struct lglock *lg, int cpu);
+
+void lg_double_lock(struct lglock *lg, int cpu1, int cpu2);
+void lg_double_unlock(struct lglock *lg, int cpu1, int cpu2);
+
 void lg_global_lock(struct lglock *lg);
 void lg_global_unlock(struct lglock *lg);
 
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 28aeae46f355..36ce37bcc963 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,7 @@ 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 */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
@@ -1364,7 +1364,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/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 066ba4157541..70400dc7660f 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -130,8 +130,8 @@ enum bounce_type {
 };
 
 struct lock_class_stats {
-        unsigned long                   contention_point[4];
-        unsigned long                   contending_point[4];
+        unsigned long                   contention_point[LOCKSTAT_POINTS];
+        unsigned long                   contending_point[LOCKSTAT_POINTS];
         struct lock_time                read_waittime;
         struct lock_time                write_waittime;
         struct lock_time                read_holdtime;
@@ -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/mbus.h b/include/linux/mbus.h
index 611b69fa8594..1f7bc630d225 100644
--- a/include/linux/mbus.h
+++ b/include/linux/mbus.h
@@ -54,11 +54,16 @@ struct mbus_dram_target_info
  */
 #ifdef CONFIG_PLAT_ORION
 extern const struct mbus_dram_target_info *mv_mbus_dram_info(void);
+extern const struct mbus_dram_target_info *mv_mbus_dram_info_nooverlap(void);
 #else
 static inline const struct mbus_dram_target_info *mv_mbus_dram_info(void)
 {
         return NULL;
 }
+static inline const struct mbus_dram_target_info *mv_mbus_dram_info_nooverlap(void)
+{
+        return NULL;
+}
 #endif
 
 int mvebu_mbus_save_cpu_target(u32 *store_addr);
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/memblock.h b/include/linux/memblock.h
index 9497ec7c77ea..0215ffd63069 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,11 +91,13 @@ 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);
 
@@ -100,16 +108,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,17 +128,18 @@ 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))
 
 #ifdef CONFIG_MOVABLE_NODE
@@ -153,6 +163,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 +196,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 +212,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 +291,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..f6722677e6d0 100644
--- a/include/linux/mfd/arizona/pdata.h
+++ b/include/linux/mfd/arizona/pdata.h
@@ -156,7 +156,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..02f97dc568ac 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,11 @@ 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;
+};
+
 #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/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..99959a34f4f1 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);
@@ -2146,12 +2150,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/mmc/card.h b/include/linux/mmc/card.h
index 19f0175c0afa..4d3776d25925 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -97,6 +97,7 @@ struct mmc_ext_csd {
         u8                      raw_erased_mem_count;   /* 181 */
         u8                      raw_ext_csd_structure;  /* 194 */
         u8                      raw_card_type;          /* 196 */
+        u8                      raw_driver_strength;    /* 197 */
         u8                      out_of_int_time;        /* 198 */
         u8                      raw_pwr_cl_52_195;      /* 200 */
         u8                      raw_pwr_cl_26_195;      /* 201 */
@@ -305,6 +306,7 @@ struct mmc_card {
 
         unsigned int            sd_bus_speed;   /* Bus Speed Mode set for the card */
         unsigned int            mmc_avail_type; /* supported device type by both host and card */
+        unsigned int            drive_strength; /* for UHS-I, HS200 or HS400 */
 
         struct dentry           *debugfs_root;
         struct mmc_part part[MMC_NUM_PHY_PARTITION]; /* physical partitions */
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index de722d4e9d61..258daf914c6d 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -121,6 +121,7 @@ struct mmc_data {
         struct mmc_request      *mrq;           /* associated request */
 
         unsigned int            sg_len;         /* size of scatter list */
+        int                     sg_count;       /* mapped sg entries */
         struct scatterlist      *sg;            /* I/O scatter list */
         s32                     host_cookie;    /* host private data */
 };
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index 12111993a317..5be97676f1fa 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -226,12 +226,6 @@ struct dw_mci_dma_ops {
 #define DW_MCI_QUIRK_HIGHSPEED                  BIT(2)
 /* Unreliable card detection */
 #define DW_MCI_QUIRK_BROKEN_CARD_DETECTION      BIT(3)
-/* No write protect */
-#define DW_MCI_QUIRK_NO_WRITE_PROTECT           BIT(4)
-
-/* Slot level quirks */
-/* This slot has no write protect */
-#define DW_MCI_SLOT_QUIRK_NO_WRITE_PROTECT      BIT(0)
 
 struct dma_pdata;
 
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index b5bedaec6223..1369e54faeb7 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -12,6 +12,7 @@
 
 #include <linux/leds.h>
 #include <linux/mutex.h>
+#include <linux/timer.h>
 #include <linux/sched.h>
 #include <linux/device.h>
 #include <linux/fault-inject.h>
@@ -131,7 +132,9 @@ struct mmc_host_ops {
 
         /* Prepare HS400 target operating frequency depending host driver */
         int     (*prepare_hs400_tuning)(struct mmc_host *host, struct mmc_ios *ios);
-        int     (*select_drive_strength)(unsigned int max_dtr, int host_drv, int card_drv);
+        int     (*select_drive_strength)(struct mmc_card *card,
+                                         unsigned int max_dtr, int host_drv,
+                                         int card_drv, int *drv_type);
         void    (*hw_reset)(struct mmc_host *host);
         void    (*card_event)(struct mmc_host *host);
 
@@ -285,6 +288,7 @@ struct mmc_host {
                                  MMC_CAP2_HS400_1_2V)
 #define MMC_CAP2_HSX00_1_2V     (MMC_CAP2_HS200_1_2V_SDR | MMC_CAP2_HS400_1_2V)
 #define MMC_CAP2_SDIO_IRQ_NOTHREAD (1 << 17)
+#define MMC_CAP2_NO_WRITE_PROTECT (1 << 18)     /* No physical write protect pin, assume that card is always read-write */
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
 
@@ -321,10 +325,18 @@ struct mmc_host {
 #ifdef CONFIG_MMC_DEBUG
         unsigned int            removed:1;      /* host is being removed */
 #endif
+        unsigned int            can_retune:1;   /* re-tuning can be used */
+        unsigned int            doing_retune:1; /* re-tuning in progress */
+        unsigned int            retune_now:1;   /* do re-tuning at next req */
 
         int                     rescan_disable; /* disable card detection */
         int                     rescan_entered; /* used with nonremovable devices */
 
+        int                     need_retune;    /* re-tuning is needed */
+        int                     hold_retune;    /* hold off re-tuning */
+        unsigned int            retune_period;  /* re-tuning period in secs */
+        struct timer_list       retune_timer;   /* for periodic re-tuning */
+
         bool                    trigger_card_event; /* card_event necessary */
 
         struct mmc_card         *card;          /* device attached to this host */
@@ -513,4 +525,18 @@ static inline bool mmc_card_hs400(struct mmc_card *card)
         return card->host->ios.timing == MMC_TIMING_MMC_HS400;
 }
 
+void mmc_retune_timer_stop(struct mmc_host *host);
+
+static inline void mmc_retune_needed(struct mmc_host *host)
+{
+        if (host->can_retune)
+                host->need_retune = 1;
+}
+
+static inline void mmc_retune_recheck(struct mmc_host *host)
+{
+        if (host->hold_retune <= 1)
+                host->retune_now = 1;
+}
+
 #endif /* LINUX_MMC_HOST_H */
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 124f562118b8..15f2c4a0a62c 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -302,6 +302,7 @@ struct _mmc_csd {
 #define EXT_CSD_REV                     192     /* RO */
 #define EXT_CSD_STRUCTURE               194     /* RO */
 #define EXT_CSD_CARD_TYPE               196     /* RO */
+#define EXT_CSD_DRIVER_STRENGTH         197     /* RO */
 #define EXT_CSD_OUT_OF_INTERRUPT_TIME   198     /* RO */
 #define EXT_CSD_PART_SWITCH_TIME        199     /* RO */
 #define EXT_CSD_PWR_CL_52_195           200     /* RO */
@@ -390,6 +391,7 @@ struct _mmc_csd {
 #define EXT_CSD_TIMING_HS       1       /* High speed */
 #define EXT_CSD_TIMING_HS200    2       /* HS200 */
 #define EXT_CSD_TIMING_HS400    3       /* HS400 */
+#define EXT_CSD_DRV_STR_SHIFT   4       /* Driver Strength shift */
 
 #define EXT_CSD_SEC_ER_EN       BIT(0)
 #define EXT_CSD_SEC_BD_BLK_EN   BIT(2)
@@ -441,4 +443,6 @@ struct _mmc_csd {
 #define MMC_SWITCH_MODE_CLEAR_BITS      0x02    /* Clear bits which are 1 in value */
 #define MMC_SWITCH_MODE_WRITE_BYTE      0x03    /* Set target to value */
 
+#define mmc_driver_type_mask(n)         (1 << (n))
+
 #endif /* LINUX_MMC_MMC_H */
diff --git a/include/linux/mmc/sdhci-pci-data.h b/include/linux/mmc/sdhci-pci-data.h
index 8959604a13d3..fda15b6d4135 100644
--- a/include/linux/mmc/sdhci-pci-data.h
+++ b/include/linux/mmc/sdhci-pci-data.h
@@ -15,4 +15,6 @@ struct sdhci_pci_data {
 extern struct sdhci_pci_data *(*sdhci_pci_get_data)(struct pci_dev *pdev,
                                 int slotno);
 
+extern int sdhci_pci_spt_drive_strength;
+
 #endif
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/module.h b/include/linux/module.h
index c883b86ea964..1e5436042eb0 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -655,4 +655,16 @@ static inline void module_bug_finalize(const Elf_Ehdr *hdr,
 static inline void module_bug_cleanup(struct module *mod) {}
 #endif  /* CONFIG_GENERIC_BUG */
 
+#ifdef CONFIG_MODULE_SIG
+static inline bool module_sig_ok(struct module *module)
+{
+        return module->sig_ok;
+}
+#else   /* !CONFIG_MODULE_SIG */
+static inline bool module_sig_ok(struct module *module)
+{
+        return true;
+}
+#endif  /* CONFIG_MODULE_SIG */
+
 #endif /* _LINUX_MODULE_H */
diff --git a/include/linux/mpi.h b/include/linux/mpi.h
index 5af1b81def49..641b7d6fd096 100644
--- a/include/linux/mpi.h
+++ b/include/linux/mpi.h
@@ -81,6 +81,8 @@ MPI mpi_read_from_buffer(const void *buffer, unsigned *ret_nread);
 int mpi_fromstr(MPI val, const char *str);
 u32 mpi_get_keyid(MPI a, u32 *keyid);
 void *mpi_get_buffer(MPI a, unsigned *nbytes, int *sign);
+int mpi_read_buffer(MPI a, uint8_t *buf, unsigned buf_len, unsigned *nbytes,
+                    int *sign);
 void *mpi_get_secure_buffer(MPI a, unsigned *nbytes, int *sign);
 int mpi_set_buffer(MPI a, const void *buffer, unsigned nbytes, int sign);
 
@@ -142,4 +144,17 @@ int mpi_rshift(MPI x, MPI a, unsigned n);
 /*-- mpi-inv.c --*/
 int mpi_invm(MPI x, MPI u, MPI v);
 
+/* inline functions */
+
+/**
+ * mpi_get_size() - returns max size required to store the number
+ *
+ * @a:  A multi precision integer for which we want to allocate a bufer
+ *
+ * Return: size required to store the number
+ */
+static inline unsigned int mpi_get_size(MPI a)
+{
+        return a->nlimbs * BYTES_PER_MPI_LIMB;
+}
 #endif /*G10_MPI_H */
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..f25e2bdd188c 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);
 /*
@@ -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/namei.h b/include/linux/namei.h
index c8990779f0c3..d8c6334cd150 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -1,16 +1,15 @@
 #ifndef _LINUX_NAMEI_H
 #define _LINUX_NAMEI_H
 
-#include <linux/dcache.h>
-#include <linux/errno.h>
-#include <linux/linkage.h>
+#include <linux/kernel.h>
 #include <linux/path.h>
-
-struct vfsmount;
-struct nameidata;
+#include <linux/fcntl.h>
+#include <linux/errno.h>
 
 enum { MAX_NESTED_LINKS = 8 };
 
+#define MAXSYMLINKS 40
+
 /*
  * Type of the last component on LOOKUP_PARENT
  */
@@ -45,13 +44,29 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
 #define LOOKUP_ROOT             0x2000
 #define LOOKUP_EMPTY            0x4000
 
-extern int user_path_at(int, const char __user *, unsigned, struct path *);
 extern int user_path_at_empty(int, const char __user *, unsigned, struct path *, int *empty);
 
-#define user_path(name, path) user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW, path)
-#define user_lpath(name, path) user_path_at(AT_FDCWD, name, 0, path)
-#define user_path_dir(name, path) \
-        user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW | LOOKUP_DIRECTORY, path)
+static inline int user_path_at(int dfd, const char __user *name, unsigned flags,
+                 struct path *path)
+{
+        return user_path_at_empty(dfd, name, flags, path, NULL);
+}
+
+static inline int user_path(const char __user *name, struct path *path)
+{
+        return user_path_at_empty(AT_FDCWD, name, LOOKUP_FOLLOW, path, NULL);
+}
+
+static inline int user_lpath(const char __user *name, struct path *path)
+{
+        return user_path_at_empty(AT_FDCWD, name, 0, path, NULL);
+}
+
+static inline int user_path_dir(const char __user *name, struct path *path)
+{
+        return user_path_at_empty(AT_FDCWD, name,
+                                  LOOKUP_FOLLOW | LOOKUP_DIRECTORY, path, NULL);
+}
 
 extern int kern_path(const char *, unsigned, struct path *);
 
@@ -70,9 +85,7 @@ extern int follow_up(struct path *);
 extern struct dentry *lock_rename(struct dentry *, struct dentry *);
 extern void unlock_rename(struct dentry *, struct dentry *);
 
-extern void nd_jump_link(struct nameidata *nd, struct path *path);
-extern void nd_set_link(struct nameidata *nd, char *path);
-extern char *nd_get_link(struct nameidata *nd);
+extern void nd_jump_link(struct path *path);
 
 static inline void nd_terminate_link(void *name, size_t len, size_t maxlen)
 {
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/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/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/nx842.h b/include/linux/nx842.h
deleted file mode 100644
index a4d324c6406a..000000000000
--- a/include/linux/nx842.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef __NX842_H__
-#define __NX842_H__
-
-int nx842_get_workmem_size(void);
-int nx842_get_workmem_size_aligned(void);
-int nx842_compress(const unsigned char *in, unsigned int in_len,
-                unsigned char *out, unsigned int *out_len, void *wrkmem);
-int nx842_decompress(const unsigned char *in, unsigned int in_len,
-                unsigned char *out, unsigned int *out_len, void *wrkmem);
-
-#endif
diff --git a/include/linux/of.h b/include/linux/of.h
index ddeaae6d2083..b871ff9d81d7 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -121,6 +121,8 @@ extern struct device_node *of_stdout;
 extern raw_spinlock_t devtree_lock;
 
 #ifdef CONFIG_OF
+void of_core_init(void);
+
 static inline bool is_of_node(struct fwnode_handle *fwnode)
 {
         return fwnode && fwnode->type == FWNODE_OF;
@@ -376,6 +378,10 @@ bool of_console_check(struct device_node *dn, char *name, int index);
 
 #else /* CONFIG_OF */
 
+static inline void of_core_init(void)
+{
+}
+
 static inline bool is_of_node(struct fwnode_handle *fwnode)
 {
         return false;
diff --git a/include/linux/of_fdt.h b/include/linux/of_fdt.h
index 587ee507965d..fd627a58068f 100644
--- a/include/linux/of_fdt.h
+++ b/include/linux/of_fdt.h
@@ -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/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/osq_lock.h b/include/linux/osq_lock.h
index 3a6490e81b28..703ea5c30a33 100644
--- a/include/linux/osq_lock.h
+++ b/include/linux/osq_lock.h
@@ -32,4 +32,9 @@ static inline void osq_lock_init(struct optimistic_spin_queue *lock)
 extern bool osq_lock(struct optimistic_spin_queue *lock);
 extern void osq_unlock(struct optimistic_spin_queue *lock);
 
+static inline bool osq_is_locked(struct optimistic_spin_queue *lock)
+{
+        return atomic_read(&lock->tail) != OSQ_UNLOCKED_VAL;
+}
+
 #endif
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 4b3736f7065c..fb0814ca65c7 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);
 
 /*
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 353db8dc4c6e..8a0321a8fb59 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -355,6 +355,7 @@ struct pci_dev {
         unsigned int    broken_intx_masking:1;
         unsigned int    io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
         unsigned int    irq_managed:1;
+        unsigned int    has_secondary_link:1;
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
@@ -577,9 +578,15 @@ int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
 int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
                   int reg, int len, u32 val);
 
+#ifdef CONFIG_PCI_BUS_ADDR_T_64BIT
+typedef u64 pci_bus_addr_t;
+#else
+typedef u32 pci_bus_addr_t;
+#endif
+
 struct pci_bus_region {
-        dma_addr_t start;
-        dma_addr_t end;
+        pci_bus_addr_t start;
+        pci_bus_addr_t end;
 };
 
 struct pci_dynids {
@@ -773,8 +780,6 @@ void pcibios_bus_to_resource(struct pci_bus *bus, struct resource *res,
 void pcibios_scan_specific_bus(int busn);
 struct pci_bus *pci_find_bus(int domain, int busnr);
 void pci_bus_add_devices(const struct pci_bus *bus);
-struct pci_bus *pci_scan_bus_parented(struct device *parent, int bus,
-                                      struct pci_ops *ops, void *sysdata);
 struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata);
 struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
                                     struct pci_ops *ops, void *sysdata,
@@ -974,7 +979,6 @@ void pci_intx(struct pci_dev *dev, int enable);
 bool pci_intx_mask_supported(struct pci_dev *dev);
 bool pci_check_and_mask_intx(struct pci_dev *dev);
 bool pci_check_and_unmask_intx(struct pci_dev *dev);
-void pci_msi_off(struct pci_dev *dev);
 int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size);
 int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask);
 int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask);
@@ -1006,6 +1010,7 @@ int __must_check pci_assign_resource(struct pci_dev *dev, int i);
 int __must_check pci_reassign_resource(struct pci_dev *dev, int i, resource_size_t add_size, resource_size_t align);
 int pci_select_bars(struct pci_dev *dev, unsigned long flags);
 bool pci_device_is_present(struct pci_dev *pdev);
+void pci_ignore_hotplug(struct pci_dev *dev);
 
 /* ROM control related routines */
 int pci_enable_rom(struct pci_dev *pdev);
@@ -1043,11 +1048,6 @@ bool pci_dev_run_wake(struct pci_dev *dev);
 bool pci_check_pme_status(struct pci_dev *dev);
 void pci_pme_wakeup_bus(struct pci_bus *bus);
 
-static inline void pci_ignore_hotplug(struct pci_dev *dev)
-{
-        dev->ignore_hotplug = 1;
-}
-
 static inline int pci_enable_wake(struct pci_dev *dev, pci_power_t state,
                                   bool enable)
 {
@@ -1128,7 +1128,7 @@ int __must_check pci_bus_alloc_resource(struct pci_bus *bus,
 
 int pci_remap_iospace(const struct resource *res, phys_addr_t phys_addr);
 
-static inline dma_addr_t pci_bus_address(struct pci_dev *pdev, int bar)
+static inline pci_bus_addr_t pci_bus_address(struct pci_dev *pdev, int bar)
 {
         struct pci_bus_region region;
 
@@ -1197,15 +1197,6 @@ int pci_set_vga_state(struct pci_dev *pdev, bool decode,
 #define pci_pool_alloc(pool, flags, handle) dma_pool_alloc(pool, flags, handle)
 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
 
-enum pci_dma_burst_strategy {
-        PCI_DMA_BURST_INFINITY, /* make bursts as large as possible,
-                                   strategy_parameter is N/A */
-        PCI_DMA_BURST_BOUNDARY, /* disconnect at every strategy_parameter
-                                   byte boundaries */
-        PCI_DMA_BURST_MULTIPLE, /* disconnect at some multiple of
-                                   strategy_parameter byte boundaries */
-};
-
 struct msix_entry {
         u32     vector; /* kernel uses to write allocated vector */
         u16     entry;  /* driver uses to specify entry, OS writes */
@@ -1430,8 +1421,6 @@ static inline int pci_request_regions(struct pci_dev *dev, const char *res_name)
 { return -EIO; }
 static inline void pci_release_regions(struct pci_dev *dev) { }
 
-#define pci_dma_burst_advice(pdev, strat, strategy_parameter) do { } while (0)
-
 static inline void pci_block_cfg_access(struct pci_dev *dev) { }
 static inline int pci_block_cfg_access_in_atomic(struct pci_dev *dev)
 { return 0; }
@@ -1905,4 +1894,15 @@ static inline bool pci_is_dev_assigned(struct pci_dev *pdev)
 {
         return (pdev->dev_flags & PCI_DEV_FLAGS_ASSIGNED) == PCI_DEV_FLAGS_ASSIGNED;
 }
+
+/**
+ * pci_ari_enabled - query ARI forwarding status
+ * @bus: the PCI bus
+ *
+ * Returns true if ARI forwarding is enabled.
+ */
+static inline bool pci_ari_enabled(struct pci_bus *bus)
+{
+        return bus->self && bus->self->ari_enabled;
+}
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 2f7b9a40f627..fcff8f865341 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -579,6 +579,7 @@
 #define PCI_DEVICE_ID_AMD_HUDSON2_SATA_IDE      0x7800
 #define PCI_DEVICE_ID_AMD_HUDSON2_SMBUS         0x780b
 #define PCI_DEVICE_ID_AMD_HUDSON2_IDE           0x780c
+#define PCI_DEVICE_ID_AMD_KERNCZ_SMBUS  0x790b
 
 #define PCI_VENDOR_ID_TRIDENT           0x1023
 #define PCI_DEVICE_ID_TRIDENT_4DWAVE_DX 0x2000
@@ -2329,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 61992cf2e977..1b82d44b0a02 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -92,8 +92,6 @@ struct hw_perf_event_extra {
         int             idx;    /* index in shared_regs->regs[] */
 };
 
-struct event_constraint;
-
 /**
  * struct hw_perf_event - performance event hardware details:
  */
@@ -112,8 +110,6 @@ struct hw_perf_event {
 
                         struct hw_perf_event_extra extra_reg;
                         struct hw_perf_event_extra branch_reg;
-
-                        struct event_constraint *constraint;
                 };
                 struct { /* software */
                         struct hrtimer  hrtimer;
@@ -124,7 +120,7 @@ struct hw_perf_event {
                 };
                 struct { /* intel_cqm */
                         int                     cqm_state;
-                        int                     cqm_rmid;
+                        u32                     cqm_rmid;
                         struct list_head        cqm_events_entry;
                         struct list_head        cqm_groups_entry;
                         struct list_head        cqm_group_entry;
@@ -566,8 +562,12 @@ struct perf_cpu_context {
         struct perf_event_context       *task_ctx;
         int                             active_oncpu;
         int                             exclusive;
+
+        raw_spinlock_t                  hrtimer_lock;
         struct hrtimer                  hrtimer;
         ktime_t                         hrtimer_interval;
+        unsigned int                    hrtimer_active;
+
         struct pmu                      *unique_pmu;
         struct perf_cgroup              *cgrp;
 };
@@ -734,6 +734,22 @@ extern int perf_event_overflow(struct perf_event *event,
                                  struct perf_sample_data *data,
                                  struct pt_regs *regs);
 
+extern void perf_event_output(struct perf_event *event,
+                                struct perf_sample_data *data,
+                                struct pt_regs *regs);
+
+extern void
+perf_event_header__init_id(struct perf_event_header *header,
+                           struct perf_sample_data *data,
+                           struct perf_event *event);
+extern void
+perf_event__output_id_sample(struct perf_event *event,
+                             struct perf_output_handle *handle,
+                             struct perf_sample_data *sample);
+
+extern void
+perf_log_lost_samples(struct perf_event *event, u64 lost);
+
 static inline bool is_sampling_event(struct perf_event *event)
 {
         return event->attr.sample_period != 0;
@@ -798,11 +814,33 @@ perf_sw_event_sched(u32 event_id, u64 nr, u64 addr)
 
 extern struct static_key_deferred perf_sched_events;
 
+static __always_inline bool
+perf_sw_migrate_enabled(void)
+{
+        if (static_key_false(&perf_swevent_enabled[PERF_COUNT_SW_CPU_MIGRATIONS]))
+                return true;
+        return false;
+}
+
+static inline void perf_event_task_migrate(struct task_struct *task)
+{
+        if (perf_sw_migrate_enabled())
+                task->sched_migrated = 1;
+}
+
 static inline void perf_event_task_sched_in(struct task_struct *prev,
                                             struct task_struct *task)
 {
         if (static_key_false(&perf_sched_events.key))
                 __perf_event_task_sched_in(prev, task);
+
+        if (perf_sw_migrate_enabled() && task->sched_migrated) {
+                struct pt_regs *regs = this_cpu_ptr(&__perf_regs[0]);
+
+                perf_fetch_caller_regs(regs);
+                ___perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, regs, 0);
+                task->sched_migrated = 0;
+        }
 }
 
 static inline void perf_event_task_sched_out(struct task_struct *prev,
@@ -925,6 +963,8 @@ perf_aux_output_skip(struct perf_output_handle *handle,
 static inline void *
 perf_get_aux(struct perf_output_handle *handle)                         { return NULL; }
 static inline void
+perf_event_task_migrate(struct task_struct *task)                       { }
+static inline void
 perf_event_task_sched_in(struct task_struct *prev,
                          struct task_struct *task)                      { }
 static inline void
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/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/gpio-omap.h b/include/linux/platform_data/gpio-omap.h
index 5d50b25a73d7..cb2618147c34 100644
--- a/include/linux/platform_data/gpio-omap.h
+++ b/include/linux/platform_data/gpio-omap.h
@@ -208,9 +208,17 @@ struct omap_gpio_platform_data {
         int (*get_context_loss_count)(struct device *dev);
 };
 
+#if IS_BUILTIN(CONFIG_GPIO_OMAP)
 extern void omap2_gpio_prepare_for_idle(int off_mode);
 extern void omap2_gpio_resume_after_idle(void);
-extern void omap_set_gpio_debounce(int gpio, int enable);
-extern void omap_set_gpio_debounce_time(int gpio, int enable);
+#else
+static inline void omap2_gpio_prepare_for_idle(int off_mode)
+{
+}
+
+static inline void omap2_gpio_resume_after_idle(void)
+{
+}
+#endif
 
 #endif
diff --git a/include/linux/platform_data/irq-renesas-irqc.h b/include/linux/platform_data/irq-renesas-irqc.h
deleted file mode 100644
index 3ae17b3e00ed..000000000000
--- a/include/linux/platform_data/irq-renesas-irqc.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Renesas IRQC Driver
- *
- *  Copyright (C) 2013 Magnus Damm
- *
- * 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
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#ifndef __IRQ_RENESAS_IRQC_H__
-#define __IRQ_RENESAS_IRQC_H__
-
-struct renesas_irqc_config {
-        unsigned int irq_base;
-};
-
-#endif /* __IRQ_RENESAS_IRQC_H__ */
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/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/ntc_thermistor.h b/include/linux/platform_data/ntc_thermistor.h
index 0a6de4ca4930..aed170588b74 100644
--- a/include/linux/platform_data/ntc_thermistor.h
+++ b/include/linux/platform_data/ntc_thermistor.h
@@ -27,6 +27,7 @@ enum ntc_thermistor_type {
         TYPE_NCPXXWB473,
         TYPE_NCPXXWL333,
         TYPE_B57330V2103,
+        TYPE_NCPXXWF104,
 };
 
 struct ntc_thermistor_platform_data {
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/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/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/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 de83b4eb1642..0f1534acaf60 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -10,13 +10,117 @@
 #include <linux/list.h>
 
 /*
- * We use the MSB mostly because its available; see <linux/preempt_mask.h> for
- * the other bits -- can't include that header due to inclusion hell.
+ * We put the hardirq and softirq counter into the preemption
+ * counter. The bitmask has the following meaning:
+ *
+ * - bits 0-7 are the preemption count (max preemption depth: 256)
+ * - bits 8-15 are the softirq count (max # of softirqs: 256)
+ *
+ * The hardirq count could in theory be the same as the number of
+ * interrupts in the system, but we run all interrupt handlers with
+ * interrupts disabled, so we cannot have nesting interrupts. Though
+ * there are a few palaeontologic drivers which reenable interrupts in
+ * the handler, so we need more than one bit here.
+ *
+ *         PREEMPT_MASK:        0x000000ff
+ *         SOFTIRQ_MASK:        0x0000ff00
+ *         HARDIRQ_MASK:        0x000f0000
+ *             NMI_MASK:        0x00100000
+ *       PREEMPT_ACTIVE:        0x00200000
+ * PREEMPT_NEED_RESCHED:        0x80000000
  */
+#define PREEMPT_BITS    8
+#define SOFTIRQ_BITS    8
+#define HARDIRQ_BITS    4
+#define NMI_BITS        1
+
+#define PREEMPT_SHIFT   0
+#define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)
+#define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
+#define NMI_SHIFT       (HARDIRQ_SHIFT + HARDIRQ_BITS)
+
+#define __IRQ_MASK(x)   ((1UL << (x))-1)
+
+#define PREEMPT_MASK    (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
+#define SOFTIRQ_MASK    (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
+#define HARDIRQ_MASK    (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
+#define NMI_MASK        (__IRQ_MASK(NMI_BITS)     << NMI_SHIFT)
+
+#define PREEMPT_OFFSET  (1UL << PREEMPT_SHIFT)
+#define SOFTIRQ_OFFSET  (1UL << SOFTIRQ_SHIFT)
+#define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
+#define NMI_OFFSET      (1UL << NMI_SHIFT)
+
+#define SOFTIRQ_DISABLE_OFFSET  (2 * SOFTIRQ_OFFSET)
+
+#define PREEMPT_ACTIVE_BITS     1
+#define PREEMPT_ACTIVE_SHIFT    (NMI_SHIFT + NMI_BITS)
+#define PREEMPT_ACTIVE  (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)
+
+/* We use the MSB mostly because its available */
 #define PREEMPT_NEED_RESCHED    0x80000000
 
+/* preempt_count() and related functions, depends on PREEMPT_NEED_RESCHED */
 #include <asm/preempt.h>
 
+#define hardirq_count() (preempt_count() & HARDIRQ_MASK)
+#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
+#define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
+                                 | NMI_MASK))
+
+/*
+ * Are we doing bottom half or hardware interrupt processing?
+ * Are we in a softirq context? Interrupt context?
+ * in_softirq - Are we currently processing softirq or have bh disabled?
+ * in_serving_softirq - Are we currently processing softirq?
+ */
+#define in_irq()                (hardirq_count())
+#define in_softirq()            (softirq_count())
+#define in_interrupt()          (irq_count())
+#define in_serving_softirq()    (softirq_count() & SOFTIRQ_OFFSET)
+
+/*
+ * Are we in NMI context?
+ */
+#define in_nmi()        (preempt_count() & NMI_MASK)
+
+#if defined(CONFIG_PREEMPT_COUNT)
+# define PREEMPT_DISABLE_OFFSET 1
+#else
+# define PREEMPT_DISABLE_OFFSET 0
+#endif
+
+/*
+ * The preempt_count offset needed for things like:
+ *
+ *  spin_lock_bh()
+ *
+ * Which need to disable both preemption (CONFIG_PREEMPT_COUNT) and
+ * softirqs, such that unlock sequences of:
+ *
+ *  spin_unlock();
+ *  local_bh_enable();
+ *
+ * Work as expected.
+ */
+#define SOFTIRQ_LOCK_OFFSET (SOFTIRQ_DISABLE_OFFSET + PREEMPT_DISABLE_OFFSET)
+
+/*
+ * Are we running in atomic context?  WARNING: this macro cannot
+ * always detect atomic context; in particular, it cannot know about
+ * held spinlocks in non-preemptible kernels.  Thus it should not be
+ * used in the general case to determine whether sleeping is possible.
+ * Do not use in_atomic() in driver code.
+ */
+#define in_atomic()     (preempt_count() != 0)
+
+/*
+ * Check whether we were atomic before we did preempt_disable():
+ * (used by the scheduler)
+ */
+#define in_atomic_preempt_off() \
+                ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_DISABLE_OFFSET)
+
 #if defined(CONFIG_DEBUG_PREEMPT) || defined(CONFIG_PREEMPT_TRACER)
 extern void preempt_count_add(int val);
 extern void preempt_count_sub(int val);
@@ -33,6 +137,18 @@ extern void preempt_count_sub(int val);
 #define preempt_count_inc() preempt_count_add(1)
 #define preempt_count_dec() preempt_count_sub(1)
 
+#define preempt_active_enter() \
+do { \
+        preempt_count_add(PREEMPT_ACTIVE + PREEMPT_DISABLE_OFFSET); \
+        barrier(); \
+} while (0)
+
+#define preempt_active_exit() \
+do { \
+        barrier(); \
+        preempt_count_sub(PREEMPT_ACTIVE + PREEMPT_DISABLE_OFFSET); \
+} while (0)
+
 #ifdef CONFIG_PREEMPT_COUNT
 
 #define preempt_disable() \
@@ -49,6 +165,8 @@ do { \
 
 #define preempt_enable_no_resched() sched_preempt_enable_no_resched()
 
+#define preemptible()   (preempt_count() == 0 && !irqs_disabled())
+
 #ifdef CONFIG_PREEMPT
 #define preempt_enable() \
 do { \
@@ -57,52 +175,46 @@ do { \
                 __preempt_schedule(); \
 } while (0)
 
+#define preempt_enable_notrace() \
+do { \
+        barrier(); \
+        if (unlikely(__preempt_count_dec_and_test())) \
+                __preempt_schedule_notrace(); \
+} while (0)
+
 #define preempt_check_resched() \
 do { \
         if (should_resched()) \
                 __preempt_schedule(); \
 } while (0)
 
-#else
+#else /* !CONFIG_PREEMPT */
 #define preempt_enable() \
 do { \
         barrier(); \
         preempt_count_dec(); \
 } while (0)
-#define preempt_check_resched() do { } while (0)
-#endif
-
-#define preempt_disable_notrace() \
-do { \
-        __preempt_count_inc(); \
-        barrier(); \
-} while (0)
 
-#define preempt_enable_no_resched_notrace() \
+#define preempt_enable_notrace() \
 do { \
         barrier(); \
         __preempt_count_dec(); \
 } while (0)
 
-#ifdef CONFIG_PREEMPT
-
-#ifndef CONFIG_CONTEXT_TRACKING
-#define __preempt_schedule_context() __preempt_schedule()
-#endif
+#define preempt_check_resched() do { } while (0)
+#endif /* CONFIG_PREEMPT */
 
-#define preempt_enable_notrace() \
+#define preempt_disable_notrace() \
 do { \
+        __preempt_count_inc(); \
         barrier(); \
-        if (unlikely(__preempt_count_dec_and_test())) \
-                __preempt_schedule_context(); \
 } while (0)
-#else
-#define preempt_enable_notrace() \
+
+#define preempt_enable_no_resched_notrace() \
 do { \
         barrier(); \
         __preempt_count_dec(); \
 } while (0)
-#endif
 
 #else /* !CONFIG_PREEMPT_COUNT */
 
@@ -121,6 +233,7 @@ do { \
 #define preempt_disable_notrace()               barrier()
 #define preempt_enable_no_resched_notrace()     barrier()
 #define preempt_enable_notrace()                barrier()
+#define preemptible()                           0
 
 #endif /* CONFIG_PREEMPT_COUNT */
 
diff --git a/include/linux/preempt_mask.h b/include/linux/preempt_mask.h
deleted file mode 100644
index dbeec4d4a3be..000000000000
--- a/include/linux/preempt_mask.h
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef LINUX_PREEMPT_MASK_H
-#define LINUX_PREEMPT_MASK_H
-
-#include <linux/preempt.h>
-
-/*
- * We put the hardirq and softirq counter into the preemption
- * counter. The bitmask has the following meaning:
- *
- * - bits 0-7 are the preemption count (max preemption depth: 256)
- * - bits 8-15 are the softirq count (max # of softirqs: 256)
- *
- * The hardirq count could in theory be the same as the number of
- * interrupts in the system, but we run all interrupt handlers with
- * interrupts disabled, so we cannot have nesting interrupts. Though
- * there are a few palaeontologic drivers which reenable interrupts in
- * the handler, so we need more than one bit here.
- *
- * PREEMPT_MASK:        0x000000ff
- * SOFTIRQ_MASK:        0x0000ff00
- * HARDIRQ_MASK:        0x000f0000
- *     NMI_MASK:        0x00100000
- * PREEMPT_ACTIVE:      0x00200000
- */
-#define PREEMPT_BITS    8
-#define SOFTIRQ_BITS    8
-#define HARDIRQ_BITS    4
-#define NMI_BITS        1
-
-#define PREEMPT_SHIFT   0
-#define SOFTIRQ_SHIFT   (PREEMPT_SHIFT + PREEMPT_BITS)
-#define HARDIRQ_SHIFT   (SOFTIRQ_SHIFT + SOFTIRQ_BITS)
-#define NMI_SHIFT       (HARDIRQ_SHIFT + HARDIRQ_BITS)
-
-#define __IRQ_MASK(x)   ((1UL << (x))-1)
-
-#define PREEMPT_MASK    (__IRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
-#define SOFTIRQ_MASK    (__IRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
-#define HARDIRQ_MASK    (__IRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
-#define NMI_MASK        (__IRQ_MASK(NMI_BITS)     << NMI_SHIFT)
-
-#define PREEMPT_OFFSET  (1UL << PREEMPT_SHIFT)
-#define SOFTIRQ_OFFSET  (1UL << SOFTIRQ_SHIFT)
-#define HARDIRQ_OFFSET  (1UL << HARDIRQ_SHIFT)
-#define NMI_OFFSET      (1UL << NMI_SHIFT)
-
-#define SOFTIRQ_DISABLE_OFFSET  (2 * SOFTIRQ_OFFSET)
-
-#define PREEMPT_ACTIVE_BITS     1
-#define PREEMPT_ACTIVE_SHIFT    (NMI_SHIFT + NMI_BITS)
-#define PREEMPT_ACTIVE  (__IRQ_MASK(PREEMPT_ACTIVE_BITS) << PREEMPT_ACTIVE_SHIFT)
-
-#define hardirq_count() (preempt_count() & HARDIRQ_MASK)
-#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
-#define irq_count()     (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK \
-                                 | NMI_MASK))
-
-/*
- * Are we doing bottom half or hardware interrupt processing?
- * Are we in a softirq context? Interrupt context?
- * in_softirq - Are we currently processing softirq or have bh disabled?
- * in_serving_softirq - Are we currently processing softirq?
- */
-#define in_irq()                (hardirq_count())
-#define in_softirq()            (softirq_count())
-#define in_interrupt()          (irq_count())
-#define in_serving_softirq()    (softirq_count() & SOFTIRQ_OFFSET)
-
-/*
- * Are we in NMI context?
- */
-#define in_nmi()        (preempt_count() & NMI_MASK)
-
-#if defined(CONFIG_PREEMPT_COUNT)
-# define PREEMPT_CHECK_OFFSET 1
-#else
-# define PREEMPT_CHECK_OFFSET 0
-#endif
-
-/*
- * The preempt_count offset needed for things like:
- *
- *  spin_lock_bh()
- *
- * Which need to disable both preemption (CONFIG_PREEMPT_COUNT) and
- * softirqs, such that unlock sequences of:
- *
- *  spin_unlock();
- *  local_bh_enable();
- *
- * Work as expected.
- */
-#define SOFTIRQ_LOCK_OFFSET (SOFTIRQ_DISABLE_OFFSET + PREEMPT_CHECK_OFFSET)
-
-/*
- * Are we running in atomic context?  WARNING: this macro cannot
- * always detect atomic context; in particular, it cannot know about
- * held spinlocks in non-preemptible kernels.  Thus it should not be
- * used in the general case to determine whether sleeping is possible.
- * Do not use in_atomic() in driver code.
- */
-#define in_atomic()     ((preempt_count() & ~PREEMPT_ACTIVE) != 0)
-
-/*
- * Check whether we were atomic before we did preempt_disable():
- * (used by the scheduler, *after* releasing the kernel lock)
- */
-#define in_atomic_preempt_off() \
-                ((preempt_count() & ~PREEMPT_ACTIVE) != PREEMPT_CHECK_OFFSET)
-
-#ifdef CONFIG_PREEMPT_COUNT
-# define preemptible()  (preempt_count() == 0 && !irqs_disabled())
-#else
-# define preemptible()  0
-#endif
-
-#endif /* LINUX_PREEMPT_MASK_H */
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/pwm.h b/include/linux/pwm.h
index e90628cac8fa..36262d08a9da 100644
--- a/include/linux/pwm.h
+++ b/include/linux/pwm.h
@@ -182,6 +182,8 @@ struct pwm_chip {
 int pwm_set_chip_data(struct pwm_device *pwm, void *data);
 void *pwm_get_chip_data(struct pwm_device *pwm);
 
+int pwmchip_add_with_polarity(struct pwm_chip *chip,
+                              enum pwm_polarity polarity);
 int pwmchip_add(struct pwm_chip *chip);
 int pwmchip_remove(struct pwm_chip *chip);
 struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
@@ -217,6 +219,11 @@ static inline int pwmchip_add(struct pwm_chip *chip)
         return -EINVAL;
 }
 
+static inline int pwmchip_add_inversed(struct pwm_chip *chip)
+{
+        return -EINVAL;
+}
+
 static inline int pwmchip_remove(struct pwm_chip *chip)
 {
         return -EINVAL;
@@ -290,10 +297,15 @@ struct pwm_lookup {
 
 #if IS_ENABLED(CONFIG_PWM)
 void pwm_add_table(struct pwm_lookup *table, size_t num);
+void pwm_remove_table(struct pwm_lookup *table, size_t num);
 #else
 static inline void pwm_add_table(struct pwm_lookup *table, size_t num)
 {
 }
+
+static inline void pwm_remove_table(struct pwm_lookup *table, size_t num)
+{
+}
 #endif
 
 #ifdef CONFIG_PWM_SYSFS
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/random.h b/include/linux/random.h
index b05856e16b75..e651874df2c9 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -6,14 +6,23 @@
 #ifndef _LINUX_RANDOM_H
 #define _LINUX_RANDOM_H
 
+#include <linux/list.h>
 #include <uapi/linux/random.h>
 
+struct random_ready_callback {
+        struct list_head list;
+        void (*func)(struct random_ready_callback *rdy);
+        struct module *owner;
+};
+
 extern void add_device_randomness(const void *, unsigned int);
 extern void add_input_randomness(unsigned int type, unsigned int code,
                                  unsigned int value);
 extern void add_interrupt_randomness(int irq, int irq_flags);
 
 extern void get_random_bytes(void *buf, int nbytes);
+extern int add_random_ready_callback(struct random_ready_callback *rdy);
+extern void del_random_ready_callback(struct random_ready_callback *rdy);
 extern void get_random_bytes_arch(void *buf, int nbytes);
 void generate_random_uuid(unsigned char uuid_out[16]);
 extern int random_int_secret_init(void);
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index a18b16f1dc0e..17c6b1f84a77 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -29,8 +29,8 @@
  */
 static inline void INIT_LIST_HEAD_RCU(struct list_head *list)
 {
-        ACCESS_ONCE(list->next) = list;
-        ACCESS_ONCE(list->prev) = list;
+        WRITE_ONCE(list->next, list);
+        WRITE_ONCE(list->prev, list);
 }
 
 /*
@@ -288,7 +288,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
 #define list_first_or_null_rcu(ptr, type, member) \
 ({ \
         struct list_head *__ptr = (ptr); \
-        struct list_head *__next = ACCESS_ONCE(__ptr->next); \
+        struct list_head *__next = READ_ONCE(__ptr->next); \
         likely(__ptr != __next) ? list_entry_rcu(__next, type, member) : NULL; \
 })
 
@@ -549,8 +549,8 @@ static inline void hlist_add_behind_rcu(struct hlist_node *n,
  */
 #define hlist_for_each_entry_from_rcu(pos, member)                      \
         for (; pos;                                                     \
-             pos = hlist_entry_safe(rcu_dereference((pos)->member.next),\
-                        typeof(*(pos)), member))
+             pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \
+                        &(pos)->member)), typeof(*(pos)), member))
 
 #endif  /* __KERNEL__ */
 #endif
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 573a5afd5ed8..33a056bb886f 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -44,6 +44,8 @@
 #include <linux/debugobjects.h>
 #include <linux/bug.h>
 #include <linux/compiler.h>
+#include <linux/ktime.h>
+
 #include <asm/barrier.h>
 
 extern int rcu_expedited; /* for sysctl */
@@ -292,10 +294,6 @@ void rcu_sched_qs(void);
 void rcu_bh_qs(void);
 void rcu_check_callbacks(int user);
 struct notifier_block;
-void rcu_idle_enter(void);
-void rcu_idle_exit(void);
-void rcu_irq_enter(void);
-void rcu_irq_exit(void);
 int rcu_cpu_notify(struct notifier_block *self,
                    unsigned long action, void *hcpu);
 
@@ -364,8 +362,8 @@ extern struct srcu_struct tasks_rcu_exit_srcu;
 #define rcu_note_voluntary_context_switch(t) \
         do { \
                 rcu_all_qs(); \
-                if (ACCESS_ONCE((t)->rcu_tasks_holdout)) \
-                        ACCESS_ONCE((t)->rcu_tasks_holdout) = false; \
+                if (READ_ONCE((t)->rcu_tasks_holdout)) \
+                        WRITE_ONCE((t)->rcu_tasks_holdout, false); \
         } while (0)
 #else /* #ifdef CONFIG_TASKS_RCU */
 #define TASKS_RCU(x) do { } while (0)
@@ -609,7 +607,7 @@ static inline void rcu_preempt_sleep_check(void)
 
 #define __rcu_access_pointer(p, space) \
 ({ \
-        typeof(*p) *_________p1 = (typeof(*p) *__force)ACCESS_ONCE(p); \
+        typeof(*p) *_________p1 = (typeof(*p) *__force)READ_ONCE(p); \
         rcu_dereference_sparse(p, space); \
         ((typeof(*p) __force __kernel *)(_________p1)); \
 })
@@ -628,21 +626,6 @@ static inline void rcu_preempt_sleep_check(void)
         ((typeof(*p) __force __kernel *)(p)); \
 })
 
-#define __rcu_access_index(p, space) \
-({ \
-        typeof(p) _________p1 = ACCESS_ONCE(p); \
-        rcu_dereference_sparse(p, space); \
-        (_________p1); \
-})
-#define __rcu_dereference_index_check(p, c) \
-({ \
-        /* Dependency order vs. p above. */ \
-        typeof(p) _________p1 = lockless_dereference(p); \
-        rcu_lockdep_assert(c, \
-                           "suspicious rcu_dereference_index_check() usage"); \
-        (_________p1); \
-})
-
 /**
  * RCU_INITIALIZER() - statically initialize an RCU-protected global variable
  * @v: The value to statically initialize with.
@@ -659,7 +642,7 @@ static inline void rcu_preempt_sleep_check(void)
  */
 #define lockless_dereference(p) \
 ({ \
-        typeof(p) _________p1 = ACCESS_ONCE(p); \
+        typeof(p) _________p1 = READ_ONCE(p); \
         smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
         (_________p1); \
 })
@@ -702,7 +685,7 @@ static inline void rcu_preempt_sleep_check(void)
  * @p: The pointer to read
  *
  * Return the value of the specified RCU-protected pointer, but omit the
- * smp_read_barrier_depends() and keep the ACCESS_ONCE().  This is useful
+ * smp_read_barrier_depends() and keep the READ_ONCE().  This is useful
  * when the value of this pointer is accessed, but the pointer is not
  * dereferenced, for example, when testing an RCU-protected pointer against
  * NULL.  Although rcu_access_pointer() may also be used in cases where
@@ -787,47 +770,12 @@ static inline void rcu_preempt_sleep_check(void)
 #define rcu_dereference_raw_notrace(p) __rcu_dereference_check((p), 1, __rcu)
 
 /**
- * rcu_access_index() - fetch RCU index with no dereferencing
- * @p: The index to read
- *
- * Return the value of the specified RCU-protected index, but omit the
- * smp_read_barrier_depends() and keep the ACCESS_ONCE().  This is useful
- * when the value of this index is accessed, but the index is not
- * dereferenced, for example, when testing an RCU-protected index against
- * -1.  Although rcu_access_index() may also be used in cases where
- * update-side locks prevent the value of the index from changing, you
- * should instead use rcu_dereference_index_protected() for this use case.
- */
-#define rcu_access_index(p) __rcu_access_index((p), __rcu)
-
-/**
- * rcu_dereference_index_check() - rcu_dereference for indices with debug checking
- * @p: The pointer to read, prior to dereferencing
- * @c: The conditions under which the dereference will take place
- *
- * Similar to rcu_dereference_check(), but omits the sparse checking.
- * This allows rcu_dereference_index_check() to be used on integers,
- * which can then be used as array indices.  Attempting to use
- * rcu_dereference_check() on an integer will give compiler warnings
- * because the sparse address-space mechanism relies on dereferencing
- * the RCU-protected pointer.  Dereferencing integers is not something
- * that even gcc will put up with.
- *
- * Note that this function does not implicitly check for RCU read-side
- * critical sections.  If this function gains lots of uses, it might
- * make sense to provide versions for each flavor of RCU, but it does
- * not make sense as of early 2010.
- */
-#define rcu_dereference_index_check(p, c) \
-        __rcu_dereference_index_check((p), (c))
-
-/**
  * rcu_dereference_protected() - fetch RCU pointer when updates prevented
  * @p: The pointer to read, prior to dereferencing
  * @c: The conditions under which the dereference will take place
  *
  * Return the value of the specified RCU-protected pointer, but omit
- * both the smp_read_barrier_depends() and the ACCESS_ONCE().  This
+ * both the smp_read_barrier_depends() and the READ_ONCE().  This
  * is useful in cases where update-side locks prevent the value of the
  * pointer from changing.  Please note that this primitive does -not-
  * prevent the compiler from repeating this reference or combining it
@@ -1153,13 +1101,13 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
 #define kfree_rcu(ptr, rcu_head)                                        \
         __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
 
-#if defined(CONFIG_TINY_RCU) || defined(CONFIG_RCU_NOCB_CPU_ALL)
-static inline int rcu_needs_cpu(unsigned long *delta_jiffies)
+#ifdef CONFIG_TINY_RCU
+static inline int rcu_needs_cpu(u64 basemono, u64 *nextevt)
 {
-        *delta_jiffies = ULONG_MAX;
+        *nextevt = KTIME_MAX;
         return 0;
 }
-#endif /* #if defined(CONFIG_TINY_RCU) || defined(CONFIG_RCU_NOCB_CPU_ALL) */
+#endif /* #ifdef CONFIG_TINY_RCU */
 
 #if defined(CONFIG_RCU_NOCB_CPU_ALL)
 static inline bool rcu_is_nocb_cpu(int cpu) { return true; }
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index 937edaeb150d..3df6c1ec4e25 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -159,6 +159,22 @@ static inline void rcu_cpu_stall_reset(void)
 {
 }
 
+static inline void rcu_idle_enter(void)
+{
+}
+
+static inline void rcu_idle_exit(void)
+{
+}
+
+static inline void rcu_irq_enter(void)
+{
+}
+
+static inline void rcu_irq_exit(void)
+{
+}
+
 static inline void exit_rcu(void)
 {
 }
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index d2e583a6aaca..456879143f89 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -31,9 +31,7 @@
 #define __LINUX_RCUTREE_H
 
 void rcu_note_context_switch(void);
-#ifndef CONFIG_RCU_NOCB_CPU_ALL
-int rcu_needs_cpu(unsigned long *delta_jiffies);
-#endif /* #ifndef CONFIG_RCU_NOCB_CPU_ALL */
+int rcu_needs_cpu(u64 basem, u64 *nextevt);
 void rcu_cpu_stall_reset(void);
 
 /*
@@ -93,6 +91,11 @@ void rcu_force_quiescent_state(void);
 void rcu_bh_force_quiescent_state(void);
 void rcu_sched_force_quiescent_state(void);
 
+void rcu_idle_enter(void);
+void rcu_idle_exit(void);
+void rcu_irq_enter(void);
+void rcu_irq_exit(void);
+
 void exit_rcu(void);
 
 void rcu_scheduler_starting(void);
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/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/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 ed8f9e70df9b..50a8486c524b 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.
@@ -221,6 +246,7 @@ static inline void *sg_virt(struct scatterlist *sg)
 }
 
 int sg_nents(struct scatterlist *sg);
+int sg_nents_for_len(struct scatterlist *sg, u64 len);
 struct scatterlist *sg_next(struct scatterlist *);
 struct scatterlist *sg_last(struct scatterlist *s, unsigned int);
 void sg_init_table(struct scatterlist *, unsigned int);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 26a2e6122734..6633e83e608a 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -25,7 +25,7 @@ struct sched_param {
 #include <linux/errno.h>
 #include <linux/nodemask.h>
 #include <linux/mm_types.h>
-#include <linux/preempt_mask.h>
+#include <linux/preempt.h>
 
 #include <asm/page.h>
 #include <asm/ptrace.h>
@@ -132,6 +132,7 @@ struct fs_struct;
 struct perf_event_context;
 struct blk_plug;
 struct filename;
+struct nameidata;
 
 #define VMACACHE_BITS 2
 #define VMACACHE_SIZE (1U << VMACACHE_BITS)
@@ -173,7 +174,12 @@ extern unsigned long nr_iowait_cpu(int cpu);
 extern void get_iowait_load(unsigned long *nr_waiters, unsigned long *load);
 
 extern void calc_global_load(unsigned long ticks);
+
+#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
 extern void update_cpu_load_nohz(void);
+#else
+static inline void update_cpu_load_nohz(void) { }
+#endif
 
 extern unsigned long get_parent_ip(unsigned long addr);
 
@@ -213,9 +219,10 @@ print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
 #define TASK_WAKEKILL           128
 #define TASK_WAKING             256
 #define TASK_PARKED             512
-#define TASK_STATE_MAX          1024
+#define TASK_NOLOAD             1024
+#define TASK_STATE_MAX          2048
 
-#define TASK_STATE_TO_CHAR_STR "RSDTtXZxKWP"
+#define TASK_STATE_TO_CHAR_STR "RSDTtXZxKWPN"
 
 extern char ___assert_task_state[1 - 2*!!(
                 sizeof(TASK_STATE_TO_CHAR_STR)-1 != ilog2(TASK_STATE_MAX)+1)];
@@ -225,6 +232,8 @@ extern char ___assert_task_state[1 - 2*!!(
 #define TASK_STOPPED            (TASK_WAKEKILL | __TASK_STOPPED)
 #define TASK_TRACED             (TASK_WAKEKILL | __TASK_TRACED)
 
+#define TASK_IDLE               (TASK_UNINTERRUPTIBLE | TASK_NOLOAD)
+
 /* Convenience macros for the sake of wake_up */
 #define TASK_NORMAL             (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)
 #define TASK_ALL                (TASK_NORMAL | __TASK_STOPPED | __TASK_TRACED)
@@ -240,7 +249,8 @@ extern char ___assert_task_state[1 - 2*!!(
                         ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
 #define task_contributes_to_load(task)  \
                                 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
-                                 (task->flags & PF_FROZEN) == 0)
+                                 (task->flags & PF_FROZEN) == 0 && \
+                                 (task->state & TASK_NOLOAD) == 0)
 
 #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
 
@@ -252,7 +262,7 @@ extern char ___assert_task_state[1 - 2*!!(
 #define set_task_state(tsk, state_value)                        \
         do {                                                    \
                 (tsk)->task_state_change = _THIS_IP_;           \
-                set_mb((tsk)->state, (state_value));            \
+                smp_store_mb((tsk)->state, (state_value));              \
         } while (0)
 
 /*
@@ -274,7 +284,7 @@ extern char ___assert_task_state[1 - 2*!!(
 #define set_current_state(state_value)                          \
         do {                                                    \
                 current->task_state_change = _THIS_IP_;         \
-                set_mb(current->state, (state_value));          \
+                smp_store_mb(current->state, (state_value));            \
         } while (0)
 
 #else
@@ -282,7 +292,7 @@ extern char ___assert_task_state[1 - 2*!!(
 #define __set_task_state(tsk, state_value)              \
         do { (tsk)->state = (state_value); } while (0)
 #define set_task_state(tsk, state_value)                \
-        set_mb((tsk)->state, (state_value))
+        smp_store_mb((tsk)->state, (state_value))
 
 /*
  * set_current_state() includes a barrier so that the write of current->state
@@ -298,7 +308,7 @@ extern char ___assert_task_state[1 - 2*!!(
 #define __set_current_state(state_value)                \
         do { current->state = (state_value); } while (0)
 #define set_current_state(state_value)                  \
-        set_mb(current->state, (state_value))
+        smp_store_mb(current->state, (state_value))
 
 #endif
 
@@ -335,14 +345,10 @@ extern int runqueue_is_locked(int cpu);
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
 extern void nohz_balance_enter_idle(int cpu);
 extern void set_cpu_sd_state_idle(void);
-extern int get_nohz_timer_target(int pinned);
+extern int get_nohz_timer_target(void);
 #else
 static inline void nohz_balance_enter_idle(int cpu) { }
 static inline void set_cpu_sd_state_idle(void) { }
-static inline int get_nohz_timer_target(int pinned)
-{
-        return smp_processor_id();
-}
 #endif
 
 /*
@@ -567,6 +573,23 @@ struct task_cputime {
                 .sum_exec_runtime = 0,                          \
         }
 
+/*
+ * This is the atomic variant of task_cputime, which can be used for
+ * storing and updating task_cputime statistics without locking.
+ */
+struct task_cputime_atomic {
+        atomic64_t utime;
+        atomic64_t stime;
+        atomic64_t sum_exec_runtime;
+};
+
+#define INIT_CPUTIME_ATOMIC \
+        (struct task_cputime_atomic) {                          \
+                .utime = ATOMIC64_INIT(0),                      \
+                .stime = ATOMIC64_INIT(0),                      \
+                .sum_exec_runtime = ATOMIC64_INIT(0),           \
+        }
+
 #ifdef CONFIG_PREEMPT_COUNT
 #define PREEMPT_DISABLED        (1 + PREEMPT_ENABLED)
 #else
@@ -584,18 +607,16 @@ struct task_cputime {
 
 /**
  * struct thread_group_cputimer - thread group interval timer counts
- * @cputime:            thread group interval timers.
+ * @cputime_atomic:     atomic thread group interval timers.
  * @running:            non-zero when there are timers running and
  *                      @cputime receives updates.
- * @lock:               lock for fields in this struct.
  *
  * This structure contains the version of task_cputime, above, that is
  * used for thread group CPU timer calculations.
  */
 struct thread_group_cputimer {
-        struct task_cputime cputime;
+        struct task_cputime_atomic cputime_atomic;
         int running;
-        raw_spinlock_t lock;
 };
 
 #include <linux/rwsem.h>
@@ -900,6 +921,50 @@ enum cpu_idle_type {
 #define SCHED_CAPACITY_SCALE    (1L << SCHED_CAPACITY_SHIFT)
 
 /*
+ * Wake-queues are lists of tasks with a pending wakeup, whose
+ * callers have already marked the task as woken internally,
+ * and can thus carry on. A common use case is being able to
+ * do the wakeups once the corresponding user lock as been
+ * released.
+ *
+ * We hold reference to each task in the list across the wakeup,
+ * thus guaranteeing that the memory is still valid by the time
+ * the actual wakeups are performed in wake_up_q().
+ *
+ * One per task suffices, because there's never a need for a task to be
+ * in two wake queues simultaneously; it is forbidden to abandon a task
+ * in a wake queue (a call to wake_up_q() _must_ follow), so if a task is
+ * already in a wake queue, the wakeup will happen soon and the second
+ * waker can just skip it.
+ *
+ * The WAKE_Q macro declares and initializes the list head.
+ * wake_up_q() does NOT reinitialize the list; it's expected to be
+ * called near the end of a function, where the fact that the queue is
+ * not used again will be easy to see by inspection.
+ *
+ * Note that this can cause spurious wakeups. schedule() callers
+ * must ensure the call is done inside a loop, confirming that the
+ * wakeup condition has in fact occurred.
+ */
+struct wake_q_node {
+        struct wake_q_node *next;
+};
+
+struct wake_q_head {
+        struct wake_q_node *first;
+        struct wake_q_node **lastp;
+};
+
+#define WAKE_Q_TAIL ((struct wake_q_node *) 0x01)
+
+#define WAKE_Q(name)                                    \
+        struct wake_q_head name = { WAKE_Q_TAIL, &name.first }
+
+extern void wake_q_add(struct wake_q_head *head,
+                       struct task_struct *task);
+extern void wake_up_q(struct wake_q_head *head);
+
+/*
  * sched-domains (multiprocessor balancing) declarations:
  */
 #ifdef CONFIG_SMP
@@ -1334,8 +1399,6 @@ struct task_struct {
         int rcu_read_lock_nesting;
         union rcu_special rcu_read_unlock_special;
         struct list_head rcu_node_entry;
-#endif /* #ifdef CONFIG_PREEMPT_RCU */
-#ifdef CONFIG_PREEMPT_RCU
         struct rcu_node *rcu_blocked_node;
 #endif /* #ifdef CONFIG_PREEMPT_RCU */
 #ifdef CONFIG_TASKS_RCU
@@ -1356,9 +1419,6 @@ struct task_struct {
 #endif
 
         struct mm_struct *mm, *active_mm;
-#ifdef CONFIG_COMPAT_BRK
-        unsigned brk_randomized:1;
-#endif
         /* per-thread vma caching */
         u32 vmacache_seqnum;
         struct vm_area_struct *vmacache[VMACACHE_SIZE];
@@ -1369,7 +1429,7 @@ struct task_struct {
         int exit_state;
         int exit_code, exit_signal;
         int pdeath_signal;  /*  The signal sent when the parent dies  */
-        unsigned int jobctl;    /* JOBCTL_*, siglock protected */
+        unsigned long jobctl;   /* JOBCTL_*, siglock protected */
 
         /* Used for emulating ABI behavior of previous Linux versions */
         unsigned int personality;
@@ -1381,10 +1441,14 @@ struct task_struct {
         /* Revert to default priority/policy when forking */
         unsigned sched_reset_on_fork:1;
         unsigned sched_contributes_to_load:1;
+        unsigned sched_migrated:1;
 
 #ifdef CONFIG_MEMCG_KMEM
         unsigned memcg_kmem_skip_account:1;
 #endif
+#ifdef CONFIG_COMPAT_BRK
+        unsigned brk_randomized:1;
+#endif
 
         unsigned long atomic_flags; /* Flags needing atomic access. */
 
@@ -1461,7 +1525,7 @@ struct task_struct {
                                        it with task_lock())
                                      - initialized normally by setup_new_exec */
 /* file system info */
-        int link_count, total_link_count;
+        struct nameidata *nameidata;
 #ifdef CONFIG_SYSVIPC
 /* ipc stuff */
         struct sysv_sem sysvsem;
@@ -1511,6 +1575,8 @@ struct task_struct {
         /* Protection of the PI data structures: */
         raw_spinlock_t pi_lock;
 
+        struct wake_q_node wake_q;
+
 #ifdef CONFIG_RT_MUTEXES
         /* PI waiters blocked on a rt_mutex held by this task */
         struct rb_root pi_waiters;
@@ -1724,6 +1790,7 @@ struct task_struct {
 #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
         unsigned long   task_state_change;
 #endif
+        int pagefault_disabled;
 };
 
 /* Future-safe accessor for struct task_struct's cpus_allowed. */
@@ -2077,22 +2144,22 @@ TASK_PFA_CLEAR(SPREAD_SLAB, spread_slab)
 #define JOBCTL_TRAPPING_BIT     21      /* switching to TRACED */
 #define JOBCTL_LISTENING_BIT    22      /* ptracer is listening for events */
 
-#define JOBCTL_STOP_DEQUEUED    (1 << JOBCTL_STOP_DEQUEUED_BIT)
-#define JOBCTL_STOP_PENDING     (1 << JOBCTL_STOP_PENDING_BIT)
-#define JOBCTL_STOP_CONSUME     (1 << JOBCTL_STOP_CONSUME_BIT)
-#define JOBCTL_TRAP_STOP        (1 << JOBCTL_TRAP_STOP_BIT)
-#define JOBCTL_TRAP_NOTIFY      (1 << JOBCTL_TRAP_NOTIFY_BIT)
-#define JOBCTL_TRAPPING         (1 << JOBCTL_TRAPPING_BIT)
-#define JOBCTL_LISTENING        (1 << JOBCTL_LISTENING_BIT)
+#define JOBCTL_STOP_DEQUEUED    (1UL << JOBCTL_STOP_DEQUEUED_BIT)
+#define JOBCTL_STOP_PENDING     (1UL << JOBCTL_STOP_PENDING_BIT)
+#define JOBCTL_STOP_CONSUME     (1UL << JOBCTL_STOP_CONSUME_BIT)
+#define JOBCTL_TRAP_STOP        (1UL << JOBCTL_TRAP_STOP_BIT)
+#define JOBCTL_TRAP_NOTIFY      (1UL << JOBCTL_TRAP_NOTIFY_BIT)
+#define JOBCTL_TRAPPING         (1UL << JOBCTL_TRAPPING_BIT)
+#define JOBCTL_LISTENING        (1UL << JOBCTL_LISTENING_BIT)
 
 #define JOBCTL_TRAP_MASK        (JOBCTL_TRAP_STOP | JOBCTL_TRAP_NOTIFY)
 #define JOBCTL_PENDING_MASK     (JOBCTL_STOP_PENDING | JOBCTL_TRAP_MASK)
 
 extern bool task_set_jobctl_pending(struct task_struct *task,
-                                    unsigned int mask);
+                                    unsigned long mask);
 extern void task_clear_jobctl_trapping(struct task_struct *task);
 extern void task_clear_jobctl_pending(struct task_struct *task,
-                                      unsigned int mask);
+                                      unsigned long mask);
 
 static inline void rcu_copy_process(struct task_struct *p)
 {
@@ -2532,6 +2599,9 @@ static inline unsigned long wait_task_inactive(struct task_struct *p,
 }
 #endif
 
+#define tasklist_empty() \
+        list_empty(&init_task.tasks)
+
 #define next_task(p) \
         list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
 
@@ -2962,11 +3032,6 @@ static __always_inline bool need_resched(void)
 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
 void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
 
-static inline void thread_group_cputime_init(struct signal_struct *sig)
-{
-        raw_spin_lock_init(&sig->cputimer.lock);
-}
-
 /*
  * Reevaluate whether the task has signals pending delivery.
  * Wake the task if so.
@@ -3080,13 +3145,13 @@ static inline void mm_update_next_owner(struct mm_struct *mm)
 static inline unsigned long task_rlimit(const struct task_struct *tsk,
                 unsigned int limit)
 {
-        return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_cur);
+        return READ_ONCE(tsk->signal->rlim[limit].rlim_cur);
 }
 
 static inline unsigned long task_rlimit_max(const struct task_struct *tsk,
                 unsigned int limit)
 {
-        return ACCESS_ONCE(tsk->signal->rlim[limit].rlim_max);
+        return READ_ONCE(tsk->signal->rlim[limit].rlim_max);
 }
 
 static inline unsigned long rlimit(unsigned int limit)
diff --git a/include/linux/sched/sysctl.h b/include/linux/sched/sysctl.h
index 596a0e007c62..c9e4731cf10b 100644
--- a/include/linux/sched/sysctl.h
+++ b/include/linux/sched/sysctl.h
@@ -57,24 +57,12 @@ extern unsigned int sysctl_numa_balancing_scan_size;
 extern unsigned int sysctl_sched_migration_cost;
 extern unsigned int sysctl_sched_nr_migrate;
 extern unsigned int sysctl_sched_time_avg;
-extern unsigned int sysctl_timer_migration;
 extern unsigned int sysctl_sched_shares_window;
 
 int sched_proc_update_handler(struct ctl_table *table, int write,
                 void __user *buffer, size_t *length,
                 loff_t *ppos);
 #endif
-#ifdef CONFIG_SCHED_DEBUG
-static inline unsigned int get_sysctl_timer_migration(void)
-{
-        return sysctl_timer_migration;
-}
-#else
-static inline unsigned int get_sysctl_timer_migration(void)
-{
-        return 1;
-}
-#endif
 
 /*
  *  control realtime throttling:
diff --git a/include/linux/security.h b/include/linux/security.h
index 18264ea9e314..52febde52479 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -43,7 +43,6 @@ struct file;
 struct vfsmount;
 struct path;
 struct qstr;
-struct nameidata;
 struct iattr;
 struct fown_struct;
 struct file_operations;
@@ -477,7 +476,8 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  * @inode_follow_link:
  *      Check permission to follow a symbolic link when looking up a pathname.
  *      @dentry contains the dentry structure for the link.
- *      @nd contains the nameidata structure for the parent directory.
+ *      @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
@@ -1553,7 +1553,8 @@ struct security_operations {
         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 nameidata *nd);
+        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);
@@ -1839,7 +1840,8 @@ int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
                           struct inode *new_dir, struct dentry *new_dentry,
                           unsigned int flags);
 int security_inode_readlink(struct dentry *dentry);
-int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd);
+int security_inode_follow_link(struct dentry *dentry, struct inode *inode,
+                               bool rcu);
 int security_inode_permission(struct inode *inode, int mask);
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
 int security_inode_getattr(const struct path *path);
@@ -2242,7 +2244,8 @@ static inline int security_inode_readlink(struct dentry *dentry)
 }
 
 static inline int security_inode_follow_link(struct dentry *dentry,
-                                              struct nameidata *nd)
+                                             struct inode *inode,
+                                             bool rcu)
 {
         return 0;
 }
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index 5f68d0a391ce..486e685a226a 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -233,6 +233,47 @@ static inline void raw_write_seqcount_end(seqcount_t *s)
         s->sequence++;
 }
 
+/**
+ * raw_write_seqcount_barrier - do a seq write barrier
+ * @s: pointer to seqcount_t
+ *
+ * This can be used to provide an ordering guarantee instead of the
+ * usual consistency guarantee. It is one wmb cheaper, because we can
+ * collapse the two back-to-back wmb()s.
+ *
+ *      seqcount_t seq;
+ *      bool X = true, Y = false;
+ *
+ *      void read(void)
+ *      {
+ *              bool x, y;
+ *
+ *              do {
+ *                      int s = read_seqcount_begin(&seq);
+ *
+ *                      x = X; y = Y;
+ *
+ *              } while (read_seqcount_retry(&seq, s));
+ *
+ *              BUG_ON(!x && !y);
+ *      }
+ *
+ *      void write(void)
+ *      {
+ *              Y = true;
+ *
+ *              raw_write_seqcount_barrier(seq);
+ *
+ *              X = false;
+ *      }
+ */
+static inline void raw_write_seqcount_barrier(seqcount_t *s)
+{
+        s->sequence++;
+        smp_wmb();
+        s->sequence++;
+}
+
 /*
  * raw_write_seqcount_latch - redirect readers to even/odd copy
  * @s: pointer to seqcount_t
@@ -266,13 +307,13 @@ static inline void write_seqcount_end(seqcount_t *s)
 }
 
 /**
- * write_seqcount_barrier - invalidate in-progress read-side seq operations
+ * write_seqcount_invalidate - invalidate in-progress read-side seq operations
  * @s: pointer to seqcount_t
  *
- * After write_seqcount_barrier, no read-side seq operations will complete
+ * After write_seqcount_invalidate, no read-side seq operations will complete
  * successfully and see data older than this.
  */
-static inline void write_seqcount_barrier(seqcount_t *s)
+static inline void write_seqcount_invalidate(seqcount_t *s)
 {
         smp_wmb();
         s->sequence+=2;
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..9de2fdc8b5e4 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -153,8 +153,30 @@ size_t ksize(const void *);
 #define ARCH_KMALLOC_MINALIGN ARCH_DMA_MINALIGN
 #define KMALLOC_MIN_SIZE ARCH_DMA_MINALIGN
 #define KMALLOC_SHIFT_LOW ilog2(ARCH_DMA_MINALIGN)
+/*
+ * The KMALLOC_LOOP_LOW is the definition for the for loop index start number
+ * to create the kmalloc_caches object in create_kmalloc_caches(). The first
+ * and the second are 96 and 192. You can see that in the kmalloc_index(), if
+ * the KMALLOC_MIN_SIZE <= 32, then return 1 (96). If KMALLOC_MIN_SIZE <= 64,
+ * then return 2 (192). If the KMALLOC_MIN_SIZE is bigger than 64, we don't
+ * need to initialize 96 and 192. Go directly to start the KMALLOC_SHIFT_LOW.
+ */
+#if KMALLOC_MIN_SIZE <= 32
+#define KMALLOC_LOOP_LOW 1
+#elif KMALLOC_MIN_SIZE <= 64
+#define KMALLOC_LOOP_LOW 2
+#else
+#define KMALLOC_LOOP_LOW KMALLOC_SHIFT_LOW
+#endif
+
 #else
 #define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
+/*
+ * The KMALLOC_MIN_SIZE of slub/slab/slob is 2^3/2^5/2^3. So, even slab is used.
+ * The KMALLOC_MIN_SIZE <= 32. The kmalloc-96 and kmalloc-192 should also be
+ * initialized.
+ */
+#define KMALLOC_LOOP_LOW 1
 #endif
 
 /*
@@ -240,8 +262,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/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/spinlock.h b/include/linux/spinlock.h
index 3e18379dfa6f..0063b24b4f36 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -120,7 +120,7 @@ do {								\
 /*
  * Despite its name it doesn't necessarily has to be a full barrier.
  * It should only guarantee that a STORE before the critical section
- * can not be reordered with a LOAD inside this section.
+ * can not be reordered with LOADs and STOREs inside this section.
  * spin_lock() is the one-way barrier, this LOAD can not escape out
  * of the region. So the default implementation simply ensures that
  * a STORE can not move into the critical section, smp_wmb() should
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/sw842.h b/include/linux/sw842.h
new file mode 100644
index 000000000000..109ba041c2ae
--- /dev/null
+++ b/include/linux/sw842.h
@@ -0,0 +1,12 @@
+#ifndef __SW842_H__
+#define __SW842_H__
+
+#define SW842_MEM_COMPRESS      (0xf000)
+
+int sw842_compress(const u8 *src, unsigned int srclen,
+                   u8 *dst, unsigned int *destlen, void *wmem);
+
+int sw842_decompress(const u8 *src, unsigned int srclen,
+                     u8 *dst, unsigned int *destlen);
+
+#endif
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/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 f8492da57ad3..3741ba1a652c 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
@@ -134,6 +138,12 @@ static inline bool tick_nohz_full_cpu(int cpu)
         return cpumask_test_cpu(cpu, tick_nohz_full_mask);
 }
 
+static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask)
+{
+        if (tick_nohz_full_enabled())
+                cpumask_or(mask, mask, tick_nohz_full_mask);
+}
+
 extern void __tick_nohz_full_check(void);
 extern void tick_nohz_full_kick(void);
 extern void tick_nohz_full_kick_cpu(int cpu);
@@ -142,6 +152,7 @@ extern void __tick_nohz_task_switch(struct task_struct *tsk);
 #else
 static inline bool tick_nohz_full_enabled(void) { return false; }
 static inline bool tick_nohz_full_cpu(int cpu) { return false; }
+static inline void tick_nohz_full_add_cpus_to(struct cpumask *mask) { }
 static inline void __tick_nohz_full_check(void) { }
 static inline void tick_nohz_full_kick_cpu(int cpu) { }
 static inline void tick_nohz_full_kick(void) { }
diff --git a/include/linux/time64.h b/include/linux/time64.h
index a3831478d9cf..77b5df2acd2a 100644
--- a/include/linux/time64.h
+++ b/include/linux/time64.h
@@ -2,6 +2,7 @@
 #define _LINUX_TIME64_H
 
 #include <uapi/linux/time.h>
+#include <linux/math64.h>
 
 typedef __s64 time64_t;
 
@@ -28,6 +29,7 @@ struct timespec64 {
 #define FSEC_PER_SEC    1000000000000000LL
 
 /* Located here for timespec[64]_valid_strict */
+#define TIME64_MAX                      ((s64)~((u64)1 << 63))
 #define KTIME_MAX                       ((s64)~((u64)1 << 63))
 #define KTIME_SEC_MAX                   (KTIME_MAX / NSEC_PER_SEC)
 
diff --git a/include/linux/timekeeper_internal.h b/include/linux/timekeeper_internal.h
index fb86963859c7..25247220b4b7 100644
--- a/include/linux/timekeeper_internal.h
+++ b/include/linux/timekeeper_internal.h
@@ -49,6 +49,8 @@ struct tk_read_base {
  * @offs_boot:          Offset clock monotonic -> clock boottime
  * @offs_tai:           Offset clock monotonic -> clock tai
  * @tai_offset:         The current UTC to TAI offset in seconds
+ * @clock_was_set_seq:  The sequence number of clock was set events
+ * @next_leap_ktime:    CLOCK_MONOTONIC time value of a pending leap-second
  * @raw_time:           Monotonic raw base time in timespec64 format
  * @cycle_interval:     Number of clock cycles in one NTP interval
  * @xtime_interval:     Number of clock shifted nano seconds in one NTP
@@ -60,6 +62,9 @@ struct tk_read_base {
  *                      shifted nano seconds.
  * @ntp_error_shift:    Shift conversion between clock shifted nano seconds and
  *                      ntp shifted nano seconds.
+ * @last_warning:       Warning ratelimiter (DEBUG_TIMEKEEPING)
+ * @underflow_seen:     Underflow warning flag (DEBUG_TIMEKEEPING)
+ * @overflow_seen:      Overflow warning flag (DEBUG_TIMEKEEPING)
  *
  * Note: For timespec(64) based interfaces wall_to_monotonic is what
  * we need to add to xtime (or xtime corrected for sub jiffie times)
@@ -85,6 +90,8 @@ struct timekeeper {
         ktime_t                 offs_boot;
         ktime_t                 offs_tai;
         s32                     tai_offset;
+        unsigned int            clock_was_set_seq;
+        ktime_t                 next_leap_ktime;
         struct timespec64       raw_time;
 
         /* The following members are for timekeeping internal use */
@@ -104,6 +111,18 @@ struct timekeeper {
         s64                     ntp_error;
         u32                     ntp_error_shift;
         u32                     ntp_err_mult;
+#ifdef CONFIG_DEBUG_TIMEKEEPING
+        long                    last_warning;
+        /*
+         * These simple flag variables are managed
+         * without locks, which is racy, but they are
+         * ok since we don't really care about being
+         * super precise about how many events were
+         * seen, just that a problem was observed.
+         */
+        int                     underflow_seen;
+        int                     overflow_seen;
+#endif
 };
 
 #ifdef CONFIG_GENERIC_TIME_VSYSCALL
diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index 99176af216af..3aa72e648650 100644
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -163,6 +163,7 @@ extern ktime_t ktime_get(void);
 extern ktime_t ktime_get_with_offset(enum tk_offsets offs);
 extern ktime_t ktime_mono_to_any(ktime_t tmono, enum tk_offsets offs);
 extern ktime_t ktime_get_raw(void);
+extern u32 ktime_get_resolution_ns(void);
 
 /**
  * ktime_get_real - get the real (wall-) time in ktime_t format
@@ -266,7 +267,6 @@ extern int persistent_clock_is_local;
 
 extern void read_persistent_clock(struct timespec *ts);
 extern void read_persistent_clock64(struct timespec64 *ts);
-extern void read_boot_clock(struct timespec *ts);
 extern void read_boot_clock64(struct timespec64 *ts);
 extern int update_persistent_clock(struct timespec now);
 extern int update_persistent_clock64(struct timespec64 now);
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 8c5a197e1587..61aa61dc410c 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -14,27 +14,23 @@ struct timer_list {
          * All fields that change during normal runtime grouped to the
          * same cacheline
          */
-        struct list_head entry;
-        unsigned long expires;
-        struct tvec_base *base;
-
-        void (*function)(unsigned long);
-        unsigned long data;
-
-        int slack;
+        struct hlist_node       entry;
+        unsigned long           expires;
+        void                    (*function)(unsigned long);
+        unsigned long           data;
+        u32                     flags;
+        int                     slack;
 
 #ifdef CONFIG_TIMER_STATS
-        int start_pid;
-        void *start_site;
-        char start_comm[16];
+        int                     start_pid;
+        void                    *start_site;
+        char                    start_comm[16];
 #endif
 #ifdef CONFIG_LOCKDEP
-        struct lockdep_map lockdep_map;
+        struct lockdep_map      lockdep_map;
 #endif
 };
 
-extern struct tvec_base boot_tvec_bases;
-
 #ifdef CONFIG_LOCKDEP
 /*
  * NB: because we have to copy the lockdep_map, setting the lockdep_map key
@@ -49,9 +45,6 @@ extern struct tvec_base boot_tvec_bases;
 #endif
 
 /*
- * Note that all tvec_bases are at least 4 byte aligned and lower two bits
- * of base in timer_list is guaranteed to be zero. Use them for flags.
- *
  * A deferrable timer will work normally when the system is busy, but
  * will not cause a CPU to come out of idle just to service it; instead,
  * the timer will be serviced when the CPU eventually wakes up with a
@@ -65,17 +58,18 @@ extern struct tvec_base boot_tvec_bases;
  * workqueue locking issues. It's not meant for executing random crap
  * with interrupts disabled. Abuse is monitored!
  */
-#define TIMER_DEFERRABLE                0x1LU
-#define TIMER_IRQSAFE                   0x2LU
-
-#define TIMER_FLAG_MASK                 0x3LU
+#define TIMER_CPUMASK           0x0007FFFF
+#define TIMER_MIGRATING         0x00080000
+#define TIMER_BASEMASK          (TIMER_CPUMASK | TIMER_MIGRATING)
+#define TIMER_DEFERRABLE        0x00100000
+#define TIMER_IRQSAFE           0x00200000
 
 #define __TIMER_INITIALIZER(_function, _expires, _data, _flags) { \
-                .entry = { .prev = TIMER_ENTRY_STATIC },        \
+                .entry = { .next = TIMER_ENTRY_STATIC },        \
                 .function = (_function),                        \
                 .expires = (_expires),                          \
                 .data = (_data),                                \
-                .base = (void *)((unsigned long)&boot_tvec_bases + (_flags)), \
+                .flags = (_flags),                              \
                 .slack = -1,                                    \
                 __TIMER_LOCKDEP_MAP_INITIALIZER(                \
                         __FILE__ ":" __stringify(__LINE__))     \
@@ -168,7 +162,7 @@ static inline void init_timer_on_stack_key(struct timer_list *timer,
  */
 static inline int timer_pending(const struct timer_list * timer)
 {
-        return timer->entry.next != NULL;
+        return timer->entry.pprev != NULL;
 }
 
 extern void add_timer_on(struct timer_list *timer, int cpu);
@@ -188,26 +182,16 @@ extern void set_timer_slack(struct timer_list *time, int slack_hz);
 #define NEXT_TIMER_MAX_DELTA    ((1UL << 30) - 1)
 
 /*
- * Return when the next timer-wheel timeout occurs (in absolute jiffies),
- * locks the timer base and does the comparison against the given
- * jiffie.
- */
-extern unsigned long get_next_timer_interrupt(unsigned long now);
-
-/*
  * Timer-statistics info:
  */
 #ifdef CONFIG_TIMER_STATS
 
 extern int timer_stats_active;
 
-#define TIMER_STATS_FLAG_DEFERRABLE     0x1
-
 extern void init_timer_stats(void);
 
 extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
-                                     void *timerf, char *comm,
-                                     unsigned int timer_flag);
+                                     void *timerf, char *comm, u32 flags);
 
 extern void __timer_stats_timer_set_start_info(struct timer_list *timer,
                                                void *addr);
@@ -254,6 +238,15 @@ extern void run_local_timers(void);
 struct hrtimer;
 extern enum hrtimer_restart it_real_fn(struct hrtimer *);
 
+#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
+#include <linux/sysctl.h>
+
+extern unsigned int sysctl_timer_migration;
+int timer_migration_handler(struct ctl_table *table, int write,
+                            void __user *buffer, size_t *lenp,
+                            loff_t *ppos);
+#endif
+
 unsigned long __round_jiffies(unsigned long j, int cpu);
 unsigned long __round_jiffies_relative(unsigned long j, int cpu);
 unsigned long round_jiffies(unsigned long j);
diff --git a/include/linux/timerqueue.h b/include/linux/timerqueue.h
index a520fd70a59f..7eec17ad7fa1 100644
--- a/include/linux/timerqueue.h
+++ b/include/linux/timerqueue.h
@@ -16,10 +16,10 @@ struct timerqueue_head {
 };
 
 
-extern void timerqueue_add(struct timerqueue_head *head,
-                                struct timerqueue_node *node);
-extern void timerqueue_del(struct timerqueue_head *head,
-                                struct timerqueue_node *node);
+extern bool timerqueue_add(struct timerqueue_head *head,
+                           struct timerqueue_node *node);
+extern bool timerqueue_del(struct timerqueue_head *head,
+                           struct timerqueue_node *node);
 extern struct timerqueue_node *timerqueue_iterate_next(
                                                 struct timerqueue_node *node);
 
diff --git a/include/linux/topology.h b/include/linux/topology.h
index 909b6e43b694..73ddad1e0fa3 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -191,8 +191,8 @@ static inline int cpu_to_mem(int cpu)
 #ifndef topology_core_id
 #define topology_core_id(cpu)                   ((void)(cpu), 0)
 #endif
-#ifndef topology_thread_cpumask
-#define topology_thread_cpumask(cpu)            cpumask_of(cpu)
+#ifndef topology_sibling_cpumask
+#define topology_sibling_cpumask(cpu)           cpumask_of(cpu)
 #endif
 #ifndef topology_core_cpumask
 #define topology_core_cpumask(cpu)              cpumask_of(cpu)
@@ -201,7 +201,7 @@ static inline int cpu_to_mem(int cpu)
 #ifdef CONFIG_SCHED_SMT
 static inline const struct cpumask *cpu_smt_mask(int cpu)
 {
-        return topology_thread_cpumask(cpu);
+        return topology_sibling_cpumask(cpu);
 }
 #endif
 
diff --git a/include/linux/types.h b/include/linux/types.h
index 59698be03490..8715287c3b1f 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -139,12 +139,20 @@ typedef unsigned long blkcnt_t;
  */
 #define pgoff_t unsigned long
 
-/* A dma_addr_t can hold any valid DMA or bus address for the platform */
+/*
+ * A dma_addr_t can hold any valid DMA address, i.e., any address returned
+ * by the DMA API.
+ *
+ * If the DMA API only uses 32-bit addresses, dma_addr_t need only be 32
+ * bits wide.  Bus addresses, e.g., PCI BARs, may be wider than 32 bits,
+ * but drivers do memory-mapped I/O to ioremapped kernel virtual addresses,
+ * so they don't care about the size of the actual bus addresses.
+ */
 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
 typedef u64 dma_addr_t;
 #else
 typedef u32 dma_addr_t;
-#endif /* dma_addr_t */
+#endif
 
 typedef unsigned __bitwise__ gfp_t;
 typedef unsigned __bitwise__ fmode_t;
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/uaccess.h b/include/linux/uaccess.h
index ecd3319dac33..ae572c138607 100644
--- a/include/linux/uaccess.h
+++ b/include/linux/uaccess.h
@@ -1,21 +1,30 @@
 #ifndef __LINUX_UACCESS_H__
 #define __LINUX_UACCESS_H__
 
-#include <linux/preempt.h>
+#include <linux/sched.h>
 #include <asm/uaccess.h>
 
+static __always_inline void pagefault_disabled_inc(void)
+{
+        current->pagefault_disabled++;
+}
+
+static __always_inline void pagefault_disabled_dec(void)
+{
+        current->pagefault_disabled--;
+        WARN_ON(current->pagefault_disabled < 0);
+}
+
 /*
- * These routines enable/disable the pagefault handler in that
- * it will not take any locks and go straight to the fixup table.
+ * These routines enable/disable the pagefault handler. If disabled, it will
+ * not take any locks and go straight to the fixup table.
  *
- * They have great resemblance to the preempt_disable/enable calls
- * and in fact they are identical; this is because currently there is
- * no other way to make the pagefault handlers do this. So we do
- * disable preemption but we don't necessarily care about that.
+ * User access methods will not sleep when called from a pagefault_disabled()
+ * environment.
  */
 static inline void pagefault_disable(void)
 {
-        preempt_count_inc();
+        pagefault_disabled_inc();
         /*
          * make sure to have issued the store before a pagefault
          * can hit.
@@ -25,18 +34,31 @@ static inline void pagefault_disable(void)
 
 static inline void pagefault_enable(void)
 {
-#ifndef CONFIG_PREEMPT
         /*
          * make sure to issue those last loads/stores before enabling
          * the pagefault handler again.
          */
         barrier();
-        preempt_count_dec();
-#else
-        preempt_enable();
-#endif
+        pagefault_disabled_dec();
 }
 
+/*
+ * Is the pagefault handler disabled? If so, user access methods will not sleep.
+ */
+#define pagefault_disabled() (current->pagefault_disabled != 0)
+
+/*
+ * The pagefault handler is in general disabled by pagefault_disable() or
+ * when in irq context (via in_atomic()).
+ *
+ * This function should only be used by the fault handlers. Other users should
+ * stick to pagefault_disabled().
+ * Please NEVER use preempt_disable() to disable the fault handler. With
+ * !CONFIG_PREEMPT_COUNT, this is like a NOP. So the handler won't be disabled.
+ * in_atomic() will report different values based on !CONFIG_PREEMPT_COUNT.
+ */
+#define faulthandler_disabled() (pagefault_disabled() || in_atomic())
+
 #ifndef ARCH_HAS_NOCACHE_UACCESS
 
 static inline unsigned long __copy_from_user_inatomic_nocache(void *to,
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 2db83349865b..d69ac4ecc88b 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -969,7 +969,7 @@ extern int bit_wait_io_timeout(struct wait_bit_key *);
  * on that signal.
  */
 static inline int
-wait_on_bit(void *word, int bit, unsigned mode)
+wait_on_bit(unsigned long *word, int bit, unsigned mode)
 {
         might_sleep();
         if (!test_bit(bit, word))
@@ -994,7 +994,7 @@ wait_on_bit(void *word, int bit, unsigned mode)
  * on that signal.
  */
 static inline int
-wait_on_bit_io(void *word, int bit, unsigned mode)
+wait_on_bit_io(unsigned long *word, int bit, unsigned mode)
 {
         might_sleep();
         if (!test_bit(bit, word))
@@ -1020,7 +1020,8 @@ wait_on_bit_io(void *word, int bit, unsigned mode)
  * received a signal and the mode permitted wakeup on that signal.
  */
 static inline int
-wait_on_bit_timeout(void *word, int bit, unsigned mode, unsigned long timeout)
+wait_on_bit_timeout(unsigned long *word, int bit, unsigned mode,
+                    unsigned long timeout)
 {
         might_sleep();
         if (!test_bit(bit, word))
@@ -1047,7 +1048,8 @@ wait_on_bit_timeout(void *word, int bit, unsigned mode, unsigned long timeout)
  * on that signal.
  */
 static inline int
-wait_on_bit_action(void *word, int bit, wait_bit_action_f *action, unsigned mode)
+wait_on_bit_action(unsigned long *word, int bit, wait_bit_action_f *action,
+                   unsigned mode)
 {
         might_sleep();
         if (!test_bit(bit, word))
@@ -1075,7 +1077,7 @@ wait_on_bit_action(void *word, int bit, wait_bit_action_f *action, unsigned mode
  * the @mode allows that signal to wake the process.
  */
 static inline int
-wait_on_bit_lock(void *word, int bit, unsigned mode)
+wait_on_bit_lock(unsigned long *word, int bit, unsigned mode)
 {
         might_sleep();
         if (!test_and_set_bit(bit, word))
@@ -1099,7 +1101,7 @@ wait_on_bit_lock(void *word, int bit, unsigned mode)
  * the @mode allows that signal to wake the process.
  */
 static inline int
-wait_on_bit_lock_io(void *word, int bit, unsigned mode)
+wait_on_bit_lock_io(unsigned long *word, int bit, unsigned mode)
 {
         might_sleep();
         if (!test_and_set_bit(bit, word))
@@ -1125,7 +1127,8 @@ wait_on_bit_lock_io(void *word, int bit, unsigned mode)
  * the @mode allows that signal to wake the process.
  */
 static inline int
-wait_on_bit_lock_action(void *word, int bit, wait_bit_action_f *action, unsigned mode)
+wait_on_bit_lock_action(unsigned long *word, int bit, wait_bit_action_f *action,
+                        unsigned mode)
 {
         might_sleep();
         if (!test_and_set_bit(bit, word))
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);