319 files changed, 11197 insertions, 4807 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index e6b98a32495f..64e10746f282 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -56,6 +56,8 @@ static inline acpi_handle acpi_device_handle(struct acpi_device *adev)
 #define ACPI_COMPANION_SET(dev, adev)   set_primary_fwnode(dev, (adev) ? \
         acpi_fwnode_handle(adev) : NULL)
 #define ACPI_HANDLE(dev)                acpi_device_handle(ACPI_COMPANION(dev))
+#define ACPI_HANDLE_FWNODE(fwnode)      \
+                                acpi_device_handle(to_acpi_device_node(fwnode))
 
 static inline struct fwnode_handle *acpi_alloc_fwnode_static(void)
 {
@@ -585,6 +587,7 @@ extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
                                                const struct device *dev);
 
+void *acpi_get_match_data(const struct device *dev);
 extern bool acpi_driver_match_device(struct device *dev,
                                      const struct device_driver *drv);
 int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
@@ -627,6 +630,7 @@ int acpi_arch_timer_mem_init(struct arch_timer_mem *timer_mem, int *timer_count)
 #define ACPI_COMPANION(dev)             (NULL)
 #define ACPI_COMPANION_SET(dev, adev)   do { } while (0)
 #define ACPI_HANDLE(dev)                (NULL)
+#define ACPI_HANDLE_FWNODE(fwnode)      (NULL)
 #define ACPI_DEVICE_CLASS(_cls, _msk)   .cls = (0), .cls_msk = (0),
 
 struct fwnode_handle;
@@ -762,6 +766,11 @@ static inline const struct acpi_device_id *acpi_match_device(
         return NULL;
 }
 
+static inline void *acpi_get_match_data(const struct device *dev)
+{
+        return NULL;
+}
+
 static inline bool acpi_driver_match_device(struct device *dev,
                                             const struct device_driver *drv)
 {
@@ -985,6 +994,11 @@ struct acpi_gpio_mapping {
         const char *name;
         const struct acpi_gpio_params *data;
         unsigned int size;
+
+/* Ignore IoRestriction field */
+#define ACPI_GPIO_QUIRK_NO_IO_RESTRICTION       BIT(0)
+
+        unsigned int quirks;
 };
 
 #if defined(CONFIG_ACPI) && defined(CONFIG_GPIOLIB)
diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
index 304511267c82..2b709416de05 100644
--- a/include/linux/arch_topology.h
+++ b/include/linux/arch_topology.h
@@ -27,7 +27,7 @@ void topology_set_cpu_scale(unsigned int cpu, unsigned long capacity);
 DECLARE_PER_CPU(unsigned long, freq_scale);
 
 static inline
-unsigned long topology_get_freq_scale(struct sched_domain *sd, int cpu)
+unsigned long topology_get_freq_scale(int cpu)
 {
         return per_cpu(freq_scale, cpu);
 }
diff --git a/include/linux/arm-smccc.h b/include/linux/arm-smccc.h
index 4c5bca38c653..a031897fca76 100644
--- a/include/linux/arm-smccc.h
+++ b/include/linux/arm-smccc.h
@@ -14,14 +14,16 @@
 #ifndef __LINUX_ARM_SMCCC_H
 #define __LINUX_ARM_SMCCC_H
 
+#include <uapi/linux/const.h>
+
 /*
  * This file provides common defines for ARM SMC Calling Convention as
  * specified in
  * http://infocenter.arm.com/help/topic/com.arm.doc.den0028a/index.html
  */
 
-#define ARM_SMCCC_STD_CALL              0
-#define ARM_SMCCC_FAST_CALL             1
+#define ARM_SMCCC_STD_CALL              _AC(0,U)
+#define ARM_SMCCC_FAST_CALL             _AC(1,U)
 #define ARM_SMCCC_TYPE_SHIFT            31
 
 #define ARM_SMCCC_SMC_32                0
@@ -60,6 +62,24 @@
 #define ARM_SMCCC_QUIRK_NONE            0
 #define ARM_SMCCC_QUIRK_QCOM_A6         1 /* Save/restore register a6 */
 
+#define ARM_SMCCC_VERSION_1_0           0x10000
+#define ARM_SMCCC_VERSION_1_1           0x10001
+
+#define ARM_SMCCC_VERSION_FUNC_ID                                       \
+        ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL,                         \
+                           ARM_SMCCC_SMC_32,                            \
+                           0, 0)
+
+#define ARM_SMCCC_ARCH_FEATURES_FUNC_ID                                 \
+        ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL,                         \
+                           ARM_SMCCC_SMC_32,                            \
+                           0, 1)
+
+#define ARM_SMCCC_ARCH_WORKAROUND_1                                     \
+        ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL,                         \
+                           ARM_SMCCC_SMC_32,                            \
+                           0, 0x8000)
+
 #ifndef __ASSEMBLY__
 
 #include <linux/linkage.h>
@@ -130,5 +150,146 @@ asmlinkage void __arm_smccc_hvc(unsigned long a0, unsigned long a1,
 
 #define arm_smccc_hvc_quirk(...) __arm_smccc_hvc(__VA_ARGS__)
 
+/* SMCCC v1.1 implementation madness follows */
+#ifdef CONFIG_ARM64
+
+#define SMCCC_SMC_INST  "smc    #0"
+#define SMCCC_HVC_INST  "hvc    #0"
+
+#elif defined(CONFIG_ARM)
+#include <asm/opcodes-sec.h>
+#include <asm/opcodes-virt.h>
+
+#define SMCCC_SMC_INST  __SMC(0)
+#define SMCCC_HVC_INST  __HVC(0)
+
+#endif
+
+#define ___count_args(_0, _1, _2, _3, _4, _5, _6, _7, _8, x, ...) x
+
+#define __count_args(...)                                               \
+        ___count_args(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0)
+
+#define __constraint_write_0                                            \
+        "+r" (r0), "=&r" (r1), "=&r" (r2), "=&r" (r3)
+#define __constraint_write_1                                            \
+        "+r" (r0), "+r" (r1), "=&r" (r2), "=&r" (r3)
+#define __constraint_write_2                                            \
+        "+r" (r0), "+r" (r1), "+r" (r2), "=&r" (r3)
+#define __constraint_write_3                                            \
+        "+r" (r0), "+r" (r1), "+r" (r2), "+r" (r3)
+#define __constraint_write_4    __constraint_write_3
+#define __constraint_write_5    __constraint_write_4
+#define __constraint_write_6    __constraint_write_5
+#define __constraint_write_7    __constraint_write_6
+
+#define __constraint_read_0
+#define __constraint_read_1
+#define __constraint_read_2
+#define __constraint_read_3
+#define __constraint_read_4     "r" (r4)
+#define __constraint_read_5     __constraint_read_4, "r" (r5)
+#define __constraint_read_6     __constraint_read_5, "r" (r6)
+#define __constraint_read_7     __constraint_read_6, "r" (r7)
+
+#define __declare_arg_0(a0, res)                                        \
+        struct arm_smccc_res   *___res = res;                           \
+        register u32           r0 asm("r0") = a0;                       \
+        register unsigned long r1 asm("r1");                            \
+        register unsigned long r2 asm("r2");                            \
+        register unsigned long r3 asm("r3")
+
+#define __declare_arg_1(a0, a1, res)                                    \
+        struct arm_smccc_res   *___res = res;                           \
+        register u32           r0 asm("r0") = a0;                       \
+        register typeof(a1)    r1 asm("r1") = a1;                       \
+        register unsigned long r2 asm("r2");                            \
+        register unsigned long r3 asm("r3")
+
+#define __declare_arg_2(a0, a1, a2, res)                                \
+        struct arm_smccc_res   *___res = res;                           \
+        register u32           r0 asm("r0") = a0;                       \
+        register typeof(a1)    r1 asm("r1") = a1;                       \
+        register typeof(a2)    r2 asm("r2") = a2;                       \
+        register unsigned long r3 asm("r3")
+
+#define __declare_arg_3(a0, a1, a2, a3, res)                            \
+        struct arm_smccc_res   *___res = res;                           \
+        register u32           r0 asm("r0") = a0;                       \
+        register typeof(a1)    r1 asm("r1") = a1;                       \
+        register typeof(a2)    r2 asm("r2") = a2;                       \
+        register typeof(a3)    r3 asm("r3") = a3
+
+#define __declare_arg_4(a0, a1, a2, a3, a4, res)                        \
+        __declare_arg_3(a0, a1, a2, a3, res);                           \
+        register typeof(a4) r4 asm("r4") = a4
+
+#define __declare_arg_5(a0, a1, a2, a3, a4, a5, res)                    \
+        __declare_arg_4(a0, a1, a2, a3, a4, res);                       \
+        register typeof(a5) r5 asm("r5") = a5
+
+#define __declare_arg_6(a0, a1, a2, a3, a4, a5, a6, res)                \
+        __declare_arg_5(a0, a1, a2, a3, a4, a5, res);                   \
+        register typeof(a6) r6 asm("r6") = a6
+
+#define __declare_arg_7(a0, a1, a2, a3, a4, a5, a6, a7, res)            \
+        __declare_arg_6(a0, a1, a2, a3, a4, a5, a6, res);               \
+        register typeof(a7) r7 asm("r7") = a7
+
+#define ___declare_args(count, ...) __declare_arg_ ## count(__VA_ARGS__)
+#define __declare_args(count, ...)  ___declare_args(count, __VA_ARGS__)
+
+#define ___constraints(count)                                           \
+        : __constraint_write_ ## count                                  \
+        : __constraint_read_ ## count                                   \
+        : "memory"
+#define __constraints(count)    ___constraints(count)
+
+/*
+ * We have an output list that is not necessarily used, and GCC feels
+ * entitled to optimise the whole sequence away. "volatile" is what
+ * makes it stick.
+ */
+#define __arm_smccc_1_1(inst, ...)                                      \
+        do {                                                            \
+                __declare_args(__count_args(__VA_ARGS__), __VA_ARGS__); \
+                asm volatile(inst "\n"                                  \
+                             __constraints(__count_args(__VA_ARGS__))); \
+                if (___res)                                             \
+                        *___res = (typeof(*___res)){r0, r1, r2, r3};    \
+        } while (0)
+
+/*
+ * arm_smccc_1_1_smc() - make an SMCCC v1.1 compliant SMC call
+ *
+ * This is a variadic macro taking one to eight source arguments, and
+ * an optional return structure.
+ *
+ * @a0-a7: arguments passed in registers 0 to 7
+ * @res: result values from registers 0 to 3
+ *
+ * This macro is used to make SMC calls following SMC Calling Convention v1.1.
+ * The content of the supplied param are copied to registers 0 to 7 prior
+ * to the SMC instruction. The return values are updated with the content
+ * from register 0 to 3 on return from the SMC instruction if not NULL.
+ */
+#define arm_smccc_1_1_smc(...)  __arm_smccc_1_1(SMCCC_SMC_INST, __VA_ARGS__)
+
+/*
+ * arm_smccc_1_1_hvc() - make an SMCCC v1.1 compliant HVC call
+ *
+ * This is a variadic macro taking one to eight source arguments, and
+ * an optional return structure.
+ *
+ * @a0-a7: arguments passed in registers 0 to 7
+ * @res: result values from registers 0 to 3
+ *
+ * This macro is used to make HVC calls following SMC Calling Convention v1.1.
+ * The content of the supplied param are copied to registers 0 to 7 prior
+ * to the HVC instruction. The return values are updated with the content
+ * from register 0 to 3 on return from the HVC instruction if not NULL.
+ */
+#define arm_smccc_1_1_hvc(...)  __arm_smccc_1_1(SMCCC_HVC_INST, __VA_ARGS__)
+
 #endif /*__ASSEMBLY__*/
 #endif /*__LINUX_ARM_SMCCC_H*/
diff --git a/include/linux/arm_sdei.h b/include/linux/arm_sdei.h
new file mode 100644
index 000000000000..942afbd544b7
--- /dev/null
+++ b/include/linux/arm_sdei.h
@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (C) 2017 Arm Ltd.
+#ifndef __LINUX_ARM_SDEI_H
+#define __LINUX_ARM_SDEI_H
+
+#include <uapi/linux/arm_sdei.h>
+
+enum sdei_conduit_types {
+        CONDUIT_INVALID = 0,
+        CONDUIT_SMC,
+        CONDUIT_HVC,
+};
+
+#include <asm/sdei.h>
+
+/* Arch code should override this to set the entry point from firmware... */
+#ifndef sdei_arch_get_entry_point
+#define sdei_arch_get_entry_point(conduit)      (0)
+#endif
+
+/*
+ * When an event occurs sdei_event_handler() will call a user-provided callback
+ * like this in NMI context on the CPU that received the event.
+ */
+typedef int (sdei_event_callback)(u32 event, struct pt_regs *regs, void *arg);
+
+/*
+ * Register your callback to claim an event. The event must be described
+ * by firmware.
+ */
+int sdei_event_register(u32 event_num, sdei_event_callback *cb, void *arg);
+
+/*
+ * Calls to sdei_event_unregister() may return EINPROGRESS. Keep calling
+ * it until it succeeds.
+ */
+int sdei_event_unregister(u32 event_num);
+
+int sdei_event_enable(u32 event_num);
+int sdei_event_disable(u32 event_num);
+
+#ifdef CONFIG_ARM_SDE_INTERFACE
+/* For use by arch code when CPU hotplug notifiers are not appropriate. */
+int sdei_mask_local_cpu(void);
+int sdei_unmask_local_cpu(void);
+#else
+static inline int sdei_mask_local_cpu(void) { return 0; }
+static inline int sdei_unmask_local_cpu(void) { return 0; }
+#endif /* CONFIG_ARM_SDE_INTERFACE */
+
+
+/*
+ * This struct represents an event that has been registered. The driver
+ * maintains a list of all events, and which ones are registered. (Private
+ * events have one entry in the list, but are registered on each CPU).
+ * A pointer to this struct is passed to firmware, and back to the event
+ * handler. The event handler can then use this to invoke the registered
+ * callback, without having to walk the list.
+ *
+ * For CPU private events, this structure is per-cpu.
+ */
+struct sdei_registered_event {
+        /* For use by arch code: */
+        struct pt_regs          interrupted_regs;
+
+        sdei_event_callback     *callback;
+        void                    *callback_arg;
+        u32                      event_num;
+        u8                       priority;
+};
+
+/* The arch code entry point should then call this when an event arrives. */
+int notrace sdei_event_handler(struct pt_regs *regs,
+                               struct sdei_registered_event *arg);
+
+/* arch code may use this to retrieve the extra registers. */
+int sdei_api_event_context(u32 query, u64 *result);
+
+#endif /* __LINUX_ARM_SDEI_H */
diff --git a/include/linux/ata.h b/include/linux/ata.h
index c7a353825450..40d150ad7e07 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -448,6 +448,8 @@ enum {
         ATA_SET_MAX_LOCK        = 0x02,
         ATA_SET_MAX_UNLOCK      = 0x03,
         ATA_SET_MAX_FREEZE_LOCK = 0x04,
+        ATA_SET_MAX_PASSWD_DMA  = 0x05,
+        ATA_SET_MAX_UNLOCK_DMA  = 0x06,
 
         /* feature values for DEVICE CONFIGURATION OVERLAY */
         ATA_DCO_RESTORE         = 0xC0,
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index e54e7e0033eb..3e4ce54d84ab 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -332,7 +332,7 @@ static inline bool inode_to_wb_is_valid(struct inode *inode)
  * 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)
+static inline struct bdi_writeback *inode_to_wb(const struct inode *inode)
 {
 #ifdef CONFIG_LOCKDEP
         WARN_ON_ONCE(debug_locks &&
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 23d29b39f71e..d0eb659fa733 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -300,6 +300,29 @@ static inline void bio_get_last_bvec(struct bio *bio, struct bio_vec *bv)
                 bv->bv_len = iter.bi_bvec_done;
 }
 
+static inline unsigned bio_pages_all(struct bio *bio)
+{
+        WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
+        return bio->bi_vcnt;
+}
+
+static inline struct bio_vec *bio_first_bvec_all(struct bio *bio)
+{
+        WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
+        return bio->bi_io_vec;
+}
+
+static inline struct page *bio_first_page_all(struct bio *bio)
+{
+        return bio_first_bvec_all(bio)->bv_page;
+}
+
+static inline struct bio_vec *bio_last_bvec_all(struct bio *bio)
+{
+        WARN_ON_ONCE(bio_flagged(bio, BIO_CLONED));
+        return &bio->bi_io_vec[bio->bi_vcnt - 1];
+}
+
 enum bip_flags {
         BIP_BLOCK_INTEGRITY     = 1 << 0, /* block layer owns integrity data */
         BIP_MAPPED_INTEGRITY    = 1 << 1, /* ref tag has been remapped */
@@ -477,7 +500,6 @@ static inline void bio_flush_dcache_pages(struct bio *bi)
 #endif
 
 extern void bio_copy_data(struct bio *dst, struct bio *src);
-extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
 extern void bio_free_pages(struct bio *bio);
 
 extern struct bio *bio_copy_user_iov(struct request_queue *,
diff --git a/include/linux/bitfield.h b/include/linux/bitfield.h
index 1030651f8309..cf2588d81148 100644
--- a/include/linux/bitfield.h
+++ b/include/linux/bitfield.h
@@ -16,6 +16,7 @@
 #define _LINUX_BITFIELD_H
 
 #include <linux/build_bug.h>
+#include <asm/byteorder.h>
 
 /*
  * Bitfield access macros
@@ -103,4 +104,49 @@
                 (typeof(_mask))(((_reg) & (_mask)) >> __bf_shf(_mask)); \
         })
 
+extern void __compiletime_warning("value doesn't fit into mask")
+__field_overflow(void);
+extern void __compiletime_error("bad bitfield mask")
+__bad_mask(void);
+static __always_inline u64 field_multiplier(u64 field)
+{
+        if ((field | (field - 1)) & ((field | (field - 1)) + 1))
+                __bad_mask();
+        return field & -field;
+}
+static __always_inline u64 field_mask(u64 field)
+{
+        return field / field_multiplier(field);
+}
+#define ____MAKE_OP(type,base,to,from)                                  \
+static __always_inline __##type type##_encode_bits(base v, base field)  \
+{                                                                       \
+        if (__builtin_constant_p(v) &&  (v & ~field_multiplier(field))) \
+                            __field_overflow();                         \
+        return to((v & field_mask(field)) * field_multiplier(field));   \
+}                                                                       \
+static __always_inline __##type type##_replace_bits(__##type old,       \
+                                        base val, base field)           \
+{                                                                       \
+        return (old & ~to(field)) | type##_encode_bits(val, field);     \
+}                                                                       \
+static __always_inline void type##p_replace_bits(__##type *p,           \
+                                        base val, base field)           \
+{                                                                       \
+        *p = (*p & ~to(field)) | type##_encode_bits(val, field);        \
+}                                                                       \
+static __always_inline base type##_get_bits(__##type v, base field)     \
+{                                                                       \
+        return (from(v) & field)/field_multiplier(field);               \
+}
+#define __MAKE_OP(size)                                                 \
+        ____MAKE_OP(le##size,u##size,cpu_to_le##size,le##size##_to_cpu) \
+        ____MAKE_OP(be##size,u##size,cpu_to_be##size,be##size##_to_cpu) \
+        ____MAKE_OP(u##size,u##size,,)
+__MAKE_OP(16)
+__MAKE_OP(32)
+__MAKE_OP(64)
+#undef __MAKE_OP
+#undef ____MAKE_OP
+
 #endif
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 3489253e38fc..5f11fbdc27f8 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -64,9 +64,14 @@
  *  bitmap_find_free_region(bitmap, bits, order)  Find and allocate bit region
  *  bitmap_release_region(bitmap, pos, order)   Free specified bit region
  *  bitmap_allocate_region(bitmap, pos, order)  Allocate specified bit region
- *  bitmap_from_u32array(dst, nbits, buf, nwords)  *dst = *buf (nwords 32b words)
- *  bitmap_to_u32array(buf, nwords, src, nbits) *buf = *dst (nwords 32b words)
+ *  bitmap_from_arr32(dst, buf, nbits)          Copy nbits from u32[] buf to dst
+ *  bitmap_to_arr32(buf, src, nbits)            Copy nbits from buf to u32[] dst
  *
+ * Note, bitmap_zero() and bitmap_fill() operate over the region of
+ * unsigned longs, that is, bits behind bitmap till the unsigned long
+ * boundary will be zeroed or filled as well. Consider to use
+ * bitmap_clear() or bitmap_set() to make explicit zeroing or filling
+ * respectively.
  */
 
 /**
@@ -83,8 +88,12 @@
  *  test_and_change_bit(bit, addr)      Change bit and return old value
  *  find_first_zero_bit(addr, nbits)    Position first zero bit in *addr
  *  find_first_bit(addr, nbits)         Position first set bit in *addr
- *  find_next_zero_bit(addr, nbits, bit)  Position next zero bit in *addr >= bit
+ *  find_next_zero_bit(addr, nbits, bit)
+ *                                      Position next zero bit in *addr >= bit
  *  find_next_bit(addr, nbits, bit)     Position next set bit in *addr >= bit
+ *  find_next_and_bit(addr1, addr2, nbits, bit)
+ *                                      Same as find_next_bit, but in
+ *                                      (*addr1 & *addr2)
  *
  */
 
@@ -174,14 +183,7 @@ extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
 extern int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
 extern void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);
 extern int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);
-extern unsigned int bitmap_from_u32array(unsigned long *bitmap,
-                                         unsigned int nbits,
-                                         const u32 *buf,
-                                         unsigned int nwords);
-extern unsigned int bitmap_to_u32array(u32 *buf,
-                                       unsigned int nwords,
-                                       const unsigned long *bitmap,
-                                       unsigned int nbits);
+
 #ifdef __BIG_ENDIAN
 extern void bitmap_copy_le(unsigned long *dst, const unsigned long *src, unsigned int nbits);
 #else
@@ -209,12 +211,12 @@ static inline void bitmap_zero(unsigned long *dst, unsigned int nbits)
 
 static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)
 {
-        unsigned int nlongs = BITS_TO_LONGS(nbits);
-        if (!small_const_nbits(nbits)) {
-                unsigned int len = (nlongs - 1) * sizeof(unsigned long);
-                memset(dst, 0xff,  len);
+        if (small_const_nbits(nbits))
+                *dst = ~0UL;
+        else {
+                unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+                memset(dst, 0xff, len);
         }
-        dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits);
 }
 
 static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
@@ -228,6 +230,35 @@ static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
         }
 }
 
+/*
+ * Copy bitmap and clear tail bits in last word.
+ */
+static inline void bitmap_copy_clear_tail(unsigned long *dst,
+                const unsigned long *src, unsigned int nbits)
+{
+        bitmap_copy(dst, src, nbits);
+        if (nbits % BITS_PER_LONG)
+                dst[nbits / BITS_PER_LONG] &= BITMAP_LAST_WORD_MASK(nbits);
+}
+
+/*
+ * On 32-bit systems bitmaps are represented as u32 arrays internally, and
+ * therefore conversion is not needed when copying data from/to arrays of u32.
+ */
+#if BITS_PER_LONG == 64
+extern void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf,
+                                                        unsigned int nbits);
+extern void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap,
+                                                        unsigned int nbits);
+#else
+#define bitmap_from_arr32(bitmap, buf, nbits)                   \
+        bitmap_copy_clear_tail((unsigned long *) (bitmap),      \
+                        (const unsigned long *) (buf), (nbits))
+#define bitmap_to_arr32(buf, bitmap, nbits)                     \
+        bitmap_copy_clear_tail((unsigned long *) (buf),         \
+                        (const unsigned long *) (bitmap), (nbits))
+#endif
+
 static inline int bitmap_and(unsigned long *dst, const unsigned long *src1,
                         const unsigned long *src2, unsigned int nbits)
 {
diff --git a/include/linux/blk-cgroup.h b/include/linux/blk-cgroup.h
index e9825ff57b15..69bea82ebeb1 100644
--- a/include/linux/blk-cgroup.h
+++ b/include/linux/blk-cgroup.h
@@ -660,12 +660,14 @@ static inline void blkg_rwstat_reset(struct blkg_rwstat *rwstat)
 static inline void blkg_rwstat_add_aux(struct blkg_rwstat *to,
                                        struct blkg_rwstat *from)
 {
-        struct blkg_rwstat v = blkg_rwstat_read(from);
+        u64 sum[BLKG_RWSTAT_NR];
         int i;
 
         for (i = 0; i < BLKG_RWSTAT_NR; i++)
-                atomic64_add(atomic64_read(&v.aux_cnt[i]) +
-                             atomic64_read(&from->aux_cnt[i]),
+                sum[i] = percpu_counter_sum_positive(&from->cpu_cnt[i]);
+
+        for (i = 0; i < BLKG_RWSTAT_NR; i++)
+                atomic64_add(sum[i] + atomic64_read(&from->aux_cnt[i]),
                              &to->aux_cnt[i]);
 }
 
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 95c9a5c862e2..8efcf49796a3 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -51,6 +51,7 @@ struct blk_mq_hw_ctx {
         unsigned int            queue_num;
 
         atomic_t                nr_active;
+        unsigned int            nr_expired;
 
         struct hlist_node       cpuhp_dead;
         struct kobject          kobj;
@@ -65,7 +66,7 @@ struct blk_mq_hw_ctx {
 #endif
 
         /* Must be the last member - see also blk_mq_hw_ctx_size(). */
-        struct srcu_struct      queue_rq_srcu[0];
+        struct srcu_struct      srcu[0];
 };
 
 struct blk_mq_tag_set {
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 9e7d8bd776d2..bf18b95ed92d 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -39,6 +39,52 @@ typedef u8 __bitwise blk_status_t;
 
 #define BLK_STS_AGAIN           ((__force blk_status_t)12)
 
+/*
+ * BLK_STS_DEV_RESOURCE is returned from the driver to the block layer if
+ * device related resources are unavailable, but the driver can guarantee
+ * that the queue will be rerun in the future once resources become
+ * available again. This is typically the case for device specific
+ * resources that are consumed for IO. If the driver fails allocating these
+ * resources, we know that inflight (or pending) IO will free these
+ * resource upon completion.
+ *
+ * This is different from BLK_STS_RESOURCE in that it explicitly references
+ * a device specific resource. For resources of wider scope, allocation
+ * failure can happen without having pending IO. This means that we can't
+ * rely on request completions freeing these resources, as IO may not be in
+ * flight. Examples of that are kernel memory allocations, DMA mappings, or
+ * any other system wide resources.
+ */
+#define BLK_STS_DEV_RESOURCE    ((__force blk_status_t)13)
+
+/**
+ * blk_path_error - returns true if error may be path related
+ * @error: status the request was completed with
+ *
+ * Description:
+ *     This classifies block error status into non-retryable errors and ones
+ *     that may be successful if retried on a failover path.
+ *
+ * Return:
+ *     %false - retrying failover path will not help
+ *     %true  - may succeed if retried
+ */
+static inline bool blk_path_error(blk_status_t error)
+{
+        switch (error) {
+        case BLK_STS_NOTSUPP:
+        case BLK_STS_NOSPC:
+        case BLK_STS_TARGET:
+        case BLK_STS_NEXUS:
+        case BLK_STS_MEDIUM:
+        case BLK_STS_PROTECTION:
+                return false;
+        }
+
+        /* Anything else could be a path failure, so should be retried */
+        return true;
+}
+
 struct blk_issue_stat {
         u64 stat;
 };
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 0ce8a372d506..4f3df807cf8f 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -27,6 +27,8 @@
 #include <linux/percpu-refcount.h>
 #include <linux/scatterlist.h>
 #include <linux/blkzoned.h>
+#include <linux/seqlock.h>
+#include <linux/u64_stats_sync.h>
 
 struct module;
 struct scsi_ioctl_command;
@@ -121,6 +123,12 @@ typedef __u32 __bitwise req_flags_t;
 /* Look at ->special_vec for the actual data payload instead of the
    bio chain. */
 #define RQF_SPECIAL_PAYLOAD     ((__force req_flags_t)(1 << 18))
+/* The per-zone write lock is held for this request */
+#define RQF_ZONE_WRITE_LOCKED   ((__force req_flags_t)(1 << 19))
+/* timeout is expired */
+#define RQF_MQ_TIMEOUT_EXPIRED  ((__force req_flags_t)(1 << 20))
+/* already slept for hybrid poll */
+#define RQF_MQ_POLL_SLEPT       ((__force req_flags_t)(1 << 21))
 
 /* flags that prevent us from merging requests: */
 #define RQF_NOMERGE_FLAGS \
@@ -133,12 +141,6 @@ typedef __u32 __bitwise req_flags_t;
  * especially blk_mq_rq_ctx_init() to take care of the added fields.
  */
 struct request {
-        struct list_head queuelist;
-        union {
-                struct __call_single_data csd;
-                u64 fifo_time;
-        };
-
         struct request_queue *q;
         struct blk_mq_ctx *mq_ctx;
 
@@ -148,8 +150,6 @@ struct request {
 
         int internal_tag;
 
-        unsigned long atomic_flags;
-
         /* the following two fields are internal, NEVER access directly */
         unsigned int __data_len;        /* total data len */
         int tag;
@@ -158,6 +158,8 @@ struct request {
         struct bio *bio;
         struct bio *biotail;
 
+        struct list_head queuelist;
+
         /*
          * The hash is used inside the scheduler, and killed once the
          * request reaches the dispatch list. The ipi_list is only used
@@ -205,19 +207,16 @@ struct request {
         struct hd_struct *part;
         unsigned long start_time;
         struct blk_issue_stat issue_stat;
-#ifdef CONFIG_BLK_CGROUP
-        struct request_list *rl;                /* rl this rq is alloced from */
-        unsigned long long start_time_ns;
-        unsigned long long io_start_time_ns;    /* when passed to hardware */
-#endif
         /* Number of scatter-gather DMA addr+len pairs after
          * physical address coalescing is performed.
          */
         unsigned short nr_phys_segments;
+
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
         unsigned short nr_integrity_segments;
 #endif
 
+        unsigned short write_hint;
         unsigned short ioprio;
 
         unsigned int timeout;
@@ -226,11 +225,37 @@ struct request {
 
         unsigned int extra_len; /* length of alignment and padding */
 
-        unsigned short write_hint;
+        /*
+         * On blk-mq, the lower bits of ->gstate (generation number and
+         * state) carry the MQ_RQ_* state value and the upper bits the
+         * generation number which is monotonically incremented and used to
+         * distinguish the reuse instances.
+         *
+         * ->gstate_seq allows updates to ->gstate and other fields
+         * (currently ->deadline) during request start to be read
+         * atomically from the timeout path, so that it can operate on a
+         * coherent set of information.
+         */
+        seqcount_t gstate_seq;
+        u64 gstate;
+
+        /*
+         * ->aborted_gstate is used by the timeout to claim a specific
+         * recycle instance of this request.  See blk_mq_timeout_work().
+         */
+        struct u64_stats_sync aborted_gstate_sync;
+        u64 aborted_gstate;
+
+        /* access through blk_rq_set_deadline, blk_rq_deadline */
+        unsigned long __deadline;
 
-        unsigned long deadline;
         struct list_head timeout_list;
 
+        union {
+                struct __call_single_data csd;
+                u64 fifo_time;
+        };
+
         /*
          * completion callback.
          */
@@ -239,6 +264,12 @@ struct request {
 
         /* for bidi */
         struct request *next_rq;
+
+#ifdef CONFIG_BLK_CGROUP
+        struct request_list *rl;                /* rl this rq is alloced from */
+        unsigned long long start_time_ns;
+        unsigned long long io_start_time_ns;    /* when passed to hardware */
+#endif
 };
 
 static inline bool blk_op_is_scsi(unsigned int op)
@@ -564,6 +595,22 @@ struct request_queue {
         struct queue_limits     limits;
 
         /*
+         * Zoned block device information for request dispatch control.
+         * nr_zones is the total number of zones of the device. This is always
+         * 0 for regular block devices. seq_zones_bitmap is a bitmap of nr_zones
+         * bits which indicates if a zone is conventional (bit clear) or
+         * sequential (bit set). seq_zones_wlock is a bitmap of nr_zones
+         * bits which indicates if a zone is write locked, that is, if a write
+         * request targeting the zone was dispatched. All three fields are
+         * initialized by the low level device driver (e.g. scsi/sd.c).
+         * Stacking drivers (device mappers) may or may not initialize
+         * these fields.
+         */
+        unsigned int            nr_zones;
+        unsigned long           *seq_zones_bitmap;
+        unsigned long           *seq_zones_wlock;
+
+        /*
          * sg stuff
          */
         unsigned int            sg_timeout;
@@ -807,6 +854,27 @@ static inline unsigned int blk_queue_zone_sectors(struct request_queue *q)
         return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0;
 }
 
+static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
+{
+        return q->nr_zones;
+}
+
+static inline unsigned int blk_queue_zone_no(struct request_queue *q,
+                                             sector_t sector)
+{
+        if (!blk_queue_is_zoned(q))
+                return 0;
+        return sector >> ilog2(q->limits.chunk_sectors);
+}
+
+static inline bool blk_queue_zone_is_seq(struct request_queue *q,
+                                         sector_t sector)
+{
+        if (!blk_queue_is_zoned(q) || !q->seq_zones_bitmap)
+                return false;
+        return test_bit(blk_queue_zone_no(q, sector), q->seq_zones_bitmap);
+}
+
 static inline bool rq_is_sync(struct request *rq)
 {
         return op_is_sync(rq->cmd_flags);
@@ -1046,6 +1114,16 @@ static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
         return blk_rq_cur_bytes(rq) >> 9;
 }
 
+static inline unsigned int blk_rq_zone_no(struct request *rq)
+{
+        return blk_queue_zone_no(rq->q, blk_rq_pos(rq));
+}
+
+static inline unsigned int blk_rq_zone_is_seq(struct request *rq)
+{
+        return blk_queue_zone_is_seq(rq->q, blk_rq_pos(rq));
+}
+
 /*
  * Some commands like WRITE SAME have a payload or data transfer size which
  * is different from the size of the request.  Any driver that supports such
@@ -1595,7 +1673,15 @@ static inline unsigned int bdev_zone_sectors(struct block_device *bdev)
 
         if (q)
                 return blk_queue_zone_sectors(q);
+        return 0;
+}
+
+static inline unsigned int bdev_nr_zones(struct block_device *bdev)
+{
+        struct request_queue *q = bdev_get_queue(bdev);
 
+        if (q)
+                return blk_queue_nr_zones(q);
         return 0;
 }
 
@@ -1731,8 +1817,6 @@ static inline bool req_gap_front_merge(struct request *req, struct bio *bio)
 
 int kblockd_schedule_work(struct work_struct *work);
 int kblockd_schedule_work_on(int cpu, struct work_struct *work);
-int kblockd_schedule_delayed_work(struct delayed_work *dwork, unsigned long delay);
-int kblockd_schedule_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
 int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
 
 #ifdef CONFIG_BLK_CGROUP
@@ -1971,6 +2055,60 @@ extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
 extern int bdev_read_page(struct block_device *, sector_t, struct page *);
 extern int bdev_write_page(struct block_device *, sector_t, struct page *,
                                                 struct writeback_control *);
+
+#ifdef CONFIG_BLK_DEV_ZONED
+bool blk_req_needs_zone_write_lock(struct request *rq);
+void __blk_req_zone_write_lock(struct request *rq);
+void __blk_req_zone_write_unlock(struct request *rq);
+
+static inline void blk_req_zone_write_lock(struct request *rq)
+{
+        if (blk_req_needs_zone_write_lock(rq))
+                __blk_req_zone_write_lock(rq);
+}
+
+static inline void blk_req_zone_write_unlock(struct request *rq)
+{
+        if (rq->rq_flags & RQF_ZONE_WRITE_LOCKED)
+                __blk_req_zone_write_unlock(rq);
+}
+
+static inline bool blk_req_zone_is_write_locked(struct request *rq)
+{
+        return rq->q->seq_zones_wlock &&
+                test_bit(blk_rq_zone_no(rq), rq->q->seq_zones_wlock);
+}
+
+static inline bool blk_req_can_dispatch_to_zone(struct request *rq)
+{
+        if (!blk_req_needs_zone_write_lock(rq))
+                return true;
+        return !blk_req_zone_is_write_locked(rq);
+}
+#else
+static inline bool blk_req_needs_zone_write_lock(struct request *rq)
+{
+        return false;
+}
+
+static inline void blk_req_zone_write_lock(struct request *rq)
+{
+}
+
+static inline void blk_req_zone_write_unlock(struct request *rq)
+{
+}
+static inline bool blk_req_zone_is_write_locked(struct request *rq)
+{
+        return false;
+}
+
+static inline bool blk_req_can_dispatch_to_zone(struct request *rq)
+{
+        return true;
+}
+#endif /* CONFIG_BLK_DEV_ZONED */
+
 #else /* CONFIG_BLOCK */
 
 struct block_device;
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 0b25cf87b6d6..66df387106de 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -17,6 +17,7 @@
 #include <linux/numa.h>
 #include <linux/wait.h>
 
+struct bpf_verifier_env;
 struct perf_event;
 struct bpf_prog;
 struct bpf_map;
@@ -24,6 +25,7 @@ struct bpf_map;
 /* map is generic key/value storage optionally accesible by eBPF programs */
 struct bpf_map_ops {
         /* funcs callable from userspace (via syscall) */
+        int (*map_alloc_check)(union bpf_attr *attr);
         struct bpf_map *(*map_alloc)(union bpf_attr *attr);
         void (*map_release)(struct bpf_map *map, struct file *map_file);
         void (*map_free)(struct bpf_map *map);
@@ -72,6 +74,33 @@ struct bpf_map {
         char name[BPF_OBJ_NAME_LEN];
 };
 
+struct bpf_offloaded_map;
+
+struct bpf_map_dev_ops {
+        int (*map_get_next_key)(struct bpf_offloaded_map *map,
+                                void *key, void *next_key);
+        int (*map_lookup_elem)(struct bpf_offloaded_map *map,
+                               void *key, void *value);
+        int (*map_update_elem)(struct bpf_offloaded_map *map,
+                               void *key, void *value, u64 flags);
+        int (*map_delete_elem)(struct bpf_offloaded_map *map, void *key);
+};
+
+struct bpf_offloaded_map {
+        struct bpf_map map;
+        struct net_device *netdev;
+        const struct bpf_map_dev_ops *dev_ops;
+        void *dev_priv;
+        struct list_head offloads;
+};
+
+static inline struct bpf_offloaded_map *map_to_offmap(struct bpf_map *map)
+{
+        return container_of(map, struct bpf_offloaded_map, map);
+}
+
+extern const struct bpf_map_ops bpf_map_offload_ops;
+
 /* function argument constraints */
 enum bpf_arg_type {
         ARG_DONTCARE = 0,       /* unused argument in helper function */
@@ -193,14 +222,20 @@ struct bpf_verifier_ops {
                                   struct bpf_prog *prog, u32 *target_size);
 };
 
-struct bpf_dev_offload {
+struct bpf_prog_offload_ops {
+        int (*insn_hook)(struct bpf_verifier_env *env,
+                         int insn_idx, int prev_insn_idx);
+};
+
+struct bpf_prog_offload {
         struct bpf_prog         *prog;
         struct net_device       *netdev;
         void                    *dev_priv;
         struct list_head        offloads;
         bool                    dev_state;
-        bool                    verifier_running;
-        wait_queue_head_t       verifier_done;
+        const struct bpf_prog_offload_ops *dev_ops;
+        void                    *jited_image;
+        u32                     jited_len;
 };
 
 struct bpf_prog_aux {
@@ -209,6 +244,10 @@ struct bpf_prog_aux {
         u32 max_ctx_offset;
         u32 stack_depth;
         u32 id;
+        u32 func_cnt;
+        bool offload_requested;
+        struct bpf_prog **func;
+        void *jit_data; /* JIT specific data. arch dependent */
         struct latch_tree_node ksym_tnode;
         struct list_head ksym_lnode;
         const struct bpf_prog_ops *ops;
@@ -220,7 +259,7 @@ struct bpf_prog_aux {
 #ifdef CONFIG_SECURITY
         void *security;
 #endif
-        struct bpf_dev_offload *offload;
+        struct bpf_prog_offload *offload;
         union {
                 struct work_struct work;
                 struct rcu_head rcu;
@@ -295,6 +334,9 @@ int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs,
 
 void bpf_prog_array_delete_safe(struct bpf_prog_array __rcu *progs,
                                 struct bpf_prog *old_prog);
+int bpf_prog_array_copy_info(struct bpf_prog_array __rcu *array,
+                             __u32 __user *prog_ids, u32 request_cnt,
+                             __u32 __user *prog_cnt);
 int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
                         struct bpf_prog *exclude_prog,
                         struct bpf_prog *include_prog,
@@ -355,6 +397,9 @@ void bpf_prog_put(struct bpf_prog *prog);
 int __bpf_prog_charge(struct user_struct *user, u32 pages);
 void __bpf_prog_uncharge(struct user_struct *user, u32 pages);
 
+void bpf_prog_free_id(struct bpf_prog *prog, bool do_idr_lock);
+void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock);
+
 struct bpf_map *bpf_map_get_with_uref(u32 ufd);
 struct bpf_map *__bpf_map_get(struct fd f);
 struct bpf_map * __must_check bpf_map_inc(struct bpf_map *map, bool uref);
@@ -363,6 +408,7 @@ void bpf_map_put(struct bpf_map *map);
 int bpf_map_precharge_memlock(u32 pages);
 void *bpf_map_area_alloc(size_t size, int numa_node);
 void bpf_map_area_free(void *base);
+void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);
 
 extern int sysctl_unprivileged_bpf_disabled;
 
@@ -409,6 +455,7 @@ static inline void bpf_long_memcpy(void *dst, const void *src, u32 size)
 
 /* verify correctness of eBPF program */
 int bpf_check(struct bpf_prog **fp, union bpf_attr *attr);
+void bpf_patch_call_args(struct bpf_insn *insn, u32 stack_depth);
 
 /* Map specifics */
 struct net_device  *__dev_map_lookup_elem(struct bpf_map *map, u32 key);
@@ -536,14 +583,35 @@ bool bpf_prog_get_ok(struct bpf_prog *, enum bpf_prog_type *, bool);
 
 int bpf_prog_offload_compile(struct bpf_prog *prog);
 void bpf_prog_offload_destroy(struct bpf_prog *prog);
+int bpf_prog_offload_info_fill(struct bpf_prog_info *info,
+                               struct bpf_prog *prog);
+
+int bpf_map_offload_info_fill(struct bpf_map_info *info, struct bpf_map *map);
+
+int bpf_map_offload_lookup_elem(struct bpf_map *map, void *key, void *value);
+int bpf_map_offload_update_elem(struct bpf_map *map,
+                                void *key, void *value, u64 flags);
+int bpf_map_offload_delete_elem(struct bpf_map *map, void *key);
+int bpf_map_offload_get_next_key(struct bpf_map *map,
+                                 void *key, void *next_key);
+
+bool bpf_offload_dev_match(struct bpf_prog *prog, struct bpf_map *map);
 
 #if defined(CONFIG_NET) && defined(CONFIG_BPF_SYSCALL)
 int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr);
 
 static inline bool bpf_prog_is_dev_bound(struct bpf_prog_aux *aux)
 {
-        return aux->offload;
+        return aux->offload_requested;
 }
+
+static inline bool bpf_map_is_dev_bound(struct bpf_map *map)
+{
+        return unlikely(map->ops == &bpf_map_offload_ops);
+}
+
+struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr);
+void bpf_map_offload_map_free(struct bpf_map *map);
 #else
 static inline int bpf_prog_offload_init(struct bpf_prog *prog,
                                         union bpf_attr *attr)
@@ -555,9 +623,23 @@ static inline bool bpf_prog_is_dev_bound(struct bpf_prog_aux *aux)
 {
         return false;
 }
+
+static inline bool bpf_map_is_dev_bound(struct bpf_map *map)
+{
+        return false;
+}
+
+static inline struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr)
+{
+        return ERR_PTR(-EOPNOTSUPP);
+}
+
+static inline void bpf_map_offload_map_free(struct bpf_map *map)
+{
+}
 #endif /* CONFIG_NET && CONFIG_BPF_SYSCALL */
 
-#if defined(CONFIG_STREAM_PARSER) && defined(CONFIG_BPF_SYSCALL)
+#if defined(CONFIG_STREAM_PARSER) && defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_INET)
 struct sock  *__sock_map_lookup_elem(struct bpf_map *map, u32 key);
 int sock_map_prog(struct bpf_map *map, struct bpf_prog *prog, u32 type);
 #else
diff --git a/include/linux/bpf_types.h b/include/linux/bpf_types.h
index 978c1d9c9383..19b8349a3809 100644
--- a/include/linux/bpf_types.h
+++ b/include/linux/bpf_types.h
@@ -42,7 +42,7 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY_OF_MAPS, array_of_maps_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_HASH_OF_MAPS, htab_of_maps_map_ops)
 #ifdef CONFIG_NET
 BPF_MAP_TYPE(BPF_MAP_TYPE_DEVMAP, dev_map_ops)
-#ifdef CONFIG_STREAM_PARSER
+#if defined(CONFIG_STREAM_PARSER) && defined(CONFIG_INET)
 BPF_MAP_TYPE(BPF_MAP_TYPE_SOCKMAP, sock_map_ops)
 #endif
 BPF_MAP_TYPE(BPF_MAP_TYPE_CPUMAP, cpu_map_ops)
diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
index 1632bb13ad8a..6b66cd1aa0b9 100644
--- a/include/linux/bpf_verifier.h
+++ b/include/linux/bpf_verifier.h
@@ -76,6 +76,14 @@ struct bpf_reg_state {
         s64 smax_value; /* maximum possible (s64)value */
         u64 umin_value; /* minimum possible (u64)value */
         u64 umax_value; /* maximum possible (u64)value */
+        /* Inside the callee two registers can be both PTR_TO_STACK like
+         * R1=fp-8 and R2=fp-8, but one of them points to this function stack
+         * while another to the caller's stack. To differentiate them 'frameno'
+         * is used which is an index in bpf_verifier_state->frame[] array
+         * pointing to bpf_func_state.
+         * This field must be second to last, for states_equal() reasons.
+         */
+        u32 frameno;
         /* This field must be last, for states_equal() reasons. */
         enum bpf_reg_liveness live;
 };
@@ -83,7 +91,8 @@ struct bpf_reg_state {
 enum bpf_stack_slot_type {
         STACK_INVALID,    /* nothing was stored in this stack slot */
         STACK_SPILL,      /* register spilled into stack */
-        STACK_MISC        /* BPF program wrote some data into this slot */
+        STACK_MISC,       /* BPF program wrote some data into this slot */
+        STACK_ZERO,       /* BPF program wrote constant zero */
 };
 
 #define BPF_REG_SIZE 8  /* size of eBPF register in bytes */
@@ -96,13 +105,34 @@ struct bpf_stack_state {
 /* state of the program:
  * type of all registers and stack info
  */
-struct bpf_verifier_state {
+struct bpf_func_state {
         struct bpf_reg_state regs[MAX_BPF_REG];
         struct bpf_verifier_state *parent;
+        /* index of call instruction that called into this func */
+        int callsite;
+        /* stack frame number of this function state from pov of
+         * enclosing bpf_verifier_state.
+         * 0 = main function, 1 = first callee.
+         */
+        u32 frameno;
+        /* subprog number == index within subprog_stack_depth
+         * zero == main subprog
+         */
+        u32 subprogno;
+
+        /* should be second to last. See copy_func_state() */
         int allocated_stack;
         struct bpf_stack_state *stack;
 };
 
+#define MAX_CALL_FRAMES 8
+struct bpf_verifier_state {
+        /* call stack tracking */
+        struct bpf_func_state *frame[MAX_CALL_FRAMES];
+        struct bpf_verifier_state *parent;
+        u32 curframe;
+};
+
 /* linked list of verifier states used to prune search */
 struct bpf_verifier_state_list {
         struct bpf_verifier_state state;
@@ -113,6 +143,7 @@ struct bpf_insn_aux_data {
         union {
                 enum bpf_reg_type ptr_type;     /* pointer type for load/store insns */
                 struct bpf_map *map_ptr;        /* pointer for call insn into lookup_elem */
+                s32 call_imm;                   /* saved imm field of call insn */
         };
         int ctx_field_size; /* the ctx field size for load insn, maybe 0 */
         bool seen; /* this insn was processed by the verifier */
@@ -135,11 +166,7 @@ static inline bool bpf_verifier_log_full(const struct bpf_verifer_log *log)
         return log->len_used >= log->len_total - 1;
 }
 
-struct bpf_verifier_env;
-struct bpf_ext_analyzer_ops {
-        int (*insn_hook)(struct bpf_verifier_env *env,
-                         int insn_idx, int prev_insn_idx);
-};
+#define BPF_MAX_SUBPROGS 256
 
 /* single container for all structs
  * one verifier_env per bpf_check() call
@@ -152,29 +179,31 @@ struct bpf_verifier_env {
         bool strict_alignment;          /* perform strict pointer alignment checks */
         struct bpf_verifier_state *cur_state; /* current verifier state */
         struct bpf_verifier_state_list **explored_states; /* search pruning optimization */
-        const struct bpf_ext_analyzer_ops *dev_ops; /* device analyzer ops */
         struct bpf_map *used_maps[MAX_USED_MAPS]; /* array of map's used by eBPF program */
         u32 used_map_cnt;               /* number of used maps */
         u32 id_gen;                     /* used to generate unique reg IDs */
         bool allow_ptr_leaks;
         bool seen_direct_write;
         struct bpf_insn_aux_data *insn_aux_data; /* array of per-insn state */
-
         struct bpf_verifer_log log;
+        u32 subprog_starts[BPF_MAX_SUBPROGS];
+        /* computes the stack depth of each bpf function */
+        u16 subprog_stack_depth[BPF_MAX_SUBPROGS + 1];
+        u32 subprog_cnt;
 };
 
+__printf(2, 3) void bpf_verifier_log_write(struct bpf_verifier_env *env,
+                                           const char *fmt, ...);
+
 static inline struct bpf_reg_state *cur_regs(struct bpf_verifier_env *env)
 {
-        return env->cur_state->regs;
+        struct bpf_verifier_state *cur = env->cur_state;
+
+        return cur->frame[cur->curframe]->regs;
 }
 
-#if defined(CONFIG_NET) && defined(CONFIG_BPF_SYSCALL)
 int bpf_prog_offload_verifier_prep(struct bpf_verifier_env *env);
-#else
-static inline int bpf_prog_offload_verifier_prep(struct bpf_verifier_env *env)
-{
-        return -EOPNOTSUPP;
-}
-#endif
+int bpf_prog_offload_verify_insn(struct bpf_verifier_env *env,
+                                 int insn_idx, int prev_insn_idx);
 
 #endif /* _LINUX_BPF_VERIFIER_H */
diff --git a/include/linux/brcmphy.h b/include/linux/brcmphy.h
index 8ff86b4c1b8a..d3339dd48b1a 100644
--- a/include/linux/brcmphy.h
+++ b/include/linux/brcmphy.h
@@ -14,6 +14,7 @@
 #define PHY_ID_BCM5241                  0x0143bc30
 #define PHY_ID_BCMAC131                 0x0143bc70
 #define PHY_ID_BCM5481                  0x0143bca0
+#define PHY_ID_BCM5395                  0x0143bcf0
 #define PHY_ID_BCM54810                 0x03625d00
 #define PHY_ID_BCM5482                  0x0143bcb0
 #define PHY_ID_BCM5411                  0x00206070
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 8b1bf8d3d4a2..894e5d125de6 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -81,11 +81,14 @@ struct buffer_head {
 /*
  * macro tricks to expand the set_buffer_foo(), clear_buffer_foo()
  * and buffer_foo() functions.
+ * To avoid reset buffer flags that are already set, because that causes
+ * a costly cache line transition, check the flag first.
  */
 #define BUFFER_FNS(bit, name)                                           \
 static __always_inline void set_buffer_##name(struct buffer_head *bh)   \
 {                                                                       \
-        set_bit(BH_##bit, &(bh)->b_state);                              \
+        if (!test_bit(BH_##bit, &(bh)->b_state))                        \
+                set_bit(BH_##bit, &(bh)->b_state);                      \
 }                                                                       \
 static __always_inline void clear_buffer_##name(struct buffer_head *bh) \
 {                                                                       \
@@ -151,7 +154,6 @@ void buffer_check_dirty_writeback(struct page *page,
 
 void mark_buffer_dirty(struct buffer_head *bh);
 void mark_buffer_write_io_error(struct buffer_head *bh);
-void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
 void touch_buffer(struct buffer_head *bh);
 void set_bh_page(struct buffer_head *bh,
                 struct page *page, unsigned long offset);
diff --git a/include/linux/build_bug.h b/include/linux/build_bug.h
index 3efed0d742a0..43d1fd50d433 100644
--- a/include/linux/build_bug.h
+++ b/include/linux/build_bug.h
@@ -8,7 +8,6 @@
 #define __BUILD_BUG_ON_NOT_POWER_OF_2(n) (0)
 #define BUILD_BUG_ON_NOT_POWER_OF_2(n) (0)
 #define BUILD_BUG_ON_ZERO(e) (0)
-#define BUILD_BUG_ON_NULL(e) ((void *)0)
 #define BUILD_BUG_ON_INVALID(e) (0)
 #define BUILD_BUG_ON_MSG(cond, msg) (0)
 #define BUILD_BUG_ON(condition) (0)
@@ -28,7 +27,6 @@
  * aren't permitted).
  */
 #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:(-!!(e)); }))
-#define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:(-!!(e)); }))
 
 /*
  * BUILD_BUG_ON_INVALID() permits the compiler to check the validity of the
diff --git a/include/linux/bvec.h b/include/linux/bvec.h
index ec8a4d7af6bd..fe7a22dd133b 100644
--- a/include/linux/bvec.h
+++ b/include/linux/bvec.h
@@ -125,4 +125,13 @@ static inline bool bvec_iter_rewind(const struct bio_vec *bv,
                 ((bvl = bvec_iter_bvec((bio_vec), (iter))), 1); \
              bvec_iter_advance((bio_vec), &(iter), (bvl).bv_len))
 
+/* for iterating one bio from start to end */
+#define BVEC_ITER_ALL_INIT (struct bvec_iter)                           \
+{                                                                       \
+        .bi_sector      = 0,                                            \
+        .bi_size        = UINT_MAX,                                     \
+        .bi_idx         = 0,                                            \
+        .bi_bvec_done   = 0,                                            \
+}
+
 #endif /* __LINUX_BVEC_ITER_H */
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index 61f1cf2d9f44..055aaf5ed9af 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -46,6 +46,7 @@ struct can_priv {
         unsigned int bitrate_const_cnt;
         const u32 *data_bitrate_const;
         unsigned int data_bitrate_const_cnt;
+        u32 bitrate_max;
         struct can_clock clock;
 
         enum can_state state;
@@ -166,6 +167,12 @@ void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
 unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx);
 void can_free_echo_skb(struct net_device *dev, unsigned int idx);
 
+#ifdef CONFIG_OF
+void of_can_transceiver(struct net_device *dev);
+#else
+static inline void of_can_transceiver(struct net_device *dev) { }
+#endif
+
 struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf);
 struct sk_buff *alloc_canfd_skb(struct net_device *dev,
                                 struct canfd_frame **cfd);
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
index 8b7fd8eeccee..9f242b876fde 100644
--- a/include/linux/cgroup-defs.h
+++ b/include/linux/cgroup-defs.h
@@ -561,7 +561,7 @@ struct cftype {
 
 /*
  * Control Group subsystem type.
- * See Documentation/cgroups/cgroups.txt for details
+ * See Documentation/cgroup-v1/cgroups.txt for details
  */
 struct cgroup_subsys {
         struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index 7c925e6211f1..f711be6e8c44 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -20,6 +20,8 @@
  * flags used across common struct clk.  these flags should only affect the
  * top-level framework.  custom flags for dealing with hardware specifics
  * belong in struct clk_foo
+ *
+ * Please update clk_flags[] in drivers/clk/clk.c when making changes here!
  */
 #define CLK_SET_RATE_GATE       BIT(0) /* must be gated across rate change */
 #define CLK_SET_PARENT_GATE     BIT(1) /* must be gated across re-parent */
@@ -412,7 +414,7 @@ extern const struct clk_ops clk_divider_ro_ops;
 
 unsigned long divider_recalc_rate(struct clk_hw *hw, unsigned long parent_rate,
                 unsigned int val, const struct clk_div_table *table,
-                unsigned long flags);
+                unsigned long flags, unsigned long width);
 long divider_round_rate_parent(struct clk_hw *hw, struct clk_hw *parent,
                                unsigned long rate, unsigned long *prate,
                                const struct clk_div_table *table,
@@ -744,6 +746,7 @@ unsigned long clk_hw_get_rate(const struct clk_hw *hw);
 unsigned long __clk_get_flags(struct clk *clk);
 unsigned long clk_hw_get_flags(const struct clk_hw *hw);
 bool clk_hw_is_prepared(const struct clk_hw *hw);
+bool clk_hw_rate_is_protected(const struct clk_hw *hw);
 bool clk_hw_is_enabled(const struct clk_hw *hw);
 bool __clk_is_enabled(struct clk *clk);
 struct clk *__clk_lookup(const char *name);
@@ -806,6 +809,44 @@ extern struct of_device_id __clk_of_table;
         }                                                               \
         OF_DECLARE_1(clk, name, compat, name##_of_clk_init_driver)
 
+#define CLK_HW_INIT(_name, _parent, _ops, _flags)               \
+        (&(struct clk_init_data) {                              \
+                .flags          = _flags,                       \
+                .name           = _name,                        \
+                .parent_names   = (const char *[]) { _parent }, \
+                .num_parents    = 1,                            \
+                .ops            = _ops,                         \
+        })
+
+#define CLK_HW_INIT_PARENTS(_name, _parents, _ops, _flags)      \
+        (&(struct clk_init_data) {                              \
+                .flags          = _flags,                       \
+                .name           = _name,                        \
+                .parent_names   = _parents,                     \
+                .num_parents    = ARRAY_SIZE(_parents),         \
+                .ops            = _ops,                         \
+        })
+
+#define CLK_HW_INIT_NO_PARENT(_name, _ops, _flags)      \
+        (&(struct clk_init_data) {                      \
+                .flags          = _flags,               \
+                .name           = _name,                \
+                .parent_names   = NULL,                 \
+                .num_parents    = 0,                    \
+                .ops            = _ops,                 \
+        })
+
+#define CLK_FIXED_FACTOR(_struct, _name, _parent,                       \
+                        _div, _mult, _flags)                            \
+        struct clk_fixed_factor _struct = {                             \
+                .div            = _div,                                 \
+                .mult           = _mult,                                \
+                .hw.init        = CLK_HW_INIT(_name,                    \
+                                              _parent,                  \
+                                              &clk_fixed_factor_ops,    \
+                                              _flags),                  \
+        }
+
 #ifdef CONFIG_OF
 int of_clk_add_provider(struct device_node *np,
                         struct clk *(*clk_src_get)(struct of_phandle_args *args,
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 12c96d94d1fa..4c4ef9f34db3 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -331,6 +331,38 @@ struct clk *devm_clk_get(struct device *dev, const char *id);
  */
 struct clk *devm_get_clk_from_child(struct device *dev,
                                     struct device_node *np, const char *con_id);
+/**
+ * clk_rate_exclusive_get - get exclusivity over the rate control of a
+ *                          producer
+ * @clk: clock source
+ *
+ * This function allows drivers to get exclusive control over the rate of a
+ * provider. It prevents any other consumer to execute, even indirectly,
+ * opereation which could alter the rate of the provider or cause glitches
+ *
+ * If exlusivity is claimed more than once on clock, even by the same driver,
+ * the rate effectively gets locked as exclusivity can't be preempted.
+ *
+ * Must not be called from within atomic context.
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_rate_exclusive_get(struct clk *clk);
+
+/**
+ * clk_rate_exclusive_put - release exclusivity over the rate control of a
+ *                          producer
+ * @clk: clock source
+ *
+ * This function allows drivers to release the exclusivity it previously got
+ * from clk_rate_exclusive_get()
+ *
+ * The caller must balance the number of clk_rate_exclusive_get() and
+ * clk_rate_exclusive_put() calls.
+ *
+ * Must not be called from within atomic context.
+ */
+void clk_rate_exclusive_put(struct clk *clk);
 
 /**
  * clk_enable - inform the system when the clock source should be running.
@@ -473,6 +505,23 @@ long clk_round_rate(struct clk *clk, unsigned long rate);
 int clk_set_rate(struct clk *clk, unsigned long rate);
 
 /**
+ * clk_set_rate_exclusive- set the clock rate and claim exclusivity over
+ *                         clock source
+ * @clk: clock source
+ * @rate: desired clock rate in Hz
+ *
+ * This helper function allows drivers to atomically set the rate of a producer
+ * and claim exclusivity over the rate control of the producer.
+ *
+ * It is essentially a combination of clk_set_rate() and
+ * clk_rate_exclusite_get(). Caller must balance this call with a call to
+ * clk_rate_exclusive_put()
+ *
+ * Returns success (0) or negative errno.
+ */
+int clk_set_rate_exclusive(struct clk *clk, unsigned long rate);
+
+/**
  * clk_has_parent - check if a clock is a possible parent for another
  * @clk: clock source
  * @parent: parent clock source
@@ -583,6 +632,14 @@ static inline void clk_bulk_put(int num_clks, struct clk_bulk_data *clks) {}
 
 static inline void devm_clk_put(struct device *dev, struct clk *clk) {}
 
+
+static inline int clk_rate_exclusive_get(struct clk *clk)
+{
+        return 0;
+}
+
+static inline void clk_rate_exclusive_put(struct clk *clk) {}
+
 static inline int clk_enable(struct clk *clk)
 {
         return 0;
@@ -609,6 +666,11 @@ static inline int clk_set_rate(struct clk *clk, unsigned long rate)
         return 0;
 }
 
+static inline int clk_set_rate_exclusive(struct clk *clk, unsigned long rate)
+{
+        return 0;
+}
+
 static inline long clk_round_rate(struct clk *clk, unsigned long rate)
 {
         return 0;
diff --git a/include/linux/clkdev.h b/include/linux/clkdev.h
index 2eabc862abdb..4890ff033220 100644
--- a/include/linux/clkdev.h
+++ b/include/linux/clkdev.h
@@ -12,7 +12,7 @@
 #ifndef __CLKDEV_H
 #define __CLKDEV_H
 
-#include <asm/clkdev.h>
+#include <linux/slab.h>
 
 struct clk;
 struct clk_hw;
@@ -52,9 +52,4 @@ int clk_add_alias(const char *, const char *, const char *, struct device *);
 int clk_register_clkdev(struct clk *, const char *, const char *);
 int clk_hw_register_clkdev(struct clk_hw *, const char *, const char *);
 
-#ifdef CONFIG_COMMON_CLK
-int __clk_get(struct clk *clk);
-void __clk_put(struct clk *clk);
-#endif
-
 #endif
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 0fc36406f32c..8a9643857c4a 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -157,6 +157,104 @@ struct compat_sigaction {
         compat_sigset_t                 sa_mask __packed;
 };
 
+typedef union compat_sigval {
+        compat_int_t    sival_int;
+        compat_uptr_t   sival_ptr;
+} compat_sigval_t;
+
+typedef struct compat_siginfo {
+        int si_signo;
+#ifndef __ARCH_HAS_SWAPPED_SIGINFO
+        int si_errno;
+        int si_code;
+#else
+        int si_code;
+        int si_errno;
+#endif
+
+        union {
+                int _pad[128/sizeof(int) - 3];
+
+                /* kill() */
+                struct {
+                        compat_pid_t _pid;      /* sender's pid */
+                        __compat_uid32_t _uid;  /* sender's uid */
+                } _kill;
+
+                /* POSIX.1b timers */
+                struct {
+                        compat_timer_t _tid;    /* timer id */
+                        int _overrun;           /* overrun count */
+                        compat_sigval_t _sigval;        /* same as below */
+                } _timer;
+
+                /* POSIX.1b signals */
+                struct {
+                        compat_pid_t _pid;      /* sender's pid */
+                        __compat_uid32_t _uid;  /* sender's uid */
+                        compat_sigval_t _sigval;
+                } _rt;
+
+                /* SIGCHLD */
+                struct {
+                        compat_pid_t _pid;      /* which child */
+                        __compat_uid32_t _uid;  /* sender's uid */
+                        int _status;            /* exit code */
+                        compat_clock_t _utime;
+                        compat_clock_t _stime;
+                } _sigchld;
+
+#ifdef CONFIG_X86_X32_ABI
+                /* SIGCHLD (x32 version) */
+                struct {
+                        compat_pid_t _pid;      /* which child */
+                        __compat_uid32_t _uid;  /* sender's uid */
+                        int _status;            /* exit code */
+                        compat_s64 _utime;
+                        compat_s64 _stime;
+                } _sigchld_x32;
+#endif
+
+                /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGTRAP, SIGEMT */
+                struct {
+                        compat_uptr_t _addr;    /* faulting insn/memory ref. */
+#ifdef __ARCH_SI_TRAPNO
+                        int _trapno;    /* TRAP # which caused the signal */
+#endif
+                        union {
+                                /*
+                                 * used when si_code=BUS_MCEERR_AR or
+                                 * used when si_code=BUS_MCEERR_AO
+                                 */
+                                short int _addr_lsb;    /* Valid LSB of the reported address. */
+                                /* used when si_code=SEGV_BNDERR */
+                                struct {
+                                        short _dummy_bnd;
+                                        compat_uptr_t _lower;
+                                        compat_uptr_t _upper;
+                                } _addr_bnd;
+                                /* used when si_code=SEGV_PKUERR */
+                                struct {
+                                        short _dummy_pkey;
+                                        u32 _pkey;
+                                } _addr_pkey;
+                        };
+                } _sigfault;
+
+                /* SIGPOLL */
+                struct {
+                        compat_long_t _band;    /* POLL_IN, POLL_OUT, POLL_MSG */
+                        int _fd;
+                } _sigpoll;
+
+                struct {
+                        compat_uptr_t _call_addr; /* calling user insn */
+                        int _syscall;   /* triggering system call number */
+                        unsigned int _arch;     /* AUDIT_ARCH_* of syscall */
+                } _sigsys;
+        } _sifields;
+} compat_siginfo_t;
+
 /*
  * These functions operate on 32- or 64-bit specs depending on
  * COMPAT_USE_64BIT_TIME, hence the void user pointer arguments.
@@ -412,7 +510,7 @@ long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
                        unsigned long bitmap_size);
 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
                        unsigned long bitmap_size);
-int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from);
+int copy_siginfo_from_user32(siginfo_t *to, const struct compat_siginfo __user *from);
 int copy_siginfo_to_user32(struct compat_siginfo __user *to, const siginfo_t *from);
 int get_compat_sigevent(struct sigevent *event,
                 const struct compat_sigevent __user *u_event);
diff --git a/include/linux/compiler-clang.h b/include/linux/compiler-clang.h
index 3b609edffa8f..d02a4df3f473 100644
--- a/include/linux/compiler-clang.h
+++ b/include/linux/compiler-clang.h
@@ -19,3 +19,11 @@
 
 #define randomized_struct_fields_start  struct {
 #define randomized_struct_fields_end    };
+
+/* all clang versions usable with the kernel support KASAN ABI version 5 */
+#define KASAN_ABI_VERSION 5
+
+/* emulate gcc's __SANITIZE_ADDRESS__ flag */
+#if __has_feature(address_sanitizer)
+#define __SANITIZE_ADDRESS__
+#endif
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 52e611ab9a6c..c2cc57a2f508 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -185,23 +185,21 @@ void __read_once_size(const volatile void *p, void *res, int size)
 
 #ifdef CONFIG_KASAN
 /*
- * This function is not 'inline' because __no_sanitize_address confilcts
+ * We can't declare function 'inline' because __no_sanitize_address confilcts
  * with inlining. Attempt to inline it may cause a build failure.
  *      https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
  * '__maybe_unused' allows us to avoid defined-but-not-used warnings.
  */
-static __no_sanitize_address __maybe_unused
-void __read_once_size_nocheck(const volatile void *p, void *res, int size)
-{
-        __READ_ONCE_SIZE;
-}
+# define __no_kasan_or_inline __no_sanitize_address __maybe_unused
 #else
-static __always_inline
+# define __no_kasan_or_inline __always_inline
+#endif
+
+static __no_kasan_or_inline
 void __read_once_size_nocheck(const volatile void *p, void *res, int size)
 {
         __READ_ONCE_SIZE;
 }
-#endif
 
 static __always_inline void __write_once_size(volatile void *p, void *res, int size)
 {
@@ -240,6 +238,7 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
  * required ordering.
  */
 #include <asm/barrier.h>
+#include <linux/kasan-checks.h>
 
 #define __READ_ONCE(x, check)                                           \
 ({                                                                      \
@@ -259,6 +258,13 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s
  */
 #define READ_ONCE_NOCHECK(x) __READ_ONCE(x, 0)
 
+static __no_kasan_or_inline
+unsigned long read_word_at_a_time(const void *addr)
+{
+        kasan_check_read(addr, 1);
+        return *(unsigned long *)addr;
+}
+
 #define WRITE_ONCE(x, val) \
 ({                                                      \
         union { typeof(x) __val; char __c[1]; } __u =   \
diff --git a/include/linux/cper.h b/include/linux/cper.h
index 723e952fde0d..d14ef4e77c8a 100644
--- a/include/linux/cper.h
+++ b/include/linux/cper.h
@@ -275,6 +275,50 @@ enum {
 #define CPER_ARM_INFO_FLAGS_PROPAGATED          BIT(2)
 #define CPER_ARM_INFO_FLAGS_OVERFLOW            BIT(3)
 
+#define CPER_ARM_CACHE_ERROR                    0
+#define CPER_ARM_TLB_ERROR                      1
+#define CPER_ARM_BUS_ERROR                      2
+#define CPER_ARM_VENDOR_ERROR                   3
+#define CPER_ARM_MAX_TYPE                       CPER_ARM_VENDOR_ERROR
+
+#define CPER_ARM_ERR_VALID_TRANSACTION_TYPE     BIT(0)
+#define CPER_ARM_ERR_VALID_OPERATION_TYPE       BIT(1)
+#define CPER_ARM_ERR_VALID_LEVEL                BIT(2)
+#define CPER_ARM_ERR_VALID_PROC_CONTEXT_CORRUPT BIT(3)
+#define CPER_ARM_ERR_VALID_CORRECTED            BIT(4)
+#define CPER_ARM_ERR_VALID_PRECISE_PC           BIT(5)
+#define CPER_ARM_ERR_VALID_RESTARTABLE_PC       BIT(6)
+#define CPER_ARM_ERR_VALID_PARTICIPATION_TYPE   BIT(7)
+#define CPER_ARM_ERR_VALID_TIME_OUT             BIT(8)
+#define CPER_ARM_ERR_VALID_ADDRESS_SPACE        BIT(9)
+#define CPER_ARM_ERR_VALID_MEM_ATTRIBUTES       BIT(10)
+#define CPER_ARM_ERR_VALID_ACCESS_MODE          BIT(11)
+
+#define CPER_ARM_ERR_TRANSACTION_SHIFT          16
+#define CPER_ARM_ERR_TRANSACTION_MASK           GENMASK(1,0)
+#define CPER_ARM_ERR_OPERATION_SHIFT            18
+#define CPER_ARM_ERR_OPERATION_MASK             GENMASK(3,0)
+#define CPER_ARM_ERR_LEVEL_SHIFT                22
+#define CPER_ARM_ERR_LEVEL_MASK                 GENMASK(2,0)
+#define CPER_ARM_ERR_PC_CORRUPT_SHIFT           25
+#define CPER_ARM_ERR_PC_CORRUPT_MASK            GENMASK(0,0)
+#define CPER_ARM_ERR_CORRECTED_SHIFT            26
+#define CPER_ARM_ERR_CORRECTED_MASK             GENMASK(0,0)
+#define CPER_ARM_ERR_PRECISE_PC_SHIFT           27
+#define CPER_ARM_ERR_PRECISE_PC_MASK            GENMASK(0,0)
+#define CPER_ARM_ERR_RESTARTABLE_PC_SHIFT       28
+#define CPER_ARM_ERR_RESTARTABLE_PC_MASK        GENMASK(0,0)
+#define CPER_ARM_ERR_PARTICIPATION_TYPE_SHIFT   29
+#define CPER_ARM_ERR_PARTICIPATION_TYPE_MASK    GENMASK(1,0)
+#define CPER_ARM_ERR_TIME_OUT_SHIFT             31
+#define CPER_ARM_ERR_TIME_OUT_MASK              GENMASK(0,0)
+#define CPER_ARM_ERR_ADDRESS_SPACE_SHIFT        32
+#define CPER_ARM_ERR_ADDRESS_SPACE_MASK         GENMASK(1,0)
+#define CPER_ARM_ERR_MEM_ATTRIBUTES_SHIFT       34
+#define CPER_ARM_ERR_MEM_ATTRIBUTES_MASK        GENMASK(8,0)
+#define CPER_ARM_ERR_ACCESS_MODE_SHIFT          43
+#define CPER_ARM_ERR_ACCESS_MODE_MASK           GENMASK(0,0)
+
 /*
  * All tables and structs must be byte-packed to match CPER
  * specification, since the tables are provided by the system BIOS
@@ -494,6 +538,8 @@ struct cper_sec_pcie {
 /* Reset to default packing */
 #pragma pack()
 
+extern const char * const cper_proc_error_type_strs[4];
+
 u64 cper_next_record_id(void);
 const char *cper_severity_str(unsigned int);
 const char *cper_mem_err_type_str(unsigned int);
@@ -503,5 +549,7 @@ void cper_mem_err_pack(const struct cper_sec_mem_err *,
                        struct cper_mem_err_compact *);
 const char *cper_mem_err_unpack(struct trace_seq *,
                                 struct cper_mem_err_compact *);
+void cper_print_proc_arm(const char *pfx,
+                         const struct cper_sec_proc_arm *proc);
 
 #endif
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 065f3a8eb486..21e8d248d956 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -629,6 +629,18 @@ static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
         for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++)
 
 /*
+ * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table
+ *      with index
+ * @pos:        the cpufreq_frequency_table * to use as a loop cursor.
+ * @table:      the cpufreq_frequency_table * to iterate over.
+ * @idx:        the table entry currently being processed
+ */
+
+#define cpufreq_for_each_entry_idx(pos, table, idx)     \
+        for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \
+                pos++, idx++)
+
+/*
  * cpufreq_for_each_valid_entry -     iterate over a cpufreq_frequency_table
  *      excluding CPUFREQ_ENTRY_INVALID frequencies.
  * @pos:        the cpufreq_frequency_table * to use as a loop cursor.
@@ -641,6 +653,21 @@ static inline void dev_pm_opp_free_cpufreq_table(struct device *dev,
                         continue;                                       \
                 else
 
+/*
+ * cpufreq_for_each_valid_entry_idx -     iterate with index over a cpufreq
+ *      frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies.
+ * @pos:        the cpufreq_frequency_table * to use as a loop cursor.
+ * @table:      the cpufreq_frequency_table * to iterate over.
+ * @idx:        the table entry currently being processed
+ */
+
+#define cpufreq_for_each_valid_entry_idx(pos, table, idx)               \
+        cpufreq_for_each_entry_idx(pos, table, idx)                     \
+                if (pos->frequency == CPUFREQ_ENTRY_INVALID)            \
+                        continue;                                       \
+                else
+
+
 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
                                     struct cpufreq_frequency_table *table);
 
@@ -667,19 +694,20 @@ static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy,
                                               unsigned int target_freq)
 {
         struct cpufreq_frequency_table *table = policy->freq_table;
-        struct cpufreq_frequency_table *pos, *best = table - 1;
+        struct cpufreq_frequency_table *pos;
         unsigned int freq;
+        int idx, best = -1;
 
-        cpufreq_for_each_valid_entry(pos, table) {
+        cpufreq_for_each_valid_entry_idx(pos, table, idx) {
                 freq = pos->frequency;
 
                 if (freq >= target_freq)
-                        return pos - table;
+                        return idx;
 
-                best = pos;
+                best = idx;
         }
 
-        return best - table;
+        return best;
 }
 
 /* Find lowest freq at or above target in a table in descending order */
@@ -687,28 +715,29 @@ static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy,
                                               unsigned int target_freq)
 {
         struct cpufreq_frequency_table *table = policy->freq_table;
-        struct cpufreq_frequency_table *pos, *best = table - 1;
+        struct cpufreq_frequency_table *pos;
         unsigned int freq;
+        int idx, best = -1;
 
-        cpufreq_for_each_valid_entry(pos, table) {
+        cpufreq_for_each_valid_entry_idx(pos, table, idx) {
                 freq = pos->frequency;
 
                 if (freq == target_freq)
-                        return pos - table;
+                        return idx;
 
                 if (freq > target_freq) {
-                        best = pos;
+                        best = idx;
                         continue;
                 }
 
                 /* No freq found above target_freq */
-                if (best == table - 1)
-                        return pos - table;
+                if (best == -1)
+                        return idx;
 
-                return best - table;
+                return best;
         }
 
-        return best - table;
+        return best;
 }
 
 /* Works only on sorted freq-tables */
@@ -728,28 +757,29 @@ static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy,
                                               unsigned int target_freq)
 {
         struct cpufreq_frequency_table *table = policy->freq_table;
-        struct cpufreq_frequency_table *pos, *best = table - 1;
+        struct cpufreq_frequency_table *pos;
         unsigned int freq;
+        int idx, best = -1;
 
-        cpufreq_for_each_valid_entry(pos, table) {
+        cpufreq_for_each_valid_entry_idx(pos, table, idx) {
                 freq = pos->frequency;
 
                 if (freq == target_freq)
-                        return pos - table;
+                        return idx;
 
                 if (freq < target_freq) {
-                        best = pos;
+                        best = idx;
                         continue;
                 }
 
                 /* No freq found below target_freq */
-                if (best == table - 1)
-                        return pos - table;
+                if (best == -1)
+                        return idx;
 
-                return best - table;
+                return best;
         }
 
-        return best - table;
+        return best;
 }
 
 /* Find highest freq at or below target in a table in descending order */
@@ -757,19 +787,20 @@ static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy,
                                               unsigned int target_freq)
 {
         struct cpufreq_frequency_table *table = policy->freq_table;
-        struct cpufreq_frequency_table *pos, *best = table - 1;
+        struct cpufreq_frequency_table *pos;
         unsigned int freq;
+        int idx, best = -1;
 
-        cpufreq_for_each_valid_entry(pos, table) {
+        cpufreq_for_each_valid_entry_idx(pos, table, idx) {
                 freq = pos->frequency;
 
                 if (freq <= target_freq)
-                        return pos - table;
+                        return idx;
 
-                best = pos;
+                best = idx;
         }
 
-        return best - table;
+        return best;
 }
 
 /* Works only on sorted freq-tables */
@@ -789,32 +820,33 @@ static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy,
                                               unsigned int target_freq)
 {
         struct cpufreq_frequency_table *table = policy->freq_table;
-        struct cpufreq_frequency_table *pos, *best = table - 1;
+        struct cpufreq_frequency_table *pos;
         unsigned int freq;
+        int idx, best = -1;
 
-        cpufreq_for_each_valid_entry(pos, table) {
+        cpufreq_for_each_valid_entry_idx(pos, table, idx) {
                 freq = pos->frequency;
 
                 if (freq == target_freq)
-                        return pos - table;
+                        return idx;
 
                 if (freq < target_freq) {
-                        best = pos;
+                        best = idx;
                         continue;
                 }
 
                 /* No freq found below target_freq */
-                if (best == table - 1)
-                        return pos - table;
+                if (best == -1)
+                        return idx;
 
                 /* Choose the closest freq */
-                if (target_freq - best->frequency > freq - target_freq)
-                        return pos - table;
+                if (target_freq - table[best].frequency > freq - target_freq)
+                        return idx;
 
-                return best - table;
+                return best;
         }
 
-        return best - table;
+        return best;
 }
 
 /* Find closest freq to target in a table in descending order */
@@ -822,32 +854,33 @@ static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy,
                                               unsigned int target_freq)
 {
         struct cpufreq_frequency_table *table = policy->freq_table;
-        struct cpufreq_frequency_table *pos, *best = table - 1;
+        struct cpufreq_frequency_table *pos;
         unsigned int freq;
+        int idx, best = -1;
 
-        cpufreq_for_each_valid_entry(pos, table) {
+        cpufreq_for_each_valid_entry_idx(pos, table, idx) {
                 freq = pos->frequency;
 
                 if (freq == target_freq)
-                        return pos - table;
+                        return idx;
 
                 if (freq > target_freq) {
-                        best = pos;
+                        best = idx;
                         continue;
                 }
 
                 /* No freq found above target_freq */
-                if (best == table - 1)
-                        return pos - table;
+                if (best == -1)
+                        return idx;
 
                 /* Choose the closest freq */
-                if (best->frequency - target_freq > target_freq - freq)
-                        return pos - table;
+                if (table[best].frequency - target_freq > target_freq - freq)
+                        return idx;
 
-                return best - table;
+                return best;
         }
 
-        return best - table;
+        return best;
 }
 
 /* Works only on sorted freq-tables */
diff --git a/include/linux/cpuhotplug.h b/include/linux/cpuhotplug.h
index 1a32e558eb11..5172ad0daa7c 100644
--- a/include/linux/cpuhotplug.h
+++ b/include/linux/cpuhotplug.h
@@ -59,6 +59,7 @@ enum cpuhp_state {
         CPUHP_PCI_XGENE_DEAD,
         CPUHP_IOMMU_INTEL_DEAD,
         CPUHP_LUSTRE_CFS_DEAD,
+        CPUHP_AP_ARM_CACHE_B15_RAC_DEAD,
         CPUHP_WORKQUEUE_PREP,
         CPUHP_POWER_NUMA_PREPARE,
         CPUHP_HRTIMERS_PREPARE,
@@ -109,6 +110,7 @@ enum cpuhp_state {
         CPUHP_AP_PERF_XTENSA_STARTING,
         CPUHP_AP_PERF_METAG_STARTING,
         CPUHP_AP_MIPS_OP_LOONGSON3_STARTING,
+        CPUHP_AP_ARM_SDEI_STARTING,
         CPUHP_AP_ARM_VFP_STARTING,
         CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING,
         CPUHP_AP_PERF_ARM_HW_BREAKPOINT_STARTING,
@@ -137,6 +139,7 @@ enum cpuhp_state {
         CPUHP_AP_ARM64_ISNDEP_STARTING,
         CPUHP_AP_SMPCFD_DYING,
         CPUHP_AP_X86_TBOOT_DYING,
+        CPUHP_AP_ARM_CACHE_B15_RAC_DYING,
         CPUHP_AP_ONLINE,
         CPUHP_TEARDOWN_CPU,
         CPUHP_AP_ONLINE_IDLE,
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 8f7788d23b57..871f9e21810c 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -257,22 +257,30 @@ static inline int cpuidle_register_governor(struct cpuidle_governor *gov)
 {return 0;}
 #endif
 
-#define CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx)        \
-({                                                              \
-        int __ret;                                              \
-                                                                \
-        if (!idx) {                                             \
-                cpu_do_idle();                                  \
-                return idx;                                     \
-        }                                                       \
-                                                                \
-        __ret = cpu_pm_enter();                                 \
-        if (!__ret) {                                           \
-                __ret = low_level_idle_enter(idx);              \
-                cpu_pm_exit();                                  \
-        }                                                       \
-                                                                \
-        __ret ? -1 : idx;                                       \
+#define __CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx, is_retention) \
+({                                                                      \
+        int __ret = 0;                                                  \
+                                                                        \
+        if (!idx) {                                                     \
+                cpu_do_idle();                                          \
+                return idx;                                             \
+        }                                                               \
+                                                                        \
+        if (!is_retention)                                              \
+                __ret =  cpu_pm_enter();                                \
+        if (!__ret) {                                                   \
+                __ret = low_level_idle_enter(idx);                      \
+                if (!is_retention)                                      \
+                        cpu_pm_exit();                                  \
+        }                                                               \
+                                                                        \
+        __ret ? -1 : idx;                                               \
 })
 
+#define CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx)        \
+        __CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx, 0)
+
+#define CPU_PM_CPU_IDLE_ENTER_RETENTION(low_level_idle_enter, idx)      \
+        __CPU_PM_CPU_IDLE_ENTER(low_level_idle_enter, idx, 1)
+
 #endif /* _LINUX_CPUIDLE_H */
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 75b565194437..d4a2a7dcd72d 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -640,7 +640,7 @@ static inline int cpulist_parse(const char *buf, struct cpumask *dstp)
 /**
  * cpumask_size - size to allocate for a 'struct cpumask' in bytes
  */
-static inline size_t cpumask_size(void)
+static inline unsigned int cpumask_size(void)
 {
         return BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long);
 }
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 1b8e41597ef5..934633a05d20 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -112,7 +112,7 @@ static inline int cpuset_do_slab_mem_spread(void)
         return task_spread_slab(current);
 }
 
-extern int current_cpuset_is_being_rebound(void);
+extern bool current_cpuset_is_being_rebound(void);
 
 extern void rebuild_sched_domains(void);
 
@@ -247,9 +247,9 @@ static inline int cpuset_do_slab_mem_spread(void)
         return 0;
 }
 
-static inline int current_cpuset_is_being_rebound(void)
+static inline bool current_cpuset_is_being_rebound(void)
 {
-        return 0;
+        return false;
 }
 
 static inline void rebuild_sched_domains(void)
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index a992e6ca2f1c..f7ac2aa93269 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
@@ -2,13 +2,13 @@
 #ifndef LINUX_CRASH_DUMP_H
 #define LINUX_CRASH_DUMP_H
 
-#ifdef CONFIG_CRASH_DUMP
 #include <linux/kexec.h>
 #include <linux/proc_fs.h>
 #include <linux/elf.h>
 
 #include <asm/pgtable.h> /* for pgprot_t */
 
+#ifdef CONFIG_CRASH_DUMP
 #define ELFCORE_ADDR_MAX        (-1ULL)
 #define ELFCORE_ADDR_ERR        (-2ULL)
 
@@ -52,13 +52,13 @@ void vmcore_cleanup(void);
  * has passed the elf core header address on command line.
  *
  * This is not just a test if CONFIG_CRASH_DUMP is enabled or not. It will
- * return 1 if CONFIG_CRASH_DUMP=y and if kernel is booting after a panic of
- * previous kernel.
+ * return true if CONFIG_CRASH_DUMP=y and if kernel is booting after a panic
+ * of previous kernel.
  */
 
-static inline int is_kdump_kernel(void)
+static inline bool is_kdump_kernel(void)
 {
-        return (elfcorehdr_addr != ELFCORE_ADDR_MAX) ? 1 : 0;
+        return elfcorehdr_addr != ELFCORE_ADDR_MAX;
 }
 
 /* is_vmcore_usable() checks if the kernel is booting after a panic and
@@ -89,7 +89,7 @@ extern int register_oldmem_pfn_is_ram(int (*fn)(unsigned long pfn));
 extern void unregister_oldmem_pfn_is_ram(void);
 
 #else /* !CONFIG_CRASH_DUMP */
-static inline int is_kdump_kernel(void) { return 0; }
+static inline bool is_kdump_kernel(void) { return 0; }
 #endif /* CONFIG_CRASH_DUMP */
 
 extern unsigned long saved_max_pfn;
diff --git a/include/linux/crc-ccitt.h b/include/linux/crc-ccitt.h
index cd4f420231ba..72c92c396bb8 100644
--- a/include/linux/crc-ccitt.h
+++ b/include/linux/crc-ccitt.h
@@ -5,12 +5,19 @@
 #include <linux/types.h>
 
 extern u16 const crc_ccitt_table[256];
+extern u16 const crc_ccitt_false_table[256];
 
 extern u16 crc_ccitt(u16 crc, const u8 *buffer, size_t len);
+extern u16 crc_ccitt_false(u16 crc, const u8 *buffer, size_t len);
 
 static inline u16 crc_ccitt_byte(u16 crc, const u8 c)
 {
         return (crc >> 8) ^ crc_ccitt_table[(crc ^ c) & 0xff];
 }
 
+static inline u16 crc_ccitt_false_byte(u16 crc, const u8 c)
+{
+    return (crc << 8) ^ crc_ccitt_false_table[(crc >> 8) ^ c];
+}
+
 #endif /* _LINUX_CRC_CCITT_H */
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 78508ca4b108..7e6e84cf6383 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -107,8 +107,16 @@
 #define CRYPTO_ALG_INTERNAL             0x00002000
 
 /*
+ * Set if the algorithm has a ->setkey() method but can be used without
+ * calling it first, i.e. there is a default key.
+ */
+#define CRYPTO_ALG_OPTIONAL_KEY         0x00004000
+
+/*
  * Transform masks and values (for crt_flags).
  */
+#define CRYPTO_TFM_NEED_KEY             0x00000001
+
 #define CRYPTO_TFM_REQ_MASK             0x000fff00
 #define CRYPTO_TFM_RES_MASK             0xfff00000
 
@@ -447,7 +455,7 @@ struct crypto_alg {
         unsigned int cra_alignmask;
 
         int cra_priority;
-        atomic_t cra_refcnt;
+        refcount_t cra_refcnt;
 
         char cra_name[CRYPTO_MAX_ALG_NAME];
         char cra_driver_name[CRYPTO_MAX_ALG_NAME];
diff --git a/include/linux/dax.h b/include/linux/dax.h
index 5258346c558c..0185ecdae135 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -96,7 +96,7 @@ bool dax_write_cache_enabled(struct dax_device *dax_dev);
 ssize_t dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter,
                 const struct iomap_ops *ops);
 int dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size,
-                    pfn_t *pfnp, const struct iomap_ops *ops);
+                    pfn_t *pfnp, int *errp, const struct iomap_ops *ops);
 int dax_finish_sync_fault(struct vm_fault *vmf, enum page_entry_size pe_size,
                           pfn_t pfn);
 int dax_delete_mapping_entry(struct address_space *mapping, pgoff_t index);
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 65cd8ab60b7a..82a99d366aec 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -227,6 +227,7 @@ extern seqlock_t rename_lock;
  */
 extern void d_instantiate(struct dentry *, struct inode *);
 extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
+extern struct dentry * d_instantiate_anon(struct dentry *, struct inode *);
 extern int d_instantiate_no_diralias(struct dentry *, struct inode *);
 extern void __d_drop(struct dentry *dentry);
 extern void d_drop(struct dentry *dentry);
@@ -235,6 +236,7 @@ extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op
 
 /* allocate/de-allocate */
 extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
+extern struct dentry * d_alloc_anon(struct super_block *);
 extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
 extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *,
                                         wait_queue_head_t *);
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index a5538433c927..da83f64952e7 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -28,6 +28,7 @@ enum dm_queue_mode {
         DM_TYPE_REQUEST_BASED    = 2,
         DM_TYPE_MQ_REQUEST_BASED = 3,
         DM_TYPE_DAX_BIO_BASED    = 4,
+        DM_TYPE_NVME_BIO_BASED   = 5,
 };
 
 typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
@@ -221,14 +222,6 @@ struct target_type {
 #define dm_target_is_wildcard(type)     ((type)->features & DM_TARGET_WILDCARD)
 
 /*
- * Some targets need to be sent the same WRITE bio severals times so
- * that they can send copies of it to different devices.  This function
- * examines any supplied bio and returns the number of copies of it the
- * target requires.
- */
-typedef unsigned (*dm_num_write_bios_fn) (struct dm_target *ti, struct bio *bio);
-
-/*
  * A target implements own bio data integrity.
  */
 #define DM_TARGET_INTEGRITY             0x00000010
@@ -291,13 +284,6 @@ struct dm_target {
          */
         unsigned per_io_data_size;
 
-        /*
-         * If defined, this function is called to find out how many
-         * duplicate bios should be sent to the target when writing
-         * data.
-         */
-        dm_num_write_bios_fn num_write_bios;
-
         /* target specific data */
         void *private;
 
@@ -329,35 +315,9 @@ struct dm_target_callbacks {
         int (*congested_fn) (struct dm_target_callbacks *, int);
 };
 
-/*
- * For bio-based dm.
- * One of these is allocated for each bio.
- * This structure shouldn't be touched directly by target drivers.
- * It is here so that we can inline dm_per_bio_data and
- * dm_bio_from_per_bio_data
- */
-struct dm_target_io {
-        struct dm_io *io;
-        struct dm_target *ti;
-        unsigned target_bio_nr;
-        unsigned *len_ptr;
-        struct bio clone;
-};
-
-static inline void *dm_per_bio_data(struct bio *bio, size_t data_size)
-{
-        return (char *)bio - offsetof(struct dm_target_io, clone) - data_size;
-}
-
-static inline struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size)
-{
-        return (struct bio *)((char *)data + data_size + offsetof(struct dm_target_io, clone));
-}
-
-static inline unsigned dm_bio_get_target_bio_nr(const struct bio *bio)
-{
-        return container_of(bio, struct dm_target_io, clone)->target_bio_nr;
-}
+void *dm_per_bio_data(struct bio *bio, size_t data_size);
+struct bio *dm_bio_from_per_bio_data(void *data, size_t data_size);
+unsigned dm_bio_get_target_bio_nr(const struct bio *bio);
 
 int dm_register_target(struct target_type *t);
 void dm_unregister_target(struct target_type *t);
@@ -500,6 +460,11 @@ void dm_table_set_type(struct dm_table *t, enum dm_queue_mode type);
 int dm_table_complete(struct dm_table *t);
 
 /*
+ * Destroy the table when finished.
+ */
+void dm_table_destroy(struct dm_table *t);
+
+/*
  * Target may require that it is never sent I/O larger than len.
  */
 int __must_check dm_set_target_max_io_len(struct dm_target *ti, sector_t len);
@@ -585,6 +550,7 @@ do {									\
 #define DM_ENDIO_DONE           0
 #define DM_ENDIO_INCOMPLETE     1
 #define DM_ENDIO_REQUEUE        2
+#define DM_ENDIO_DELAY_REQUEUE  3
 
 /*
  * Definitions of return values from target map function.
@@ -592,7 +558,7 @@ do {									\
 #define DM_MAPIO_SUBMITTED      0
 #define DM_MAPIO_REMAPPED       1
 #define DM_MAPIO_REQUEUE        DM_ENDIO_REQUEUE
-#define DM_MAPIO_DELAY_REQUEUE  3
+#define DM_MAPIO_DELAY_REQUEUE  DM_ENDIO_DELAY_REQUEUE
 #define DM_MAPIO_KILL           4
 
 #define dm_sector_div64(x, y)( \
diff --git a/include/linux/device.h b/include/linux/device.h
index 9d32000725da..b093405ed525 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * device.h - generic, centralized driver model
  *
@@ -5,8 +6,6 @@
  * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
  * Copyright (c) 2008-2009 Novell Inc.
  *
- * This file is released under the GPLv2
- *
  * See Documentation/driver-model/ for more information.
  */
 
@@ -21,7 +20,6 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
 #include <linux/mutex.h>
-#include <linux/pinctrl/devinfo.h>
 #include <linux/pm.h>
 #include <linux/atomic.h>
 #include <linux/ratelimit.h>
@@ -42,6 +40,7 @@ struct fwnode_handle;
 struct iommu_ops;
 struct iommu_group;
 struct iommu_fwspec;
+struct dev_pin_info;
 
 struct bus_attribute {
         struct attribute        attr;
@@ -288,6 +287,7 @@ struct device_driver {
         const struct attribute_group **groups;
 
         const struct dev_pm_ops *pm;
+        int (*coredump) (struct device *dev);
 
         struct driver_private *p;
 };
@@ -301,7 +301,6 @@ extern struct device_driver *driver_find(const char *name,
 extern int driver_probe_done(void);
 extern void wait_for_device_probe(void);
 
-
 /* sysfs interface for exporting driver attributes */
 
 struct driver_attribute {
@@ -575,6 +574,9 @@ ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
 
 #define DEVICE_ATTR(_name, _mode, _show, _store) \
         struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
+#define DEVICE_ATTR_PREALLOC(_name, _mode, _show, _store) \
+        struct device_attribute dev_attr_##_name = \
+                __ATTR_PREALLOC(_name, _mode, _show, _store)
 #define DEVICE_ATTR_RW(_name) \
         struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
 #define DEVICE_ATTR_RO(_name) \
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index 79f27d60ec66..085db2fee2d7 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -301,7 +301,7 @@ struct dma_buf {
                 struct dma_fence_cb cb;
                 wait_queue_head_t *poll;
 
-                unsigned long active;
+                __poll_t active;
         } cb_excl, cb_shared;
 };
 
diff --git a/include/linux/dma-direct.h b/include/linux/dma-direct.h
new file mode 100644
index 000000000000..bcdb1a3e4b1f
--- /dev/null
+++ b/include/linux/dma-direct.h
@@ -0,0 +1,47 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_DMA_DIRECT_H
+#define _LINUX_DMA_DIRECT_H 1
+
+#include <linux/dma-mapping.h>
+
+#ifdef CONFIG_ARCH_HAS_PHYS_TO_DMA
+#include <asm/dma-direct.h>
+#else
+static inline dma_addr_t phys_to_dma(struct device *dev, phys_addr_t paddr)
+{
+        dma_addr_t dev_addr = (dma_addr_t)paddr;
+
+        return dev_addr - ((dma_addr_t)dev->dma_pfn_offset << PAGE_SHIFT);
+}
+
+static inline phys_addr_t dma_to_phys(struct device *dev, dma_addr_t dev_addr)
+{
+        phys_addr_t paddr = (phys_addr_t)dev_addr;
+
+        return paddr + ((phys_addr_t)dev->dma_pfn_offset << PAGE_SHIFT);
+}
+
+static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
+{
+        if (!dev->dma_mask)
+                return false;
+
+        return addr + size - 1 <= *dev->dma_mask;
+}
+#endif /* !CONFIG_ARCH_HAS_PHYS_TO_DMA */
+
+#ifdef CONFIG_ARCH_HAS_DMA_MARK_CLEAN
+void dma_mark_clean(void *addr, size_t size);
+#else
+static inline void dma_mark_clean(void *addr, size_t size)
+{
+}
+#endif /* CONFIG_ARCH_HAS_DMA_MARK_CLEAN */
+
+void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
+                gfp_t gfp, unsigned long attrs);
+void dma_direct_free(struct device *dev, size_t size, void *cpu_addr,
+                dma_addr_t dma_addr, unsigned long attrs);
+int dma_direct_supported(struct device *dev, u64 mask);
+
+#endif /* _LINUX_DMA_DIRECT_H */
diff --git a/include/linux/dma-fence-array.h b/include/linux/dma-fence-array.h
index 332a5420243c..bc8940ca280d 100644
--- a/include/linux/dma-fence-array.h
+++ b/include/linux/dma-fence-array.h
@@ -21,6 +21,7 @@
 #define __LINUX_DMA_FENCE_ARRAY_H
 
 #include <linux/dma-fence.h>
+#include <linux/irq_work.h>
 
 /**
  * struct dma_fence_array_cb - callback helper for fence array
@@ -47,6 +48,8 @@ struct dma_fence_array {
         unsigned num_fences;
         atomic_t num_pending;
         struct dma_fence **fences;
+
+        struct irq_work work;
 };
 
 extern const struct dma_fence_ops dma_fence_array_ops;
diff --git a/include/linux/dma-fence.h b/include/linux/dma-fence.h
index efdabbb64e3c..4c008170fe65 100644
--- a/include/linux/dma-fence.h
+++ b/include/linux/dma-fence.h
@@ -242,7 +242,7 @@ static inline struct dma_fence *dma_fence_get_rcu(struct dma_fence *fence)
  * The caller is required to hold the RCU read lock.
  */
 static inline struct dma_fence *
-dma_fence_get_rcu_safe(struct dma_fence * __rcu *fencep)
+dma_fence_get_rcu_safe(struct dma_fence __rcu **fencep)
 {
         do {
                 struct dma_fence *fence;
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 81ed9b2d84dc..34fe8463d10e 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -136,7 +136,7 @@ struct dma_map_ops {
         int is_phys;
 };
 
-extern const struct dma_map_ops dma_noop_ops;
+extern const struct dma_map_ops dma_direct_ops;
 extern const struct dma_map_ops dma_virt_ops;
 
 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
@@ -513,10 +513,18 @@ static inline void *dma_alloc_attrs(struct device *dev, size_t size,
         void *cpu_addr;
 
         BUG_ON(!ops);
+        WARN_ON_ONCE(dev && !dev->coherent_dma_mask);
 
         if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr))
                 return cpu_addr;
 
+        /*
+         * Let the implementation decide on the zone to allocate from, and
+         * decide on the way of zeroing the memory given that the memory
+         * returned should always be zeroed.
+         */
+        flag &= ~(__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM | __GFP_ZERO);
+
         if (!arch_dma_alloc_attrs(&dev, &flag))
                 return NULL;
         if (!ops->alloc)
@@ -568,6 +576,14 @@ static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
         return 0;
 }
 
+/*
+ * This is a hack for the legacy x86 forbid_dac and iommu_sac_force. Please
+ * don't use this is new code.
+ */
+#ifndef arch_dma_supported
+#define arch_dma_supported(dev, mask)   (1)
+#endif
+
 static inline void dma_check_mask(struct device *dev, u64 mask)
 {
         if (sme_active() && (mask < (((u64)sme_get_me_mask() << 1) - 1)))
@@ -580,6 +596,9 @@ static inline int dma_supported(struct device *dev, u64 mask)
 
         if (!ops)
                 return 0;
+        if (!arch_dma_supported(dev, mask))
+                return 0;
+
         if (!ops->dma_supported)
                 return 1;
         return ops->dma_supported(dev, mask);
@@ -692,7 +711,7 @@ static inline int dma_set_seg_boundary(struct device *dev, unsigned long mask)
 #ifndef dma_max_pfn
 static inline unsigned long dma_max_pfn(struct device *dev)
 {
-        return *dev->dma_mask >> PAGE_SHIFT;
+        return (*dev->dma_mask >> PAGE_SHIFT) + dev->dma_pfn_offset;
 }
 #endif
 
diff --git a/include/linux/dsa/lan9303.h b/include/linux/dsa/lan9303.h
index f48a85c377de..b4f22112ba75 100644
--- a/include/linux/dsa/lan9303.h
+++ b/include/linux/dsa/lan9303.h
@@ -23,9 +23,10 @@ struct lan9303 {
         struct regmap_irq_chip_data *irq_data;
         struct gpio_desc *reset_gpio;
         u32 reset_duration; /* in [ms] */
-        bool phy_addr_sel_strap;
+        int phy_addr_base;
         struct dsa_switch *ds;
         struct mutex indirect_mutex; /* protect indexed register access */
+        struct mutex alr_mutex; /* protect ALR access */
         const struct lan9303_phy_ops *ops;
         bool is_bridged; /* true if port 1 and 2 are bridged */
 
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 29fdf8029cf6..f5083aa72eae 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -475,6 +475,39 @@ typedef struct {
         u64 get_all;
 } apple_properties_protocol_64_t;
 
+typedef struct {
+        u32 get_capability;
+        u32 get_event_log;
+        u32 hash_log_extend_event;
+        u32 submit_command;
+        u32 get_active_pcr_banks;
+        u32 set_active_pcr_banks;
+        u32 get_result_of_set_active_pcr_banks;
+} efi_tcg2_protocol_32_t;
+
+typedef struct {
+        u64 get_capability;
+        u64 get_event_log;
+        u64 hash_log_extend_event;
+        u64 submit_command;
+        u64 get_active_pcr_banks;
+        u64 set_active_pcr_banks;
+        u64 get_result_of_set_active_pcr_banks;
+} efi_tcg2_protocol_64_t;
+
+typedef u32 efi_tcg2_event_log_format;
+
+typedef struct {
+        void *get_capability;
+        efi_status_t (*get_event_log)(efi_handle_t, efi_tcg2_event_log_format,
+                efi_physical_addr_t *, efi_physical_addr_t *, efi_bool_t *);
+        void *hash_log_extend_event;
+        void *submit_command;
+        void *get_active_pcr_banks;
+        void *set_active_pcr_banks;
+        void *get_result_of_set_active_pcr_banks;
+} efi_tcg2_protocol_t;
+
 /*
  * Types and defines for EFI ResetSystem
  */
@@ -625,6 +658,7 @@ void efi_native_runtime_setup(void);
 #define EFI_MEMORY_ATTRIBUTES_TABLE_GUID        EFI_GUID(0xdcfa911d, 0x26eb, 0x469f,  0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20)
 #define EFI_CONSOLE_OUT_DEVICE_GUID             EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4,  0x9a, 0x46, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
 #define APPLE_PROPERTIES_PROTOCOL_GUID          EFI_GUID(0x91bd12fe, 0xf6c3, 0x44fb,  0xa5, 0xb7, 0x51, 0x22, 0xab, 0x30, 0x3a, 0xe0)
+#define EFI_TCG2_PROTOCOL_GUID                  EFI_GUID(0x607f766c, 0x7455, 0x42be,  0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f)
 
 #define EFI_IMAGE_SECURITY_DATABASE_GUID        EFI_GUID(0xd719b2cb, 0x3d3a, 0x4596,  0xa3, 0xbc, 0xda, 0xd0, 0x0e, 0x67, 0x65, 0x6f)
 #define EFI_SHIM_LOCK_GUID                      EFI_GUID(0x605dab50, 0xe046, 0x4300,  0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23)
@@ -637,6 +671,7 @@ void efi_native_runtime_setup(void);
 #define LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID    EFI_GUID(0xe03fc20a, 0x85dc, 0x406e,  0xb9, 0x0e, 0x4a, 0xb5, 0x02, 0x37, 0x1d, 0x95)
 #define LINUX_EFI_LOADER_ENTRY_GUID             EFI_GUID(0x4a67b082, 0x0a4c, 0x41cf,  0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f)
 #define LINUX_EFI_RANDOM_SEED_TABLE_GUID        EFI_GUID(0x1ce1e5bc, 0x7ceb, 0x42f2,  0x81, 0xe5, 0x8a, 0xad, 0xf1, 0x80, 0xf5, 0x7b)
+#define LINUX_EFI_TPM_EVENT_LOG_GUID            EFI_GUID(0xb7799cb0, 0xeca2, 0x4943,  0x96, 0x67, 0x1f, 0xae, 0x07, 0xb7, 0x47, 0xfa)
 
 typedef struct {
         efi_guid_t guid;
@@ -911,6 +946,7 @@ extern struct efi {
         unsigned long properties_table; /* properties table */
         unsigned long mem_attr_table;   /* memory attributes table */
         unsigned long rng_seed;         /* UEFI firmware random seed */
+        unsigned long tpm_log;          /* TPM2 Event Log table */
         efi_get_time_t *get_time;
         efi_set_time_t *set_time;
         efi_get_wakeup_time_t *get_wakeup_time;
@@ -1536,6 +1572,8 @@ static inline void
 efi_enable_reset_attack_mitigation(efi_system_table_t *sys_table_arg) { }
 #endif
 
+void efi_retrieve_tpm2_eventlog(efi_system_table_t *sys_table);
+
 /*
  * Arch code can implement the following three template macros, avoiding
  * reptition for the void/non-void return cases of {__,}efi_call_virt():
@@ -1603,4 +1641,12 @@ struct linux_efi_random_seed {
         u8      bits[];
 };
 
+struct linux_efi_tpm_eventlog {
+        u32     size;
+        u8      version;
+        u8      log[];
+};
+
+extern int efi_tpm_eventlog_init(void);
+
 #endif /* _LINUX_EFI_H */
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index 3d794b3dc532..6d9e230dffd2 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -198,8 +198,6 @@ extern bool elv_attempt_insert_merge(struct request_queue *, struct request *);
 extern void elv_requeue_request(struct request_queue *, struct request *);
 extern struct request *elv_former_request(struct request_queue *, struct request *);
 extern struct request *elv_latter_request(struct request_queue *, struct request *);
-extern int elv_register_queue(struct request_queue *q);
-extern void elv_unregister_queue(struct request_queue *q);
 extern int elv_may_queue(struct request_queue *, unsigned int);
 extern void elv_completed_request(struct request_queue *, struct request *);
 extern int elv_set_request(struct request_queue *q, struct request *rq,
diff --git a/include/linux/error-injection.h b/include/linux/error-injection.h
new file mode 100644
index 000000000000..280c61ecbf20
--- /dev/null
+++ b/include/linux/error-injection.h
@@ -0,0 +1,27 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_ERROR_INJECTION_H
+#define _LINUX_ERROR_INJECTION_H
+
+#ifdef CONFIG_FUNCTION_ERROR_INJECTION
+
+#include <asm/error-injection.h>
+
+extern bool within_error_injection_list(unsigned long addr);
+extern int get_injectable_error_type(unsigned long addr);
+
+#else /* !CONFIG_FUNCTION_ERROR_INJECTION */
+
+#include <asm-generic/error-injection.h>
+static inline bool within_error_injection_list(unsigned long addr)
+{
+        return false;
+}
+
+static inline int get_injectable_error_type(unsigned long addr)
+{
+        return EI_ETYPE_NONE;
+}
+
+#endif
+
+#endif /* _LINUX_ERROR_INJECTION_H */
diff --git a/include/linux/errseq.h b/include/linux/errseq.h
index 6ffae9c5052d..fc2777770768 100644
--- a/include/linux/errseq.h
+++ b/include/linux/errseq.h
@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 /*
- * See Documentation/errseq.rst and lib/errseq.c
+ * See Documentation/core-api/errseq.rst and lib/errseq.c
  */
 #ifndef _LINUX_ERRSEQ_H
 #define _LINUX_ERRSEQ_H
diff --git a/include/linux/eventfd.h b/include/linux/eventfd.h
index 60b2985e8a18..7094718b653b 100644
--- a/include/linux/eventfd.h
+++ b/include/linux/eventfd.h
@@ -26,18 +26,16 @@
 #define EFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK)
 #define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE)
 
+struct eventfd_ctx;
 struct file;
 
 #ifdef CONFIG_EVENTFD
 
-struct file *eventfd_file_create(unsigned int count, int flags);
-struct eventfd_ctx *eventfd_ctx_get(struct eventfd_ctx *ctx);
 void eventfd_ctx_put(struct eventfd_ctx *ctx);
 struct file *eventfd_fget(int fd);
 struct eventfd_ctx *eventfd_ctx_fdget(int fd);
 struct eventfd_ctx *eventfd_ctx_fileget(struct file *file);
 __u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n);
-ssize_t eventfd_ctx_read(struct eventfd_ctx *ctx, int no_wait, __u64 *cnt);
 int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *wait,
                                   __u64 *cnt);
 
@@ -47,10 +45,6 @@ int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *w
  * Ugly ugly ugly error layer to support modules that uses eventfd but
  * pretend to work in !CONFIG_EVENTFD configurations. Namely, AIO.
  */
-static inline struct file *eventfd_file_create(unsigned int count, int flags)
-{
-        return ERR_PTR(-ENOSYS);
-}
 
 static inline struct eventfd_ctx *eventfd_ctx_fdget(int fd)
 {
@@ -67,12 +61,6 @@ static inline void eventfd_ctx_put(struct eventfd_ctx *ctx)
 
 }
 
-static inline ssize_t eventfd_ctx_read(struct eventfd_ctx *ctx, int no_wait,
-                                       __u64 *cnt)
-{
-        return -ENOSYS;
-}
-
 static inline int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx,
                                                 wait_queue_entry_t *wait, __u64 *cnt)
 {
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 43e98d30d2df..58aecb60ea51 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -117,6 +117,7 @@ struct f2fs_super_block {
 /*
  * For checkpoint
  */
+#define CP_NOCRC_RECOVERY_FLAG  0x00000200
 #define CP_TRIMMED_FLAG         0x00000100
 #define CP_NAT_BITS_FLAG        0x00000080
 #define CP_CRC_RECOVERY_FLAG    0x00000040
@@ -212,6 +213,7 @@ struct f2fs_extent {
 #define F2FS_DATA_EXIST         0x08    /* file inline data exist flag */
 #define F2FS_INLINE_DOTS        0x10    /* file having implicit dot dentries */
 #define F2FS_EXTRA_ATTR         0x20    /* file having extra attribute */
+#define F2FS_PIN_FILE           0x40    /* file should not be gced */
 
 struct f2fs_inode {
         __le16 i_mode;                  /* file mode */
@@ -229,7 +231,13 @@ struct f2fs_inode {
         __le32 i_ctime_nsec;            /* change time in nano scale */
         __le32 i_mtime_nsec;            /* modification time in nano scale */
         __le32 i_generation;            /* file version (for NFS) */
-        __le32 i_current_depth;         /* only for directory depth */
+        union {
+                __le32 i_current_depth; /* only for directory depth */
+                __le16 i_gc_failures;   /*
+                                         * # of gc failures on pinned file.
+                                         * only for regular files.
+                                         */
+        };
         __le32 i_xattr_nid;             /* nid to save xattr */
         __le32 i_flags;                 /* file attributes */
         __le32 i_pino;                  /* parent inode number */
@@ -245,8 +253,10 @@ struct f2fs_inode {
                         __le16 i_inline_xattr_size;     /* inline xattr size, unit: 4 bytes */
                         __le32 i_projid;        /* project id */
                         __le32 i_inode_checksum;/* inode meta checksum */
+                        __le64 i_crtime;        /* creation time */
+                        __le32 i_crtime_nsec;   /* creation time in nano scale */
                         __le32 i_extra_end[0];  /* for attribute size calculation */
-                };
+                } __packed;
                 __le32 i_addr[DEF_ADDRS_PER_INODE];     /* Pointers to data blocks */
         };
         __le32 i_nid[DEF_NIDS_PER_INODE];       /* direct(2), indirect(2),
diff --git a/include/linux/fb.h b/include/linux/fb.h
index bc24e48e396d..f577d3c89618 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -465,6 +465,11 @@ struct fb_info {
         atomic_t count;
         int node;
         int flags;
+        /*
+         * -1 by default, set to a FB_ROTATE_* value by the driver, if it knows
+         * a lcd is not mounted upright and fbcon should rotate to compensate.
+         */
+        int fbcon_rotate_hint;
         struct mutex lock;              /* Lock for open/release/ioctl funcs */
         struct mutex mm_lock;           /* Lock for fb_mmap and smem_* fields */
         struct fb_var_screeninfo var;   /* Current var */
@@ -564,7 +569,10 @@ static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
 #define fb_memcpy_fromfb sbus_memcpy_fromio
 #define fb_memcpy_tofb sbus_memcpy_toio
 
-#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__) || defined(__bfin__) || defined(__arm__)
+#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || \
+        defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || \
+        defined(__avr32__) || defined(__bfin__) || defined(__arm__) ||  \
+        defined(__aarch64__)
 
 #define fb_readb __raw_readb
 #define fb_readw __raw_readw
diff --git a/include/linux/fdtable.h b/include/linux/fdtable.h
index 1c65817673db..41615f38bcff 100644
--- a/include/linux/fdtable.h
+++ b/include/linux/fdtable.h
@@ -10,6 +10,7 @@
 #include <linux/compiler.h>
 #include <linux/spinlock.h>
 #include <linux/rcupdate.h>
+#include <linux/nospec.h>
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/fs.h>
@@ -82,8 +83,10 @@ static inline struct file *__fcheck_files(struct files_struct *files, unsigned i
 {
         struct fdtable *fdt = rcu_dereference_raw(files->fdt);
 
-        if (fd < fdt->max_fds)
+        if (fd < fdt->max_fds) {
+                fd = array_index_nospec(fd, fdt->max_fds);
                 return rcu_dereference_raw(fdt->fd[fd]);
+        }
         return NULL;
 }
 
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 80b5b482cb46..276932d75975 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -18,7 +18,9 @@
 #include <linux/capability.h>
 #include <linux/cryptohash.h>
 #include <linux/set_memory.h>
+#include <linux/kallsyms.h>
 
+#include <net/xdp.h>
 #include <net/sch_generic.h>
 
 #include <uapi/linux/filter.h>
@@ -58,6 +60,9 @@ struct bpf_prog_aux;
 /* unused opcode to mark special call to bpf_tail_call() helper */
 #define BPF_TAIL_CALL   0xf0
 
+/* unused opcode to mark call to interpreter with arguments */
+#define BPF_CALL_ARGS   0xe0
+
 /* As per nm, we expose JITed images as text (code) section for
  * kallsyms. That way, tools like perf can find it to match
  * addresses.
@@ -455,10 +460,14 @@ struct bpf_binary_header {
 struct bpf_prog {
         u16                     pages;          /* Number of allocated pages */
         u16                     jited:1,        /* Is our filter JIT'ed? */
+                                jit_requested:1,/* archs need to JIT the prog */
                                 locked:1,       /* Program image locked? */
                                 gpl_compatible:1, /* Is filter GPL compatible? */
                                 cb_access:1,    /* Is control block accessed? */
-                                dst_needed:1;   /* Do we need dst entry? */
+                                dst_needed:1,   /* Do we need dst entry? */
+                                blinded:1,      /* Was blinded */
+                                is_func:1,      /* program is a bpf function */
+                                kprobe_override:1; /* Do we override a kprobe? */
         enum bpf_prog_type      type;           /* Type of BPF program */
         u32                     len;            /* Number of filter blocks */
         u32                     jited_len;      /* Size of jited insns in bytes */
@@ -495,6 +504,7 @@ struct xdp_buff {
         void *data_end;
         void *data_meta;
         void *data_hard_start;
+        struct xdp_rxq_info *rxq;
 };
 
 /* Compute the linear packet data range [data, data_end) which
@@ -678,6 +688,8 @@ static inline int sk_filter(struct sock *sk, struct sk_buff *skb)
 struct bpf_prog *bpf_prog_select_runtime(struct bpf_prog *fp, int *err);
 void bpf_prog_free(struct bpf_prog *fp);
 
+bool bpf_opcode_in_insntable(u8 code);
+
 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);
@@ -709,11 +721,22 @@ bool sk_filter_charge(struct sock *sk, struct sk_filter *fp);
 void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp);
 
 u64 __bpf_call_base(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
+#define __bpf_call_base_args \
+        ((u64 (*)(u64, u64, u64, u64, u64, const struct bpf_insn *)) \
+         __bpf_call_base)
 
 struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog);
 void bpf_jit_compile(struct bpf_prog *prog);
 bool bpf_helper_changes_pkt_data(void *func);
 
+static inline bool bpf_dump_raw_ok(void)
+{
+        /* Reconstruction of call-sites is dependent on kallsyms,
+         * thus make dump the same restriction.
+         */
+        return kallsyms_show_value() == 1;
+}
+
 struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,
                                        const struct bpf_insn *patch, u32 len);
 
@@ -797,7 +820,7 @@ static inline bool bpf_prog_ebpf_jited(const struct bpf_prog *fp)
         return fp->jited && bpf_jit_is_ebpf();
 }
 
-static inline bool bpf_jit_blinding_enabled(void)
+static inline bool bpf_jit_blinding_enabled(struct bpf_prog *prog)
 {
         /* These are the prerequisites, should someone ever have the
          * idea to call blinding outside of them, we make sure to
@@ -805,7 +828,7 @@ static inline bool bpf_jit_blinding_enabled(void)
          */
         if (!bpf_jit_is_ebpf())
                 return false;
-        if (!bpf_jit_enable)
+        if (!prog->jit_requested)
                 return false;
         if (!bpf_jit_harden)
                 return false;
@@ -982,9 +1005,20 @@ struct bpf_sock_ops_kern {
         struct  sock *sk;
         u32     op;
         union {
+                u32 args[4];
                 u32 reply;
                 u32 replylong[4];
         };
+        u32     is_fullsock;
+        u64     temp;                   /* temp and everything after is not
+                                         * initialized to 0 before calling
+                                         * the BPF program. New fields that
+                                         * should be initialized to 0 should
+                                         * be inserted before temp.
+                                         * temp is scratch storage used by
+                                         * sock_ops_convert_ctx_access
+                                         * as temporary storage of a register.
+                                         */
 };
 
 #endif /* __LINUX_FILTER_H__ */
diff --git a/include/linux/fpga/fpga-bridge.h b/include/linux/fpga/fpga-bridge.h
index aa66c87c120b..3694821a6d2d 100644
--- a/include/linux/fpga/fpga-bridge.h
+++ b/include/linux/fpga/fpga-bridge.h
@@ -1,10 +1,11 @@
 /* SPDX-License-Identifier: GPL-2.0 */
-#include <linux/device.h>
-#include <linux/fpga/fpga-mgr.h>
 
 #ifndef _LINUX_FPGA_BRIDGE_H
 #define _LINUX_FPGA_BRIDGE_H
 
+#include <linux/device.h>
+#include <linux/fpga/fpga-mgr.h>
+
 struct fpga_bridge;
 
 /**
@@ -12,11 +13,13 @@ struct fpga_bridge;
  * @enable_show: returns the FPGA bridge's status
  * @enable_set: set a FPGA bridge as enabled or disabled
  * @fpga_bridge_remove: set FPGA into a specific state during driver remove
+ * @groups: optional attribute groups.
  */
 struct fpga_bridge_ops {
         int (*enable_show)(struct fpga_bridge *bridge);
         int (*enable_set)(struct fpga_bridge *bridge, bool enable);
         void (*fpga_bridge_remove)(struct fpga_bridge *bridge);
+        const struct attribute_group **groups;
 };
 
 /**
@@ -43,6 +46,8 @@ struct fpga_bridge {
 
 struct fpga_bridge *of_fpga_bridge_get(struct device_node *node,
                                        struct fpga_image_info *info);
+struct fpga_bridge *fpga_bridge_get(struct device *dev,
+                                    struct fpga_image_info *info);
 void fpga_bridge_put(struct fpga_bridge *bridge);
 int fpga_bridge_enable(struct fpga_bridge *bridge);
 int fpga_bridge_disable(struct fpga_bridge *bridge);
@@ -50,9 +55,12 @@ int fpga_bridge_disable(struct fpga_bridge *bridge);
 int fpga_bridges_enable(struct list_head *bridge_list);
 int fpga_bridges_disable(struct list_head *bridge_list);
 void fpga_bridges_put(struct list_head *bridge_list);
-int fpga_bridge_get_to_list(struct device_node *np,
+int fpga_bridge_get_to_list(struct device *dev,
                             struct fpga_image_info *info,
                             struct list_head *bridge_list);
+int of_fpga_bridge_get_to_list(struct device_node *np,
+                               struct fpga_image_info *info,
+                               struct list_head *bridge_list);
 
 int fpga_bridge_register(struct device *dev, const char *name,
                          const struct fpga_bridge_ops *br_ops, void *priv);
diff --git a/include/linux/fpga/fpga-mgr.h b/include/linux/fpga/fpga-mgr.h
index bfa14bc023fb..3c6de23aabdf 100644
--- a/include/linux/fpga/fpga-mgr.h
+++ b/include/linux/fpga/fpga-mgr.h
@@ -1,7 +1,8 @@
 /*
  * FPGA Framework
  *
- *  Copyright (C) 2013-2015 Altera Corporation
+ *  Copyright (C) 2013-2016 Altera Corporation
+ *  Copyright (C) 2017 Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
@@ -15,12 +16,12 @@
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <linux/mutex.h>
-#include <linux/platform_device.h>
-
 #ifndef _LINUX_FPGA_MGR_H
 #define _LINUX_FPGA_MGR_H
 
+#include <linux/mutex.h>
+#include <linux/platform_device.h>
+
 struct fpga_manager;
 struct sg_table;
 
@@ -83,12 +84,26 @@ enum fpga_mgr_states {
  * @disable_timeout_us: maximum time to disable traffic through bridge (uSec)
  * @config_complete_timeout_us: maximum time for FPGA to switch to operating
  *         status in the write_complete op.
+ * @firmware_name: name of FPGA image firmware file
+ * @sgt: scatter/gather table containing FPGA image
+ * @buf: contiguous buffer containing FPGA image
+ * @count: size of buf
+ * @dev: device that owns this
+ * @overlay: Device Tree overlay
  */
 struct fpga_image_info {
         u32 flags;
         u32 enable_timeout_us;
         u32 disable_timeout_us;
         u32 config_complete_timeout_us;
+        char *firmware_name;
+        struct sg_table *sgt;
+        const char *buf;
+        size_t count;
+        struct device *dev;
+#ifdef CONFIG_OF
+        struct device_node *overlay;
+#endif
 };
 
 /**
@@ -100,6 +115,7 @@ struct fpga_image_info {
  * @write_sg: write the scatter list of configuration data to the FPGA
  * @write_complete: set FPGA to operating state after writing is done
  * @fpga_remove: optional: Set FPGA into a specific state during driver remove
+ * @groups: optional attribute groups.
  *
  * fpga_manager_ops are the low level functions implemented by a specific
  * fpga manager driver.  The optional ones are tested for NULL before being
@@ -116,6 +132,7 @@ struct fpga_manager_ops {
         int (*write_complete)(struct fpga_manager *mgr,
                               struct fpga_image_info *info);
         void (*fpga_remove)(struct fpga_manager *mgr);
+        const struct attribute_group **groups;
 };
 
 /**
@@ -138,14 +155,14 @@ struct fpga_manager {
 
 #define to_fpga_manager(d) container_of(d, struct fpga_manager, dev)
 
-int fpga_mgr_buf_load(struct fpga_manager *mgr, struct fpga_image_info *info,
-                      const char *buf, size_t count);
-int fpga_mgr_buf_load_sg(struct fpga_manager *mgr, struct fpga_image_info *info,
-                         struct sg_table *sgt);
+struct fpga_image_info *fpga_image_info_alloc(struct device *dev);
+
+void fpga_image_info_free(struct fpga_image_info *info);
+
+int fpga_mgr_load(struct fpga_manager *mgr, struct fpga_image_info *info);
 
-int fpga_mgr_firmware_load(struct fpga_manager *mgr,
-                           struct fpga_image_info *info,
-                           const char *image_name);
+int fpga_mgr_lock(struct fpga_manager *mgr);
+void fpga_mgr_unlock(struct fpga_manager *mgr);
 
 struct fpga_manager *of_fpga_mgr_get(struct device_node *node);
 
diff --git a/include/linux/fpga/fpga-region.h b/include/linux/fpga/fpga-region.h
new file mode 100644
index 000000000000..b6520318ab9c
--- /dev/null
+++ b/include/linux/fpga/fpga-region.h
@@ -0,0 +1,40 @@
+#ifndef _FPGA_REGION_H
+#define _FPGA_REGION_H
+
+#include <linux/device.h>
+#include <linux/fpga/fpga-mgr.h>
+#include <linux/fpga/fpga-bridge.h>
+
+/**
+ * struct fpga_region - FPGA Region structure
+ * @dev: FPGA Region device
+ * @mutex: enforces exclusive reference to region
+ * @bridge_list: list of FPGA bridges specified in region
+ * @mgr: FPGA manager
+ * @info: FPGA image info
+ * @priv: private data
+ * @get_bridges: optional function to get bridges to a list
+ * @groups: optional attribute groups.
+ */
+struct fpga_region {
+        struct device dev;
+        struct mutex mutex; /* for exclusive reference to region */
+        struct list_head bridge_list;
+        struct fpga_manager *mgr;
+        struct fpga_image_info *info;
+        void *priv;
+        int (*get_bridges)(struct fpga_region *region);
+        const struct attribute_group **groups;
+};
+
+#define to_fpga_region(d) container_of(d, struct fpga_region, dev)
+
+struct fpga_region *fpga_region_class_find(
+        struct device *start, const void *data,
+        int (*match)(struct device *, const void *));
+
+int fpga_region_program_fpga(struct fpga_region *region);
+int fpga_region_register(struct device *dev, struct fpga_region *region);
+int fpga_region_unregister(struct fpga_region *region);
+
+#endif /* _FPGA_REGION_H */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 511fbaabf624..2a815560fda0 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -639,7 +639,7 @@ struct inode {
                 struct hlist_head       i_dentry;
                 struct rcu_head         i_rcu;
         };
-        u64                     i_version;
+        atomic64_t              i_version;
         atomic_t                i_count;
         atomic_t                i_dio_count;
         atomic_t                i_writecount;
@@ -748,6 +748,11 @@ static inline void inode_lock_nested(struct inode *inode, unsigned subclass)
         down_write_nested(&inode->i_rwsem, subclass);
 }
 
+static inline void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
+{
+        down_read_nested(&inode->i_rwsem, subclass);
+}
+
 void lock_two_nondirectories(struct inode *, struct inode*);
 void unlock_two_nondirectories(struct inode *, struct inode*);
 
@@ -1359,7 +1364,7 @@ struct super_block {
 
         const struct fscrypt_operations *s_cop;
 
-        struct hlist_bl_head    s_anon;         /* anonymous dentries for (nfs) exporting */
+        struct hlist_bl_head    s_roots;        /* alternate root dentries for NFS */
         struct list_head        s_mounts;       /* list of mounts; _not_ for fs use */
         struct block_device     *s_bdev;
         struct backing_dev_info *s_bdi;
@@ -1608,6 +1613,10 @@ extern int vfs_whiteout(struct inode *, struct dentry *);
 extern struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode,
                                   int open_flag);
 
+int vfs_mkobj(struct dentry *, umode_t,
+                int (*f)(struct dentry *, umode_t, void *),
+                void *);
+
 /*
  * VFS file helper functions.
  */
@@ -1698,7 +1707,7 @@ struct file_operations {
         ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
         int (*iterate) (struct file *, struct dir_context *);
         int (*iterate_shared) (struct file *, struct dir_context *);
-        unsigned int (*poll) (struct file *, struct poll_table_struct *);
+        __poll_t (*poll) (struct file *, struct poll_table_struct *);
         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
         int (*mmap) (struct file *, struct vm_area_struct *);
@@ -2036,21 +2045,6 @@ static inline void inode_dec_link_count(struct inode *inode)
         mark_inode_dirty(inode);
 }
 
-/**
- * inode_inc_iversion - increments i_version
- * @inode: inode that need to be updated
- *
- * Every time the inode is modified, the i_version field will be incremented.
- * The filesystem has to be mounted with i_version flag
- */
-
-static inline void inode_inc_iversion(struct inode *inode)
-{
-       spin_lock(&inode->i_lock);
-       inode->i_version++;
-       spin_unlock(&inode->i_lock);
-}
-
 enum file_time_flags {
         S_ATIME = 1,
         S_MTIME = 2,
@@ -2699,7 +2693,6 @@ extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *, struct inode **);
 extern int inode_permission(struct inode *, int);
-extern int __inode_permission(struct inode *, int);
 extern int generic_permission(struct inode *, int);
 extern int __check_sticky(struct inode *dir, struct inode *inode);
 
@@ -2992,6 +2985,7 @@ enum {
 };
 
 void dio_end_io(struct bio *bio);
+void dio_warn_stale_pagecache(struct file *filp);
 
 ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
                              struct block_device *bdev, struct iov_iter *iter,
@@ -3239,6 +3233,8 @@ static inline int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags)
                 ki->ki_flags |= IOCB_DSYNC;
         if (flags & RWF_SYNC)
                 ki->ki_flags |= (IOCB_DSYNC | IOCB_SYNC);
+        if (flags & RWF_APPEND)
+                ki->ki_flags |= IOCB_APPEND;
         return 0;
 }
 
diff --git a/include/linux/fscrypt.h b/include/linux/fscrypt.h
index 08b4b40c5aa8..952ab97af325 100644
--- a/include/linux/fscrypt.h
+++ b/include/linux/fscrypt.h
@@ -14,42 +14,13 @@
 #ifndef _LINUX_FSCRYPT_H
 #define _LINUX_FSCRYPT_H
 
-#include <linux/key.h>
 #include <linux/fs.h>
-#include <linux/mm.h>
-#include <linux/bio.h>
-#include <linux/dcache.h>
-#include <crypto/skcipher.h>
-#include <uapi/linux/fs.h>
 
 #define FS_CRYPTO_BLOCK_SIZE            16
 
+struct fscrypt_ctx;
 struct fscrypt_info;
 
-struct fscrypt_ctx {
-        union {
-                struct {
-                        struct page *bounce_page;       /* Ciphertext page */
-                        struct page *control_page;      /* Original page  */
-                } w;
-                struct {
-                        struct bio *bio;
-                        struct work_struct work;
-                } r;
-                struct list_head free_list;     /* Free list */
-        };
-        u8 flags;                               /* Flags */
-};
-
-/**
- * For encrypted symlinks, the ciphertext length is stored at the beginning
- * of the string in little-endian format.
- */
-struct fscrypt_symlink_data {
-        __le16 len;
-        char encrypted_path[1];
-} __packed;
-
 struct fscrypt_str {
         unsigned char *name;
         u32 len;
@@ -68,89 +39,14 @@ struct fscrypt_name {
 #define fname_name(p)           ((p)->disk_name.name)
 #define fname_len(p)            ((p)->disk_name.len)
 
-/*
- * fscrypt superblock flags
- */
-#define FS_CFLG_OWN_PAGES (1U << 1)
-
-/*
- * crypto opertions for filesystems
- */
-struct fscrypt_operations {
-        unsigned int flags;
-        const char *key_prefix;
-        int (*get_context)(struct inode *, void *, size_t);
-        int (*set_context)(struct inode *, const void *, size_t, void *);
-        bool (*dummy_context)(struct inode *);
-        bool (*empty_dir)(struct inode *);
-        unsigned (*max_namelen)(struct inode *);
-};
-
 /* Maximum value for the third parameter of fscrypt_operations.set_context(). */
 #define FSCRYPT_SET_CONTEXT_MAX_SIZE    28
 
-static inline bool fscrypt_dummy_context_enabled(struct inode *inode)
-{
-        if (inode->i_sb->s_cop->dummy_context &&
-                                inode->i_sb->s_cop->dummy_context(inode))
-                return true;
-        return false;
-}
-
-static inline bool fscrypt_valid_enc_modes(u32 contents_mode,
-                                        u32 filenames_mode)
-{
-        if (contents_mode == FS_ENCRYPTION_MODE_AES_128_CBC &&
-            filenames_mode == FS_ENCRYPTION_MODE_AES_128_CTS)
-                return true;
-
-        if (contents_mode == FS_ENCRYPTION_MODE_AES_256_XTS &&
-            filenames_mode == FS_ENCRYPTION_MODE_AES_256_CTS)
-                return true;
-
-        return false;
-}
-
-static inline bool fscrypt_is_dot_dotdot(const struct qstr *str)
-{
-        if (str->len == 1 && str->name[0] == '.')
-                return true;
-
-        if (str->len == 2 && str->name[0] == '.' && str->name[1] == '.')
-                return true;
-
-        return false;
-}
-
 #if __FS_HAS_ENCRYPTION
-
-static inline struct page *fscrypt_control_page(struct page *page)
-{
-        return ((struct fscrypt_ctx *)page_private(page))->w.control_page;
-}
-
-static inline bool fscrypt_has_encryption_key(const struct inode *inode)
-{
-        return (inode->i_crypt_info != NULL);
-}
-
 #include <linux/fscrypt_supp.h>
-
-#else /* !__FS_HAS_ENCRYPTION */
-
-static inline struct page *fscrypt_control_page(struct page *page)
-{
-        WARN_ON_ONCE(1);
-        return ERR_PTR(-EINVAL);
-}
-
-static inline bool fscrypt_has_encryption_key(const struct inode *inode)
-{
-        return 0;
-}
-
+#else
 #include <linux/fscrypt_notsupp.h>
-#endif /* __FS_HAS_ENCRYPTION */
+#endif
 
 /**
  * fscrypt_require_key - require an inode's encryption key
@@ -291,4 +187,68 @@ static inline int fscrypt_prepare_setattr(struct dentry *dentry,
         return 0;
 }
 
+/**
+ * fscrypt_prepare_symlink - prepare to create a possibly-encrypted symlink
+ * @dir: directory in which the symlink is being created
+ * @target: plaintext symlink target
+ * @len: length of @target excluding null terminator
+ * @max_len: space the filesystem has available to store the symlink target
+ * @disk_link: (out) the on-disk symlink target being prepared
+ *
+ * This function computes the size the symlink target will require on-disk,
+ * stores it in @disk_link->len, and validates it against @max_len.  An
+ * encrypted symlink may be longer than the original.
+ *
+ * Additionally, @disk_link->name is set to @target if the symlink will be
+ * unencrypted, but left NULL if the symlink will be encrypted.  For encrypted
+ * symlinks, the filesystem must call fscrypt_encrypt_symlink() to create the
+ * on-disk target later.  (The reason for the two-step process is that some
+ * filesystems need to know the size of the symlink target before creating the
+ * inode, e.g. to determine whether it will be a "fast" or "slow" symlink.)
+ *
+ * Return: 0 on success, -ENAMETOOLONG if the symlink target is too long,
+ * -ENOKEY if the encryption key is missing, or another -errno code if a problem
+ * occurred while setting up the encryption key.
+ */
+static inline int fscrypt_prepare_symlink(struct inode *dir,
+                                          const char *target,
+                                          unsigned int len,
+                                          unsigned int max_len,
+                                          struct fscrypt_str *disk_link)
+{
+        if (IS_ENCRYPTED(dir) || fscrypt_dummy_context_enabled(dir))
+                return __fscrypt_prepare_symlink(dir, len, max_len, disk_link);
+
+        disk_link->name = (unsigned char *)target;
+        disk_link->len = len + 1;
+        if (disk_link->len > max_len)
+                return -ENAMETOOLONG;
+        return 0;
+}
+
+/**
+ * fscrypt_encrypt_symlink - encrypt the symlink target if needed
+ * @inode: symlink inode
+ * @target: plaintext symlink target
+ * @len: length of @target excluding null terminator
+ * @disk_link: (in/out) the on-disk symlink target being prepared
+ *
+ * If the symlink target needs to be encrypted, then this function encrypts it
+ * into @disk_link->name.  fscrypt_prepare_symlink() must have been called
+ * previously to compute @disk_link->len.  If the filesystem did not allocate a
+ * buffer for @disk_link->name after calling fscrypt_prepare_link(), then one
+ * will be kmalloc()'ed and the filesystem will be responsible for freeing it.
+ *
+ * Return: 0 on success, -errno on failure
+ */
+static inline int fscrypt_encrypt_symlink(struct inode *inode,
+                                          const char *target,
+                                          unsigned int len,
+                                          struct fscrypt_str *disk_link)
+{
+        if (IS_ENCRYPTED(inode))
+                return __fscrypt_encrypt_symlink(inode, target, len, disk_link);
+        return 0;
+}
+
 #endif  /* _LINUX_FSCRYPT_H */
diff --git a/include/linux/fscrypt_notsupp.h b/include/linux/fscrypt_notsupp.h
index 63e58808519a..44b50c04bae9 100644
--- a/include/linux/fscrypt_notsupp.h
+++ b/include/linux/fscrypt_notsupp.h
@@ -14,6 +14,16 @@
 #ifndef _LINUX_FSCRYPT_NOTSUPP_H
 #define _LINUX_FSCRYPT_NOTSUPP_H
 
+static inline bool fscrypt_has_encryption_key(const struct inode *inode)
+{
+        return false;
+}
+
+static inline bool fscrypt_dummy_context_enabled(struct inode *inode)
+{
+        return false;
+}
+
 /* crypto.c */
 static inline struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *inode,
                                                   gfp_t gfp_flags)
@@ -43,6 +53,11 @@ static inline int fscrypt_decrypt_page(const struct inode *inode,
         return -EOPNOTSUPP;
 }
 
+static inline struct page *fscrypt_control_page(struct page *page)
+{
+        WARN_ON_ONCE(1);
+        return ERR_PTR(-EINVAL);
+}
 
 static inline void fscrypt_restore_control_page(struct page *page)
 {
@@ -90,8 +105,7 @@ static inline int fscrypt_get_encryption_info(struct inode *inode)
         return -EOPNOTSUPP;
 }
 
-static inline void fscrypt_put_encryption_info(struct inode *inode,
-                                               struct fscrypt_info *ci)
+static inline void fscrypt_put_encryption_info(struct inode *inode)
 {
         return;
 }
@@ -116,16 +130,8 @@ static inline void fscrypt_free_filename(struct fscrypt_name *fname)
         return;
 }
 
-static inline u32 fscrypt_fname_encrypted_size(const struct inode *inode,
-                                               u32 ilen)
-{
-        /* never happens */
-        WARN_ON(1);
-        return 0;
-}
-
 static inline int fscrypt_fname_alloc_buffer(const struct inode *inode,
-                                             u32 ilen,
+                                             u32 max_encrypted_len,
                                              struct fscrypt_str *crypto_str)
 {
         return -EOPNOTSUPP;
@@ -144,13 +150,6 @@ static inline int fscrypt_fname_disk_to_usr(struct inode *inode,
         return -EOPNOTSUPP;
 }
 
-static inline int fscrypt_fname_usr_to_disk(struct inode *inode,
-                                            const struct qstr *iname,
-                                            struct fscrypt_str *oname)
-{
-        return -EOPNOTSUPP;
-}
-
 static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
                                       const u8 *de_name, u32 de_name_len)
 {
@@ -208,4 +207,28 @@ static inline int __fscrypt_prepare_lookup(struct inode *dir,
         return -EOPNOTSUPP;
 }
 
+static inline int __fscrypt_prepare_symlink(struct inode *dir,
+                                            unsigned int len,
+                                            unsigned int max_len,
+                                            struct fscrypt_str *disk_link)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int __fscrypt_encrypt_symlink(struct inode *inode,
+                                            const char *target,
+                                            unsigned int len,
+                                            struct fscrypt_str *disk_link)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline const char *fscrypt_get_symlink(struct inode *inode,
+                                              const void *caddr,
+                                              unsigned int max_size,
+                                              struct delayed_call *done)
+{
+        return ERR_PTR(-EOPNOTSUPP);
+}
+
 #endif  /* _LINUX_FSCRYPT_NOTSUPP_H */
diff --git a/include/linux/fscrypt_supp.h b/include/linux/fscrypt_supp.h
index cf9e9fc02f0a..477a7a6504d2 100644
--- a/include/linux/fscrypt_supp.h
+++ b/include/linux/fscrypt_supp.h
@@ -11,8 +11,54 @@
 #ifndef _LINUX_FSCRYPT_SUPP_H
 #define _LINUX_FSCRYPT_SUPP_H
 
+#include <linux/mm.h>
+#include <linux/slab.h>
+
+/*
+ * fscrypt superblock flags
+ */
+#define FS_CFLG_OWN_PAGES (1U << 1)
+
+/*
+ * crypto operations for filesystems
+ */
+struct fscrypt_operations {
+        unsigned int flags;
+        const char *key_prefix;
+        int (*get_context)(struct inode *, void *, size_t);
+        int (*set_context)(struct inode *, const void *, size_t, void *);
+        bool (*dummy_context)(struct inode *);
+        bool (*empty_dir)(struct inode *);
+        unsigned (*max_namelen)(struct inode *);
+};
+
+struct fscrypt_ctx {
+        union {
+                struct {
+                        struct page *bounce_page;       /* Ciphertext page */
+                        struct page *control_page;      /* Original page  */
+                } w;
+                struct {
+                        struct bio *bio;
+                        struct work_struct work;
+                } r;
+                struct list_head free_list;     /* Free list */
+        };
+        u8 flags;                               /* Flags */
+};
+
+static inline bool fscrypt_has_encryption_key(const struct inode *inode)
+{
+        return (inode->i_crypt_info != NULL);
+}
+
+static inline bool fscrypt_dummy_context_enabled(struct inode *inode)
+{
+        return inode->i_sb->s_cop->dummy_context &&
+                inode->i_sb->s_cop->dummy_context(inode);
+}
+
 /* crypto.c */
-extern struct kmem_cache *fscrypt_info_cachep;
 extern struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *, gfp_t);
 extern void fscrypt_release_ctx(struct fscrypt_ctx *);
 extern struct page *fscrypt_encrypt_page(const struct inode *, struct page *,
@@ -20,6 +66,12 @@ extern struct page *fscrypt_encrypt_page(const struct inode *, struct page *,
                                                 u64, gfp_t);
 extern int fscrypt_decrypt_page(const struct inode *, struct page *, unsigned int,
                                 unsigned int, u64);
+
+static inline struct page *fscrypt_control_page(struct page *page)
+{
+        return ((struct fscrypt_ctx *)page_private(page))->w.control_page;
+}
+
 extern void fscrypt_restore_control_page(struct page *);
 
 extern const struct dentry_operations fscrypt_d_ops;
@@ -44,7 +96,7 @@ extern int fscrypt_inherit_context(struct inode *, struct inode *,
                                         void *, bool);
 /* keyinfo.c */
 extern int fscrypt_get_encryption_info(struct inode *);
-extern void fscrypt_put_encryption_info(struct inode *, struct fscrypt_info *);
+extern void fscrypt_put_encryption_info(struct inode *);
 
 /* fname.c */
 extern int fscrypt_setup_filename(struct inode *, const struct qstr *,
@@ -55,14 +107,11 @@ static inline void fscrypt_free_filename(struct fscrypt_name *fname)
         kfree(fname->crypto_buf.name);
 }
 
-extern u32 fscrypt_fname_encrypted_size(const struct inode *, u32);
 extern int fscrypt_fname_alloc_buffer(const struct inode *, u32,
                                 struct fscrypt_str *);
 extern void fscrypt_fname_free_buffer(struct fscrypt_str *);
 extern int fscrypt_fname_disk_to_usr(struct inode *, u32, u32,
                         const struct fscrypt_str *, struct fscrypt_str *);
-extern int fscrypt_fname_usr_to_disk(struct inode *, const struct qstr *,
-                        struct fscrypt_str *);
 
 #define FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE       32
 
@@ -153,5 +202,14 @@ extern int __fscrypt_prepare_rename(struct inode *old_dir,
                                     struct dentry *new_dentry,
                                     unsigned int flags);
 extern int __fscrypt_prepare_lookup(struct inode *dir, struct dentry *dentry);
+extern int __fscrypt_prepare_symlink(struct inode *dir, unsigned int len,
+                                     unsigned int max_len,
+                                     struct fscrypt_str *disk_link);
+extern int __fscrypt_encrypt_symlink(struct inode *inode, const char *target,
+                                     unsigned int len,
+                                     struct fscrypt_str *disk_link);
+extern const char *fscrypt_get_symlink(struct inode *inode, const void *caddr,
+                                       unsigned int max_size,
+                                       struct delayed_call *done);
 
 #endif  /* _LINUX_FSCRYPT_SUPP_H */
diff --git a/include/linux/fwnode.h b/include/linux/fwnode.h
index 411a84c6c400..4fa1a489efe4 100644
--- a/include/linux/fwnode.h
+++ b/include/linux/fwnode.h
@@ -15,6 +15,7 @@
 #include <linux/types.h>
 
 struct fwnode_operations;
+struct device;
 
 struct fwnode_handle {
         struct fwnode_handle *secondary;
@@ -51,6 +52,7 @@ struct fwnode_reference_args {
  * struct fwnode_operations - Operations for fwnode interface
  * @get: Get a reference to an fwnode.
  * @put: Put a reference to an fwnode.
+ * @device_get_match_data: Return the device driver match data.
  * @property_present: Return true if a property is present.
  * @property_read_integer_array: Read an array of integer properties. Return
  *                               zero on success, a negative error code
@@ -71,6 +73,8 @@ struct fwnode_operations {
         struct fwnode_handle *(*get)(struct fwnode_handle *fwnode);
         void (*put)(struct fwnode_handle *fwnode);
         bool (*device_is_available)(const struct fwnode_handle *fwnode);
+        void *(*device_get_match_data)(const struct fwnode_handle *fwnode,
+                                       const struct device *dev);
         bool (*property_present)(const struct fwnode_handle *fwnode,
                                  const char *propname);
         int (*property_read_int_array)(const struct fwnode_handle *fwnode,
diff --git a/include/linux/genetlink.h b/include/linux/genetlink.h
index ecc2928e8046..bc738504ab4a 100644
--- a/include/linux/genetlink.h
+++ b/include/linux/genetlink.h
@@ -31,8 +31,7 @@ extern wait_queue_head_t genl_sk_destructing_waitq;
  * @p: The pointer to read, prior to dereferencing
  *
  * Return the value of the specified RCU-protected pointer, but omit
- * both the smp_read_barrier_depends() and the READ_ONCE(), because
- * caller holds genl mutex.
+ * the READ_ONCE(), because caller holds genl mutex.
  */
 #define genl_dereference(p)                                     \
         rcu_dereference_protected(p, lockdep_genl_is_held())
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 5144ebe046c9..5e3531027b51 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -395,6 +395,11 @@ static inline void add_disk(struct gendisk *disk)
 {
         device_add_disk(NULL, disk);
 }
+extern void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk);
+static inline void add_disk_no_queue_reg(struct gendisk *disk)
+{
+        device_add_disk_no_queue_reg(NULL, disk);
+}
 
 extern void del_gendisk(struct gendisk *gp);
 extern struct gendisk *get_gendisk(dev_t dev, int *partno);
diff --git a/include/linux/genl_magic_func.h b/include/linux/genl_magic_func.h
index 604967609e55..83f81ac53282 100644
--- a/include/linux/genl_magic_func.h
+++ b/include/linux/genl_magic_func.h
@@ -2,6 +2,7 @@
 #ifndef GENL_MAGIC_FUNC_H
 #define GENL_MAGIC_FUNC_H
 
+#include <linux/build_bug.h>
 #include <linux/genl_magic_struct.h>
 
 /*
@@ -132,17 +133,6 @@ static void dprint_array(const char *dir, int nla_type,
  * use one static buffer for parsing of nested attributes */
 static struct nlattr *nested_attr_tb[128];
 
-#ifndef BUILD_BUG_ON
-/* Force a compilation error if condition is true */
-#define BUILD_BUG_ON(condition) ((void)BUILD_BUG_ON_ZERO(condition))
-/* Force a compilation error if condition is true, but also produce a
-   result (of value 0 and type size_t), so the expression can be used
-   e.g. in a structure initializer (or where-ever else comma expressions
-   aren't permitted). */
-#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
-#define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:-!!(e); }))
-#endif
-
 #undef GENL_struct
 #define GENL_struct(tag_name, tag_number, s_name, s_fields)             \
 /* *_from_attrs functions are static, but potentially unused */         \
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 8ef7fc0ce0f0..91ed23468530 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -1,4 +1,14 @@
 /* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * <linux/gpio.h>
+ *
+ * This is the LEGACY GPIO bulk include file, including legacy APIs. It is
+ * used for GPIO drivers still referencing the global GPIO numberspace,
+ * and should not be included in new code.
+ *
+ * If you're implementing a GPIO driver, only include <linux/gpio/driver.h>
+ * If you're implementing a GPIO consumer, only include <linux/gpio/consumer.h>
+ */
 #ifndef __LINUX_GPIO_H
 #define __LINUX_GPIO_H
 
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index 7447d85dbe2f..dbd065963296 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -139,6 +139,7 @@ void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
                                         int *value_array);
 
 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
+int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
 
 int gpiod_is_active_low(const struct gpio_desc *desc);
 int gpiod_cansleep(const struct gpio_desc *desc);
@@ -150,8 +151,14 @@ struct gpio_desc *gpio_to_desc(unsigned gpio);
 int desc_to_gpio(const struct gpio_desc *desc);
 
 /* Child properties interface */
+struct device_node;
 struct fwnode_handle;
 
+struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
+                                              struct device_node *node,
+                                              const char *propname, int index,
+                                              enum gpiod_flags dflags,
+                                              const char *label);
 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
                                          const char *propname, int index,
                                          enum gpiod_flags dflags,
@@ -431,6 +438,13 @@ static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
         return -ENOSYS;
 }
 
+static inline int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
+{
+        /* GPIO can never have been requested */
+        WARN_ON(1);
+        return -ENOSYS;
+}
+
 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 {
         /* GPIO can never have been requested */
@@ -464,9 +478,20 @@ static inline int desc_to_gpio(const struct gpio_desc *desc)
 }
 
 /* Child properties interface */
+struct device_node;
 struct fwnode_handle;
 
 static inline
+struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
+                                              struct device_node *node,
+                                              const char *propname, int index,
+                                              enum gpiod_flags dflags,
+                                              const char *label)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
+static inline
 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
                                          const char *propname, int index,
                                          enum gpiod_flags dflags,
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index 7258cd676df4..1ba9a331ec51 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -436,6 +436,9 @@ int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
                              struct lock_class_key *lock_key,
                              struct lock_class_key *request_key);
 
+bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
+                                unsigned int offset);
+
 #ifdef CONFIG_LOCKDEP
 
 /*
diff --git a/include/linux/gpio/machine.h b/include/linux/gpio/machine.h
index 846be7c69a52..b2f2dc638463 100644
--- a/include/linux/gpio/machine.h
+++ b/include/linux/gpio/machine.h
@@ -10,8 +10,8 @@ enum gpio_lookup_flags {
         GPIO_ACTIVE_LOW = (1 << 0),
         GPIO_OPEN_DRAIN = (1 << 1),
         GPIO_OPEN_SOURCE = (1 << 2),
-        GPIO_SLEEP_MAINTAIN_VALUE = (0 << 3),
-        GPIO_SLEEP_MAY_LOSE_VALUE = (1 << 3),
+        GPIO_PERSISTENT = (0 << 3),
+        GPIO_TRANSITORY = (1 << 3),
 };
 
 /**
diff --git a/include/linux/hid.h b/include/linux/hid.h
index d491027a7c22..091a81cf330f 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -281,6 +281,7 @@ struct hid_item {
 
 #define HID_DG_DEVICECONFIG     0x000d000e
 #define HID_DG_DEVICESETTINGS   0x000d0023
+#define HID_DG_AZIMUTH          0x000d003f
 #define HID_DG_CONFIDENCE       0x000d0047
 #define HID_DG_WIDTH            0x000d0048
 #define HID_DG_HEIGHT           0x000d0049
@@ -342,6 +343,7 @@ struct hid_item {
 #define HID_QUIRK_SKIP_OUTPUT_REPORTS           0x00010000
 #define HID_QUIRK_SKIP_OUTPUT_REPORT_ID         0x00020000
 #define HID_QUIRK_NO_OUTPUT_REPORTS_ON_INTR_EP  0x00040000
+#define HID_QUIRK_HAVE_SPECIAL_DRIVER           0x00080000
 #define HID_QUIRK_FULLSPEED_INTERVAL            0x10000000
 #define HID_QUIRK_NO_INIT_REPORTS               0x20000000
 #define HID_QUIRK_NO_IGNORE                     0x40000000
@@ -671,6 +673,7 @@ struct hid_usage_id {
  *            to be called)
  * @dyn_list: list of dynamically added device ids
  * @dyn_lock: lock protecting @dyn_list
+ * @match: check if the given device is handled by this driver
  * @probe: new device inserted
  * @remove: device removed (NULL if not a hot-plug capable driver)
  * @report_table: on which reports to call raw_event (NULL means all)
@@ -683,6 +686,8 @@ struct hid_usage_id {
  * @input_mapped: invoked on input registering after mapping an usage
  * @input_configured: invoked just before the device is registered
  * @feature_mapping: invoked on feature registering
+ * @bus_add_driver: invoked when a HID driver is about to be added
+ * @bus_removed_driver: invoked when a HID driver has been removed
  * @suspend: invoked on suspend (NULL means nop)
  * @resume: invoked on resume if device was not reset (NULL means nop)
  * @reset_resume: invoked on resume if device was reset (NULL means nop)
@@ -711,6 +716,7 @@ struct hid_driver {
         struct list_head dyn_list;
         spinlock_t dyn_lock;
 
+        bool (*match)(struct hid_device *dev, bool ignore_special_driver);
         int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
         void (*remove)(struct hid_device *dev);
 
@@ -736,6 +742,8 @@ struct hid_driver {
         void (*feature_mapping)(struct hid_device *hdev,
                         struct hid_field *field,
                         struct hid_usage *usage);
+        void (*bus_add_driver)(struct hid_driver *driver);
+        void (*bus_removed_driver)(struct hid_driver *driver);
 #ifdef CONFIG_PM
         int (*suspend)(struct hid_device *hdev, pm_message_t message);
         int (*resume)(struct hid_device *hdev);
@@ -814,6 +822,8 @@ extern bool hid_ignore(struct hid_device *);
 extern int hid_add_device(struct hid_device *);
 extern void hid_destroy_device(struct hid_device *);
 
+extern struct bus_type hid_bus_type;
+
 extern int __must_check __hid_register_driver(struct hid_driver *,
                 struct module *, const char *mod_name);
 
@@ -860,8 +870,12 @@ int hid_open_report(struct hid_device *device);
 int hid_check_keys_pressed(struct hid_device *hid);
 int hid_connect(struct hid_device *hid, unsigned int connect_mask);
 void hid_disconnect(struct hid_device *hid);
-const struct hid_device_id *hid_match_id(struct hid_device *hdev,
+bool hid_match_one_id(const struct hid_device *hdev,
+                      const struct hid_device_id *id);
+const struct hid_device_id *hid_match_id(const struct hid_device *hdev,
                                          const struct hid_device_id *id);
+const struct hid_device_id *hid_match_device(struct hid_device *hdev,
+                                             struct hid_driver *hdrv);
 s32 hid_snto32(__u32 value, unsigned n);
 __u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
                      unsigned offset, unsigned n);
@@ -1098,9 +1112,9 @@ int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
                 int interrupt);
 
 /* HID quirks API */
-u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct);
-int usbhid_quirks_init(char **quirks_param);
-void usbhid_quirks_exit(void);
+unsigned long hid_lookup_quirk(const struct hid_device *hdev);
+int hid_quirks_init(char **quirks_param, __u16 bus, int count);
+void hid_quirks_exit(__u16 bus);
 
 #ifdef CONFIG_HID_PID
 int hid_pidff_init(struct hid_device *hid);
diff --git a/include/linux/hil_mlc.h b/include/linux/hil_mlc.h
index 394a8405dd74..774f7d3b8f6a 100644
--- a/include/linux/hil_mlc.h
+++ b/include/linux/hil_mlc.h
@@ -144,12 +144,12 @@ struct hil_mlc {
         hil_packet              ipacket[16];
         hil_packet              imatch;
         int                     icount;
-        struct timeval          instart;
-        suseconds_t             intimeout;
+        unsigned long           instart;
+        unsigned long           intimeout;
 
         int                     ddi;    /* Last operational device id */
         int                     lcv;    /* LCV to throttle loops */
-        struct timeval          lcv_tv; /* Time loop was started */
+        time64_t                lcv_time; /* Time loop was started */
 
         int                     di_map[7]; /* Maps below items to live devs */
         struct hil_mlc_devinfo  di[HIL_MLC_DEVMEM];
diff --git a/include/linux/hp_sdc.h b/include/linux/hp_sdc.h
index d392975d8887..6f1dee7e67e0 100644
--- a/include/linux/hp_sdc.h
+++ b/include/linux/hp_sdc.h
@@ -281,7 +281,7 @@ typedef struct {
         hp_sdc_transaction *tq[HP_SDC_QUEUE_LEN]; /* All pending read/writes */
 
         int             rcurr, rqty;    /* Current read transact in process */
-        struct timeval  rtv;            /* Time when current read started */
+        ktime_t         rtime;          /* Time when current read started */
         int             wcurr;          /* Current write transact in process */
 
         int             dev_err;        /* carries status from registration */
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 012c37fdb688..c7902ca7c9f4 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -28,13 +28,29 @@ struct hrtimer_cpu_base;
 
 /*
  * Mode arguments of xxx_hrtimer functions:
+ *
+ * HRTIMER_MODE_ABS             - Time value is absolute
+ * HRTIMER_MODE_REL             - Time value is relative to now
+ * HRTIMER_MODE_PINNED          - Timer is bound to CPU (is only considered
+ *                                when starting the timer)
+ * HRTIMER_MODE_SOFT            - Timer callback function will be executed in
+ *                                soft irq context
  */
 enum hrtimer_mode {
-        HRTIMER_MODE_ABS = 0x0,         /* Time value is absolute */
-        HRTIMER_MODE_REL = 0x1,         /* Time value is relative to now */
-        HRTIMER_MODE_PINNED = 0x02,     /* Timer is bound to CPU */
-        HRTIMER_MODE_ABS_PINNED = 0x02,
-        HRTIMER_MODE_REL_PINNED = 0x03,
+        HRTIMER_MODE_ABS        = 0x00,
+        HRTIMER_MODE_REL        = 0x01,
+        HRTIMER_MODE_PINNED     = 0x02,
+        HRTIMER_MODE_SOFT       = 0x04,
+
+        HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
+        HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
+
+        HRTIMER_MODE_ABS_SOFT   = HRTIMER_MODE_ABS | HRTIMER_MODE_SOFT,
+        HRTIMER_MODE_REL_SOFT   = HRTIMER_MODE_REL | HRTIMER_MODE_SOFT,
+
+        HRTIMER_MODE_ABS_PINNED_SOFT = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_SOFT,
+        HRTIMER_MODE_REL_PINNED_SOFT = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_SOFT,
+
 };
 
 /*
@@ -87,6 +103,7 @@ enum hrtimer_restart {
  * @base:       pointer to the timer base (per cpu and per clock)
  * @state:      state information (See bit values above)
  * @is_rel:     Set if the timer was armed relative
+ * @is_soft:    Set if hrtimer will be expired in soft interrupt context.
  *
  * The hrtimer structure must be initialized by hrtimer_init()
  */
@@ -97,6 +114,7 @@ struct hrtimer {
         struct hrtimer_clock_base       *base;
         u8                              state;
         u8                              is_rel;
+        u8                              is_soft;
 };
 
 /**
@@ -112,9 +130,9 @@ struct hrtimer_sleeper {
 };
 
 #ifdef CONFIG_64BIT
-# define HRTIMER_CLOCK_BASE_ALIGN       64
+# define __hrtimer_clock_base_align     ____cacheline_aligned
 #else
-# define HRTIMER_CLOCK_BASE_ALIGN       32
+# define __hrtimer_clock_base_align
 #endif
 
 /**
@@ -123,48 +141,57 @@ struct hrtimer_sleeper {
  * @index:              clock type index for per_cpu support when moving a
  *                      timer to a base on another cpu.
  * @clockid:            clock id for per_cpu support
+ * @seq:                seqcount around __run_hrtimer
+ * @running:            pointer to the currently running hrtimer
  * @active:             red black tree root node for the active timers
  * @get_time:           function to retrieve the current time of the clock
  * @offset:             offset of this clock to the monotonic base
  */
 struct hrtimer_clock_base {
         struct hrtimer_cpu_base *cpu_base;
-        int                     index;
+        unsigned int            index;
         clockid_t               clockid;
+        seqcount_t              seq;
+        struct hrtimer          *running;
         struct timerqueue_head  active;
         ktime_t                 (*get_time)(void);
         ktime_t                 offset;
-} __attribute__((__aligned__(HRTIMER_CLOCK_BASE_ALIGN)));
+} __hrtimer_clock_base_align;
 
 enum  hrtimer_base_type {
         HRTIMER_BASE_MONOTONIC,
         HRTIMER_BASE_REALTIME,
         HRTIMER_BASE_BOOTTIME,
         HRTIMER_BASE_TAI,
+        HRTIMER_BASE_MONOTONIC_SOFT,
+        HRTIMER_BASE_REALTIME_SOFT,
+        HRTIMER_BASE_BOOTTIME_SOFT,
+        HRTIMER_BASE_TAI_SOFT,
         HRTIMER_MAX_CLOCK_BASES,
 };
 
-/*
+/**
  * 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_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
+ * @in_hrtirq:          hrtimer_interrupt() is currently executing
  * @hang_detected:      The last hrtimer interrupt detected a hang
+ * @softirq_activated:  displays, if the softirq is raised - update of softirq
+ *                      related settings is not required then.
  * @nr_events:          Total number of hrtimer interrupt events
  * @nr_retries:         Total number of hrtimer interrupt retries
  * @nr_hangs:           Total number of hrtimer interrupt hangs
  * @max_hang_time:      Maximum time spent in hrtimer_interrupt
+ * @expires_next:       absolute time of the next event, is required for remote
+ *                      hrtimer enqueue; it is the total first expiry time (hard
+ *                      and soft hrtimer are taken into account)
+ * @next_timer:         Pointer to the first expiring timer
+ * @softirq_expires_next: Time to check, if soft queues needs also to be expired
+ * @softirq_next_timer: Pointer to the first expiring softirq based timer
  * @clock_base:         array of clock bases for this cpu
  *
  * Note: next_timer is just an optimization for __remove_hrtimer().
@@ -173,31 +200,28 @@ enum  hrtimer_base_type {
  */
 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_seq;
-        bool                            migration_enabled;
-        bool                            nohz_active;
+        unsigned int                    hres_active             : 1,
+                                        in_hrtirq               : 1,
+                                        hang_detected           : 1,
+                                        softirq_activated       : 1;
 #ifdef CONFIG_HIGH_RES_TIMERS
-        unsigned int                    in_hrtirq       : 1,
-                                        hres_active     : 1,
-                                        hang_detected   : 1;
-        ktime_t                         expires_next;
-        struct hrtimer                  *next_timer;
         unsigned int                    nr_events;
-        unsigned int                    nr_retries;
-        unsigned int                    nr_hangs;
+        unsigned short                  nr_retries;
+        unsigned short                  nr_hangs;
         unsigned int                    max_hang_time;
 #endif
+        ktime_t                         expires_next;
+        struct hrtimer                  *next_timer;
+        ktime_t                         softirq_expires_next;
+        struct hrtimer                  *softirq_next_timer;
         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;
 }
@@ -266,16 +290,17 @@ static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
         return timer->base->get_time();
 }
 
+static inline int hrtimer_is_hres_active(struct hrtimer *timer)
+{
+        return IS_ENABLED(CONFIG_HIGH_RES_TIMERS) ?
+                timer->base->cpu_base->hres_active : 0;
+}
+
 #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;
-}
-
 /*
  * The resolution of the clocks. The resolution value is returned in
  * the clock_getres() system call to give application programmers an
@@ -298,11 +323,6 @@ extern unsigned int hrtimer_resolution;
 
 #define hrtimer_resolution      (unsigned int)LOW_RES_NSEC
 
-static inline int hrtimer_is_hres_active(struct hrtimer *timer)
-{
-        return 0;
-}
-
 static inline void clock_was_set_delayed(void) { }
 
 #endif
@@ -365,11 +385,12 @@ extern void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
                                    u64 range_ns, const enum hrtimer_mode mode);
 
 /**
- * hrtimer_start - (re)start an hrtimer on the current CPU
+ * hrtimer_start - (re)start an hrtimer
  * @timer:      the timer to be added
  * @tim:        expiry time
- * @mode:       expiry mode: absolute (HRTIMER_MODE_ABS) or
- *              relative (HRTIMER_MODE_REL)
+ * @mode:       timer mode: absolute (HRTIMER_MODE_ABS) or
+ *              relative (HRTIMER_MODE_REL), and pinned (HRTIMER_MODE_PINNED);
+ *              softirq based mode is considered for debug purpose only!
  */
 static inline void hrtimer_start(struct hrtimer *timer, ktime_t tim,
                                  const enum hrtimer_mode mode)
@@ -422,7 +443,7 @@ static inline int hrtimer_is_queued(struct hrtimer *timer)
  */
 static inline int hrtimer_callback_running(struct hrtimer *timer)
 {
-        return timer->base->cpu_base->running == timer;
+        return timer->base->running == timer;
 }
 
 /* Forward a hrtimer so it expires after now: */
@@ -466,7 +487,7 @@ extern int schedule_hrtimeout_range(ktime_t *expires, u64 delta,
 extern int schedule_hrtimeout_range_clock(ktime_t *expires,
                                           u64 delta,
                                           const enum hrtimer_mode mode,
-                                          int clock);
+                                          clockid_t clock_id);
 extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
 
 /* Soft interrupt function to run the hrtimer queues: */
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 82a25880714a..36fa6a2a82e3 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -119,6 +119,7 @@ long hugetlb_unreserve_pages(struct inode *inode, long start, long end,
                                                 long freed);
 bool isolate_huge_page(struct page *page, struct list_head *list);
 void putback_active_hugepage(struct page *page);
+void move_hugetlb_state(struct page *oldpage, struct page *newpage, int reason);
 void free_huge_page(struct page *page);
 void hugetlb_fix_reserve_counts(struct inode *inode);
 extern struct mutex *hugetlb_fault_mutex_table;
@@ -129,7 +130,6 @@ u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
 
 pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud);
 
-extern int hugepages_treat_as_movable;
 extern int sysctl_hugetlb_shm_group;
 extern struct list_head huge_boot_pages;
 
@@ -158,6 +158,7 @@ unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
                 unsigned long address, unsigned long end, pgprot_t newprot);
 
 bool is_hugetlb_entry_migration(pte_t pte);
+
 #else /* !CONFIG_HUGETLB_PAGE */
 
 static inline void reset_vma_resv_huge_pages(struct vm_area_struct *vma)
@@ -198,6 +199,7 @@ static inline bool isolate_huge_page(struct page *page, struct list_head *list)
         return false;
 }
 #define putback_active_hugepage(p)      do {} while (0)
+#define move_hugetlb_state(old, new, reason)    do {} while (0)
 
 static inline unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
                 unsigned long address, unsigned long end, pgprot_t newprot)
@@ -271,6 +273,17 @@ static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
         return sb->s_fs_info;
 }
 
+struct hugetlbfs_inode_info {
+        struct shared_policy policy;
+        struct inode vfs_inode;
+        unsigned int seals;
+};
+
+static inline struct hugetlbfs_inode_info *HUGETLBFS_I(struct inode *inode)
+{
+        return container_of(inode, struct hugetlbfs_inode_info, vfs_inode);
+}
+
 extern const struct file_operations hugetlbfs_file_operations;
 extern const struct vm_operations_struct hugetlb_vm_ops;
 struct file *hugetlb_file_setup(const char *name, size_t size, vm_flags_t acct,
@@ -343,10 +356,10 @@ struct huge_bootmem_page {
 struct page *alloc_huge_page(struct vm_area_struct *vma,
                                 unsigned long addr, int avoid_reserve);
 struct page *alloc_huge_page_node(struct hstate *h, int nid);
-struct page *alloc_huge_page_noerr(struct vm_area_struct *vma,
-                                unsigned long addr, int avoid_reserve);
 struct page *alloc_huge_page_nodemask(struct hstate *h, int preferred_nid,
                                 nodemask_t *nmask);
+struct page *alloc_huge_page_vma(struct hstate *h, struct vm_area_struct *vma,
+                                unsigned long address);
 int huge_add_to_page_cache(struct page *page, struct address_space *mapping,
                         pgoff_t idx);
 
@@ -524,7 +537,7 @@ struct hstate {};
 #define alloc_huge_page(v, a, r) NULL
 #define alloc_huge_page_node(h, nid) NULL
 #define alloc_huge_page_nodemask(h, preferred_nid, nmask) NULL
-#define alloc_huge_page_noerr(v, a, r) NULL
+#define alloc_huge_page_vma(h, vma, address) NULL
 #define alloc_bootmem_huge_page(h) NULL
 #define hstate_file(f) NULL
 #define hstate_sizelog(s) NULL
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 6c9336626592..93bd6fcd6e62 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -127,28 +127,6 @@ struct hv_ring_buffer_info {
         u32 priv_read_index;
 };
 
-/*
- *
- * hv_get_ringbuffer_availbytes()
- *
- * Get number of bytes available to read and to write to
- * for the specified ring buffer
- */
-static inline void
-hv_get_ringbuffer_availbytes(const struct hv_ring_buffer_info *rbi,
-                             u32 *read, u32 *write)
-{
-        u32 read_loc, write_loc, dsize;
-
-        /* Capture the read/write indices before they changed */
-        read_loc = rbi->ring_buffer->read_index;
-        write_loc = rbi->ring_buffer->write_index;
-        dsize = rbi->ring_datasize;
-
-        *write = write_loc >= read_loc ? dsize - (write_loc - read_loc) :
-                read_loc - write_loc;
-        *read = dsize - *write;
-}
 
 static inline u32 hv_get_bytes_to_read(const struct hv_ring_buffer_info *rbi)
 {
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 0f774406fad0..419a38e7c315 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -55,7 +55,7 @@ typedef int (*i2c_slave_cb_t)(struct i2c_client *, enum i2c_slave_event, u8 *);
 struct module;
 struct property_entry;
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 /*
  * The master routines are the ones normally used to transmit data to devices
  * on a bus (or read from them). Apart from two basic transfer functions to
@@ -63,10 +63,68 @@ struct property_entry;
  * transmit an arbitrary number of messages without interruption.
  * @count must be be less than 64k since msg.len is u16.
  */
-extern int i2c_master_send(const struct i2c_client *client, const char *buf,
-                           int count);
-extern int i2c_master_recv(const struct i2c_client *client, char *buf,
-                           int count);
+extern int i2c_transfer_buffer_flags(const struct i2c_client *client,
+                                     char *buf, int count, u16 flags);
+
+/**
+ * i2c_master_recv - issue a single I2C message in master receive mode
+ * @client: Handle to slave device
+ * @buf: Where to store data read from slave
+ * @count: How many bytes to read, must be less than 64k since msg.len is u16
+ *
+ * Returns negative errno, or else the number of bytes read.
+ */
+static inline int i2c_master_recv(const struct i2c_client *client,
+                                  char *buf, int count)
+{
+        return i2c_transfer_buffer_flags(client, buf, count, I2C_M_RD);
+};
+
+/**
+ * i2c_master_recv_dmasafe - issue a single I2C message in master receive mode
+ *                           using a DMA safe buffer
+ * @client: Handle to slave device
+ * @buf: Where to store data read from slave, must be safe to use with DMA
+ * @count: How many bytes to read, must be less than 64k since msg.len is u16
+ *
+ * Returns negative errno, or else the number of bytes read.
+ */
+static inline int i2c_master_recv_dmasafe(const struct i2c_client *client,
+                                          char *buf, int count)
+{
+        return i2c_transfer_buffer_flags(client, buf, count,
+                                         I2C_M_RD | I2C_M_DMA_SAFE);
+};
+
+/**
+ * i2c_master_send - issue a single I2C message in master transmit mode
+ * @client: Handle to slave device
+ * @buf: Data that will be written to the slave
+ * @count: How many bytes to write, must be less than 64k since msg.len is u16
+ *
+ * Returns negative errno, or else the number of bytes written.
+ */
+static inline int i2c_master_send(const struct i2c_client *client,
+                                  const char *buf, int count)
+{
+        return i2c_transfer_buffer_flags(client, (char *)buf, count, 0);
+};
+
+/**
+ * i2c_master_send_dmasafe - issue a single I2C message in master transmit mode
+ *                           using a DMA safe buffer
+ * @client: Handle to slave device
+ * @buf: Data that will be written to the slave, must be safe to use with DMA
+ * @count: How many bytes to write, must be less than 64k since msg.len is u16
+ *
+ * Returns negative errno, or else the number of bytes written.
+ */
+static inline int i2c_master_send_dmasafe(const struct i2c_client *client,
+                                          const char *buf, int count)
+{
+        return i2c_transfer_buffer_flags(client, (char *)buf, count,
+                                         I2C_M_DMA_SAFE);
+};
 
 /* Transfer num messages.
  */
@@ -354,7 +412,7 @@ struct i2c_board_info {
         .type = dev_type, .addr = (dev_addr)
 
 
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 /* Add-on boards should register/unregister their devices; e.g. a board
  * with integrated I2C, a config eeprom, sensors, and a codec that's
  * used in conjunction with the primary hardware.
@@ -485,40 +543,43 @@ struct i2c_timings {
 /**
  * struct i2c_bus_recovery_info - I2C bus recovery information
  * @recover_bus: Recover routine. Either pass driver's recover_bus() routine, or
- *      i2c_generic_scl_recovery() or i2c_generic_gpio_recovery().
+ *      i2c_generic_scl_recovery().
  * @get_scl: This gets current value of SCL line. Mandatory for generic SCL
- *      recovery. Used internally for generic GPIO recovery.
- * @set_scl: This sets/clears SCL line. Mandatory for generic SCL recovery. Used
- *      internally for generic GPIO recovery.
+ *      recovery. Populated internally for generic GPIO recovery.
+ * @set_scl: This sets/clears the SCL line. Mandatory for generic SCL recovery.
+ *      Populated internally for generic GPIO recovery.
  * @get_sda: This gets current value of SDA line. Optional for generic SCL
- *      recovery. Used internally, if sda_gpio is a valid GPIO, for generic GPIO
- *      recovery.
+ *      recovery. Populated internally, if sda_gpio is a valid GPIO, for generic
+ *      GPIO recovery.
+ * @set_sda: This sets/clears the SDA line. Optional for generic SCL recovery.
+ *      Populated internally, if sda_gpio is a valid GPIO, for generic GPIO
+ *      recovery.
  * @prepare_recovery: This will be called before starting recovery. Platform may
  *      configure padmux here for SDA/SCL line or something else they want.
  * @unprepare_recovery: This will be called after completing recovery. Platform
  *      may configure padmux here for SDA/SCL line or something else they want.
- * @scl_gpio: gpio number of the SCL line. Only required for GPIO recovery.
- * @sda_gpio: gpio number of the SDA line. Only required for GPIO recovery.
+ * @scl_gpiod: gpiod of the SCL line. Only required for GPIO recovery.
+ * @sda_gpiod: gpiod of the SDA line. Only required for GPIO recovery.
  */
 struct i2c_bus_recovery_info {
-        int (*recover_bus)(struct i2c_adapter *);
+        int (*recover_bus)(struct i2c_adapter *adap);
 
-        int (*get_scl)(struct i2c_adapter *);
-        void (*set_scl)(struct i2c_adapter *, int val);
-        int (*get_sda)(struct i2c_adapter *);
+        int (*get_scl)(struct i2c_adapter *adap);
+        void (*set_scl)(struct i2c_adapter *adap, int val);
+        int (*get_sda)(struct i2c_adapter *adap);
+        void (*set_sda)(struct i2c_adapter *adap, int val);
 
-        void (*prepare_recovery)(struct i2c_adapter *);
-        void (*unprepare_recovery)(struct i2c_adapter *);
+        void (*prepare_recovery)(struct i2c_adapter *adap);
+        void (*unprepare_recovery)(struct i2c_adapter *adap);
 
         /* gpio recovery */
-        int scl_gpio;
-        int sda_gpio;
+        struct gpio_desc *scl_gpiod;
+        struct gpio_desc *sda_gpiod;
 };
 
 int i2c_recover_bus(struct i2c_adapter *adap);
 
 /* Generic recovery routines */
-int i2c_generic_gpio_recovery(struct i2c_adapter *adap);
 int i2c_generic_scl_recovery(struct i2c_adapter *adap);
 
 /**
@@ -706,7 +767,7 @@ i2c_unlock_adapter(struct i2c_adapter *adapter)
 
 /* administration...
  */
-#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
+#if IS_ENABLED(CONFIG_I2C)
 extern int i2c_add_adapter(struct i2c_adapter *);
 extern void i2c_del_adapter(struct i2c_adapter *);
 extern int i2c_add_numbered_adapter(struct i2c_adapter *);
@@ -769,6 +830,9 @@ static inline u8 i2c_8bit_addr_from_msg(const struct i2c_msg *msg)
         return (msg->addr << 1) | (msg->flags & I2C_M_RD ? 1 : 0);
 }
 
+u8 *i2c_get_dma_safe_msg_buf(struct i2c_msg *msg, unsigned int threshold);
+void i2c_release_dma_safe_msg_buf(struct i2c_msg *msg, u8 *buf);
+
 int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr);
 /**
  * module_i2c_driver() - Helper macro for registering a modular I2C driver
diff --git a/include/linux/i7300_idle.h b/include/linux/i7300_idle.h
deleted file mode 100644
index 4dbe651f71f5..000000000000
--- a/include/linux/i7300_idle.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-
-#ifndef I7300_IDLE_H
-#define I7300_IDLE_H
-
-#include <linux/pci.h>
-
-/*
- * I/O AT controls (PCI bus 0 device 8 function 0)
- * DIMM controls (PCI bus 0 device 16 function 1)
- */
-#define IOAT_BUS 0
-#define IOAT_DEVFN PCI_DEVFN(8, 0)
-#define MEMCTL_BUS 0
-#define MEMCTL_DEVFN PCI_DEVFN(16, 1)
-
-struct fbd_ioat {
-        unsigned int vendor;
-        unsigned int ioat_dev;
-        unsigned int enabled;
-};
-
-/*
- * The i5000 chip-set has the same hooks as the i7300
- * but it is not enabled by default and must be manually
- * manually enabled with "forceload=1" because it is
- * only lightly validated.
- */
-
-static const struct fbd_ioat fbd_ioat_list[] = {
-        {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_CNB, 1},
-        {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT, 0},
-        {0, 0}
-};
-
-/* table of devices that work with this driver */
-static const struct pci_device_id pci_tbl[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_FBD_CNB) },
-        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_5000_ERR) },
-        { } /* Terminating entry */
-};
-
-/* Check for known platforms with I/O-AT */
-static inline int i7300_idle_platform_probe(struct pci_dev **fbd_dev,
-                                                struct pci_dev **ioat_dev,
-                                                int enable_all)
-{
-        int i;
-        struct pci_dev *memdev, *dmadev;
-
-        memdev = pci_get_bus_and_slot(MEMCTL_BUS, MEMCTL_DEVFN);
-        if (!memdev)
-                return -ENODEV;
-
-        for (i = 0; pci_tbl[i].vendor != 0; i++) {
-                if (memdev->vendor == pci_tbl[i].vendor &&
-                    memdev->device == pci_tbl[i].device) {
-                        break;
-                }
-        }
-        if (pci_tbl[i].vendor == 0)
-                return -ENODEV;
-
-        dmadev = pci_get_bus_and_slot(IOAT_BUS, IOAT_DEVFN);
-        if (!dmadev)
-                return -ENODEV;
-
-        for (i = 0; fbd_ioat_list[i].vendor != 0; i++) {
-                if (dmadev->vendor == fbd_ioat_list[i].vendor &&
-                    dmadev->device == fbd_ioat_list[i].ioat_dev) {
-                        if (!(fbd_ioat_list[i].enabled || enable_all))
-                                continue;
-                        if (fbd_dev)
-                                *fbd_dev = memdev;
-                        if (ioat_dev)
-                                *ioat_dev = dmadev;
-
-                        return 0;
-                }
-        }
-        return -ENODEV;
-}
-
-#endif
diff --git a/include/linux/idr.h b/include/linux/idr.h
index fa14f834e4ed..7d6a6313f0ab 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -15,10 +15,10 @@
 #include <linux/radix-tree.h>
 #include <linux/gfp.h>
 #include <linux/percpu.h>
-#include <linux/bug.h>
 
 struct idr {
         struct radix_tree_root  idr_rt;
+        unsigned int            idr_base;
         unsigned int            idr_next;
 };
 
@@ -31,10 +31,26 @@ struct idr {
 /* Set the IDR flag and the IDR_FREE tag */
 #define IDR_RT_MARKER           ((__force gfp_t)(3 << __GFP_BITS_SHIFT))
 
-#define IDR_INIT                                                        \
-{                                                                       \
-        .idr_rt = RADIX_TREE_INIT(IDR_RT_MARKER)                        \
+#define IDR_INIT_BASE(base) {                                           \
+        .idr_rt = RADIX_TREE_INIT(IDR_RT_MARKER),                       \
+        .idr_base = (base),                                             \
+        .idr_next = 0,                                                  \
 }
+
+/**
+ * IDR_INIT() - Initialise an IDR.
+ *
+ * A freshly-initialised IDR contains no IDs.
+ */
+#define IDR_INIT        IDR_INIT_BASE(0)
+
+/**
+ * DEFINE_IDR() - Define a statically-allocated IDR
+ * @name: Name of IDR
+ *
+ * An IDR defined using this macro is ready for use with no additional
+ * initialisation required.  It contains no IDs.
+ */
 #define DEFINE_IDR(name)        struct idr name = IDR_INIT
 
 /**
@@ -82,80 +98,52 @@ static inline void idr_set_cursor(struct idr *idr, unsigned int val)
 
 void idr_preload(gfp_t gfp_mask);
 
-int idr_alloc_cmn(struct idr *idr, void *ptr, unsigned long *index,
-                  unsigned long start, unsigned long end, gfp_t gfp,
-                  bool ext);
-
-/**
- * idr_alloc - allocate an id
- * @idr: idr handle
- * @ptr: pointer to be associated with the new id
- * @start: the minimum id (inclusive)
- * @end: the maximum id (exclusive)
- * @gfp: memory allocation flags
- *
- * Allocates an unused ID in the range [start, end).  Returns -ENOSPC
- * if there are no unused IDs in that range.
- *
- * Note that @end is treated as max when <= 0.  This is to always allow
- * using @start + N as @end as long as N is inside integer range.
- *
- * Simultaneous modifications to the @idr are not allowed and should be
- * prevented by the user, usually with a lock.  idr_alloc() may be called
- * concurrently with read-only accesses to the @idr, such as idr_find() and
- * idr_for_each_entry().
- */
-static inline int idr_alloc(struct idr *idr, void *ptr,
-                            int start, int end, gfp_t gfp)
-{
-        unsigned long id;
-        int ret;
-
-        if (WARN_ON_ONCE(start < 0))
-                return -EINVAL;
-
-        ret = idr_alloc_cmn(idr, ptr, &id, start, end, gfp, false);
-
-        if (ret)
-                return ret;
-
-        return id;
-}
-
-static inline int idr_alloc_ext(struct idr *idr, void *ptr,
-                                unsigned long *index,
-                                unsigned long start,
-                                unsigned long end,
-                                gfp_t gfp)
-{
-        return idr_alloc_cmn(idr, ptr, index, start, end, gfp, true);
-}
-
-int idr_alloc_cyclic(struct idr *, void *entry, int start, int end, gfp_t);
+int idr_alloc(struct idr *, void *ptr, int start, int end, gfp_t);
+int __must_check idr_alloc_u32(struct idr *, void *ptr, u32 *id,
+                                unsigned long max, gfp_t);
+int idr_alloc_cyclic(struct idr *, void *ptr, int start, int end, gfp_t);
+void *idr_remove(struct idr *, unsigned long id);
+void *idr_find(const struct idr *, unsigned long id);
 int idr_for_each(const struct idr *,
                  int (*fn)(int id, void *p, void *data), void *data);
 void *idr_get_next(struct idr *, int *nextid);
-void *idr_get_next_ext(struct idr *idr, unsigned long *nextid);
-void *idr_replace(struct idr *, void *, int id);
-void *idr_replace_ext(struct idr *idr, void *ptr, unsigned long id);
+void *idr_get_next_ul(struct idr *, unsigned long *nextid);
+void *idr_replace(struct idr *, void *, unsigned long id);
 void idr_destroy(struct idr *);
 
-static inline void *idr_remove_ext(struct idr *idr, unsigned long id)
-{
-        return radix_tree_delete_item(&idr->idr_rt, id, NULL);
-}
-
-static inline void *idr_remove(struct idr *idr, int id)
+/**
+ * idr_init_base() - Initialise an IDR.
+ * @idr: IDR handle.
+ * @base: The base value for the IDR.
+ *
+ * This variation of idr_init() creates an IDR which will allocate IDs
+ * starting at %base.
+ */
+static inline void idr_init_base(struct idr *idr, int base)
 {
-        return idr_remove_ext(idr, id);
+        INIT_RADIX_TREE(&idr->idr_rt, IDR_RT_MARKER);
+        idr->idr_base = base;
+        idr->idr_next = 0;
 }
 
+/**
+ * idr_init() - Initialise an IDR.
+ * @idr: IDR handle.
+ *
+ * Initialise a dynamically allocated IDR.  To initialise a
+ * statically allocated IDR, use DEFINE_IDR().
+ */
 static inline void idr_init(struct idr *idr)
 {
-        INIT_RADIX_TREE(&idr->idr_rt, IDR_RT_MARKER);
-        idr->idr_next = 0;
+        idr_init_base(idr, 0);
 }
 
+/**
+ * idr_is_empty() - Are there any IDs allocated?
+ * @idr: IDR handle.
+ *
+ * Return: %true if any IDs have been allocated from this IDR.
+ */
 static inline bool idr_is_empty(const struct idr *idr)
 {
         return radix_tree_empty(&idr->idr_rt) &&
@@ -174,50 +162,38 @@ static inline void idr_preload_end(void)
 }
 
 /**
- * idr_find - return pointer for given id
- * @idr: idr handle
- * @id: lookup key
- *
- * Return the pointer given the id it has been registered with.  A %NULL
- * return indicates that @id is not valid or you passed %NULL in
- * idr_get_new().
+ * idr_for_each_entry() - Iterate over an IDR's elements of a given type.
+ * @idr: IDR handle.
+ * @entry: The type * to use as cursor
+ * @id: Entry ID.
  *
- * This function can be called under rcu_read_lock(), given that the leaf
- * pointers lifetimes are correctly managed.
+ * @entry and @id do not need to be initialized before the loop, and
+ * after normal termination @entry is left with the value NULL.  This
+ * is convenient for a "not found" value.
  */
-static inline void *idr_find_ext(const struct idr *idr, unsigned long id)
-{
-        return radix_tree_lookup(&idr->idr_rt, id);
-}
-
-static inline void *idr_find(const struct idr *idr, int id)
-{
-        return idr_find_ext(idr, id);
-}
+#define idr_for_each_entry(idr, entry, id)                      \
+        for (id = 0; ((entry) = idr_get_next(idr, &(id))) != NULL; ++id)
 
 /**
- * idr_for_each_entry - iterate over an idr's elements of a given type
- * @idr:     idr handle
- * @entry:   the type * to use as cursor
- * @id:      id entry's key
+ * idr_for_each_entry_ul() - Iterate over an IDR's elements of a given type.
+ * @idr: IDR handle.
+ * @entry: The type * to use as cursor.
+ * @id: Entry ID.
  *
  * @entry and @id do not need to be initialized before the loop, and
- * after normal terminatinon @entry is left with the value NULL.  This
+ * after normal termination @entry is left with the value NULL.  This
  * is convenient for a "not found" value.
  */
-#define idr_for_each_entry(idr, entry, id)                      \
-        for (id = 0; ((entry) = idr_get_next(idr, &(id))) != NULL; ++id)
-#define idr_for_each_entry_ext(idr, entry, id)                  \
-        for (id = 0; ((entry) = idr_get_next_ext(idr, &(id))) != NULL; ++id)
+#define idr_for_each_entry_ul(idr, entry, id)                   \
+        for (id = 0; ((entry) = idr_get_next_ul(idr, &(id))) != NULL; ++id)
 
 /**
- * idr_for_each_entry_continue - continue iteration over an idr's elements of a given type
- * @idr:     idr handle
- * @entry:   the type * to use as cursor
- * @id:      id entry's key
+ * idr_for_each_entry_continue() - Continue iteration over an IDR's elements of a given type
+ * @idr: IDR handle.
+ * @entry: The type * to use as a cursor.
+ * @id: Entry ID.
  *
- * Continue to iterate over list of given type, continuing after
- * the current position.
+ * Continue to iterate over entries, continuing after the current position.
  */
 #define idr_for_each_entry_continue(idr, entry, id)                     \
         for ((entry) = idr_get_next((idr), &(id));                      \
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index 4c54611e03e9..622658dfbf0a 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -13,6 +13,8 @@ struct ifla_vf_stats {
         __u64 tx_bytes;
         __u64 broadcast;
         __u64 multicast;
+        __u64 rx_dropped;
+        __u64 tx_dropped;
 };
 
 struct ifla_vf_info {
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
index bedf54b6f943..4cb7aeeafce0 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -30,10 +30,10 @@ struct macvlan_dev {
         enum macvlan_mode       mode;
         u16                     flags;
         int                     nest_level;
+        unsigned int            macaddr_count;
 #ifdef CONFIG_NET_POLL_CONTROLLER
         struct netpoll          *netpoll;
 #endif
-        unsigned int            macaddr_count;
 };
 
 static inline void macvlan_count_rx(const struct macvlan_dev *vlan,
diff --git a/include/linux/if_tap.h b/include/linux/if_tap.h
index 3ecef57c31e3..8e66866c11be 100644
--- a/include/linux/if_tap.h
+++ b/include/linux/if_tap.h
@@ -4,7 +4,7 @@
 
 #if IS_ENABLED(CONFIG_TAP)
 struct socket *tap_get_socket(struct file *);
-struct skb_array *tap_get_skb_array(struct file *file);
+struct ptr_ring *tap_get_ptr_ring(struct file *file);
 #else
 #include <linux/err.h>
 #include <linux/errno.h>
@@ -14,7 +14,7 @@ static inline struct socket *tap_get_socket(struct file *f)
 {
         return ERR_PTR(-EINVAL);
 }
-static inline struct skb_array *tap_get_skb_array(struct file *f)
+static inline struct ptr_ring *tap_get_ptr_ring(struct file *f)
 {
         return ERR_PTR(-EINVAL);
 }
@@ -70,7 +70,7 @@ struct tap_queue {
         u16 queue_index;
         bool enabled;
         struct list_head next;
-        struct skb_array skb_array;
+        struct ptr_ring ring;
 };
 
 rx_handler_result_t tap_handle_frame(struct sk_buff **pskb);
diff --git a/include/linux/if_tun.h b/include/linux/if_tun.h
index bf9bdf42d577..c5b0a75a7812 100644
--- a/include/linux/if_tun.h
+++ b/include/linux/if_tun.h
@@ -17,9 +17,14 @@
 
 #include <uapi/linux/if_tun.h>
 
+#define TUN_XDP_FLAG 0x1UL
+
 #if defined(CONFIG_TUN) || defined(CONFIG_TUN_MODULE)
 struct socket *tun_get_socket(struct file *);
-struct skb_array *tun_get_skb_array(struct file *file);
+struct ptr_ring *tun_get_tx_ring(struct file *file);
+bool tun_is_xdp_buff(void *ptr);
+void *tun_xdp_to_ptr(void *ptr);
+void *tun_ptr_to_xdp(void *ptr);
 #else
 #include <linux/err.h>
 #include <linux/errno.h>
@@ -29,9 +34,21 @@ static inline struct socket *tun_get_socket(struct file *f)
 {
         return ERR_PTR(-EINVAL);
 }
-static inline struct skb_array *tun_get_skb_array(struct file *f)
+static inline struct ptr_ring *tun_get_tx_ring(struct file *f)
 {
         return ERR_PTR(-EINVAL);
 }
+static inline bool tun_is_xdp_buff(void *ptr)
+{
+        return false;
+}
+static inline void *tun_xdp_to_ptr(void *ptr)
+{
+        return NULL;
+}
+static inline void *tun_ptr_to_xdp(void *ptr)
+{
+        return NULL;
+}
 #endif /* CONFIG_TUN */
 #endif /* __IF_TUN_H */
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index f12a61be1ede..11579fd4126e 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -578,8 +578,8 @@ const struct iio_chan_spec
  * iio_device_register() - register a device with the IIO subsystem
  * @indio_dev:          Device structure filled by the device driver
  **/
-#define iio_device_register(iio_dev) \
-        __iio_device_register((iio_dev), THIS_MODULE)
+#define iio_device_register(indio_dev) \
+        __iio_device_register((indio_dev), THIS_MODULE)
 int __iio_device_register(struct iio_dev *indio_dev, struct module *this_mod);
 void iio_device_unregister(struct iio_dev *indio_dev);
 /**
diff --git a/include/linux/iio/machine.h b/include/linux/iio/machine.h
index 1601a2a63a72..5e1cfa75f652 100644
--- a/include/linux/iio/machine.h
+++ b/include/linux/iio/machine.h
@@ -28,4 +28,11 @@ struct iio_map {
         void *consumer_data;
 };
 
+#define IIO_MAP(_provider_channel, _consumer_dev_name, _consumer_channel) \
+{                                                                         \
+        .adc_channel_label = _provider_channel,                           \
+        .consumer_dev_name = _consumer_dev_name,                          \
+        .consumer_channel  = _consumer_channel,                           \
+}
+
 #endif
diff --git a/include/linux/iio/trigger.h b/include/linux/iio/trigger.h
index 7d5e44518379..b19b7204ef84 100644
--- a/include/linux/iio/trigger.h
+++ b/include/linux/iio/trigger.h
@@ -43,12 +43,13 @@ struct iio_trigger_ops {
 /**
  * struct iio_trigger - industrial I/O trigger device
  * @ops:                [DRIVER] operations structure
+ * @owner:              [INTERN] owner of this driver module
  * @id:                 [INTERN] unique id number
  * @name:               [DRIVER] unique name
  * @dev:                [DRIVER] associated device (if relevant)
  * @list:               [INTERN] used in maintenance of global trigger list
  * @alloc_list:         [DRIVER] used for driver specific trigger list
- * @use_count:          use count for the trigger
+ * @use_count:          [INTERN] use count for the trigger.
  * @subirq_chip:        [INTERN] associate 'virtual' irq chip.
  * @subirq_base:        [INTERN] base number for irqs provided by trigger.
  * @subirqs:            [INTERN] information about the 'child' irqs.
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 1ac5bf95bfdd..e16fe7d44a71 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -173,7 +173,7 @@ static inline struct net_device *ip_dev_find(struct net *net, __be32 addr)
 }
 
 int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b);
-int devinet_ioctl(struct net *net, unsigned int cmd, void __user *);
+int devinet_ioctl(struct net *net, unsigned int cmd, struct ifreq *);
 void devinet_init(void);
 struct in_device *inetdev_by_index(struct net *, int);
 __be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope);
diff --git a/include/linux/init.h b/include/linux/init.h
index ea1b31101d9e..506a98151131 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -5,6 +5,13 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
 
+/* Built-in __init functions needn't be compiled with retpoline */
+#if defined(RETPOLINE) && !defined(MODULE)
+#define __noretpoline __attribute__((indirect_branch("keep")))
+#else
+#define __noretpoline
+#endif
+
 /* These macros are used to mark some functions or 
  * initialized data (doesn't apply to uninitialized data)
  * as `initialization' functions. The kernel can take this
@@ -40,7 +47,7 @@
 
 /* These are for everybody (although not all archs will actually
    discard it in modules) */
-#define __init          __section(.init.text) __cold  __latent_entropy
+#define __init          __section(.init.text) __cold  __latent_entropy __noretpoline
 #define __initdata      __section(.init.data)
 #define __initconst     __section(.init.rodata)
 #define __exitdata      __section(.exit.data)
diff --git a/include/linux/input/gpio_tilt.h b/include/linux/input/gpio_tilt.h
deleted file mode 100644
index f9d932476a80..000000000000
--- a/include/linux/input/gpio_tilt.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _INPUT_GPIO_TILT_H
-#define _INPUT_GPIO_TILT_H
-
-/**
- * struct gpio_tilt_axis - Axis used by the tilt switch
- * @axis:               Constant describing the axis, e.g. ABS_X
- * @min:                minimum value for abs_param
- * @max:                maximum value for abs_param
- * @fuzz:               fuzz value for abs_param
- * @flat:               flat value for abs_param
- */
-struct gpio_tilt_axis {
-        int axis;
-        int min;
-        int max;
-        int fuzz;
-        int flat;
-};
-
-/**
- * struct gpio_tilt_state - state description
- * @gpios:              bitfield of gpio target-states for the value
- * @axes:               array containing the axes settings for the gpio state
- *                      The array indizes must correspond to the axes defined
- *                      in platform_data
- *
- * This structure describes a supported axis settings
- * and the necessary gpio-state which represent it.
- *
- * The n-th bit in the bitfield describes the state of the n-th GPIO
- * from the gpios-array defined in gpio_regulator_config below.
- */
-struct gpio_tilt_state {
-        int gpios;
-        int *axes;
-};
-
-/**
- * struct gpio_tilt_platform_data
- * @gpios:              Array containing the gpios determining the tilt state
- * @nr_gpios:           Number of gpios
- * @axes:               Array of gpio_tilt_axis descriptions
- * @nr_axes:            Number of axes
- * @states:             Array of gpio_tilt_state entries describing
- *                      the gpio state for specific tilts
- * @nr_states:          Number of states available
- * @debounce_interval:  debounce ticks interval in msecs
- * @poll_interval:      polling interval in msecs - for polling driver only
- * @enable:             callback to enable the tilt switch
- * @disable:            callback to disable the tilt switch
- *
- * This structure contains gpio-tilt-switch configuration
- * information that must be passed by platform code to the
- * gpio-tilt input driver.
- */
-struct gpio_tilt_platform_data {
-        struct gpio *gpios;
-        int nr_gpios;
-
-        struct gpio_tilt_axis *axes;
-        int nr_axes;
-
-        struct gpio_tilt_state *states;
-        int nr_states;
-
-        int debounce_interval;
-
-        unsigned int poll_interval;
-        int (*enable)(struct device *dev);
-        void (*disable)(struct device *dev);
-};
-
-#endif
diff --git a/include/linux/integrity.h b/include/linux/integrity.h
index c2d6082a1a4c..858d3f4a2241 100644
--- a/include/linux/integrity.h
+++ b/include/linux/integrity.h
@@ -14,6 +14,7 @@
 
 enum integrity_status {
         INTEGRITY_PASS = 0,
+        INTEGRITY_PASS_IMMUTABLE,
         INTEGRITY_FAIL,
         INTEGRITY_NOLABEL,
         INTEGRITY_NOXATTRS,
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index f3274d9f46a2..8dad3dd26eae 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -83,7 +83,9 @@
 /*
  * Decoding Capability Register
  */
+#define cap_5lp_support(c)      (((c) >> 60) & 1)
 #define cap_pi_support(c)       (((c) >> 59) & 1)
+#define cap_fl1gp_support(c)    (((c) >> 56) & 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)
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 93b4183cf53d..da0ebaec25f0 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -265,7 +265,7 @@ extern struct resource * __devm_request_region(struct device *dev,
 extern void __devm_release_region(struct device *dev, struct resource *parent,
                                   resource_size_t start, resource_size_t n);
 extern int iomem_map_sanity_check(resource_size_t addr, unsigned long size);
-extern int iomem_is_exclusive(u64 addr);
+extern bool iomem_is_exclusive(u64 addr);
 
 extern int
 walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
diff --git a/include/linux/irq_work.h b/include/linux/irq_work.h
index 0e81035b678f..b11fcdfd0770 100644
--- a/include/linux/irq_work.h
+++ b/include/linux/irq_work.h
@@ -13,10 +13,13 @@
  * busy      NULL, 2 -> {free, claimed} : callback in progress, can be claimed
  */
 
-#define IRQ_WORK_PENDING        1UL
-#define IRQ_WORK_BUSY           2UL
-#define IRQ_WORK_FLAGS          3UL
-#define IRQ_WORK_LAZY           4UL /* Doesn't want IPI, wait for tick */
+#define IRQ_WORK_PENDING        BIT(0)
+#define IRQ_WORK_BUSY           BIT(1)
+
+/* Doesn't want IPI, wait for tick: */
+#define IRQ_WORK_LAZY           BIT(2)
+
+#define IRQ_WORK_CLAIMED        (IRQ_WORK_PENDING | IRQ_WORK_BUSY)
 
 struct irq_work {
         unsigned long flags;
diff --git a/include/linux/iversion.h b/include/linux/iversion.h
new file mode 100644
index 000000000000..be50ef7cedab
--- /dev/null
+++ b/include/linux/iversion.h
@@ -0,0 +1,337 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_IVERSION_H
+#define _LINUX_IVERSION_H
+
+#include <linux/fs.h>
+
+/*
+ * The inode->i_version field:
+ * ---------------------------
+ * The change attribute (i_version) is mandated by NFSv4 and is mostly for
+ * knfsd, but is also used for other purposes (e.g. IMA). The i_version must
+ * appear different to observers if there was a change to the inode's data or
+ * metadata since it was last queried.
+ *
+ * Observers see the i_version as a 64-bit number that never decreases. If it
+ * remains the same since it was last checked, then nothing has changed in the
+ * inode. If it's different then something has changed. Observers cannot infer
+ * anything about the nature or magnitude of the changes from the value, only
+ * that the inode has changed in some fashion.
+ *
+ * Not all filesystems properly implement the i_version counter. Subsystems that
+ * want to use i_version field on an inode should first check whether the
+ * filesystem sets the SB_I_VERSION flag (usually via the IS_I_VERSION macro).
+ *
+ * Those that set SB_I_VERSION will automatically have their i_version counter
+ * incremented on writes to normal files. If the SB_I_VERSION is not set, then
+ * the VFS will not touch it on writes, and the filesystem can use it how it
+ * wishes. Note that the filesystem is always responsible for updating the
+ * i_version on namespace changes in directories (mkdir, rmdir, unlink, etc.).
+ * We consider these sorts of filesystems to have a kernel-managed i_version.
+ *
+ * It may be impractical for filesystems to keep i_version updates atomic with
+ * respect to the changes that cause them.  They should, however, guarantee
+ * that i_version updates are never visible before the changes that caused
+ * them.  Also, i_version updates should never be delayed longer than it takes
+ * the original change to reach disk.
+ *
+ * This implementation uses the low bit in the i_version field as a flag to
+ * track when the value has been queried. If it has not been queried since it
+ * was last incremented, we can skip the increment in most cases.
+ *
+ * In the event that we're updating the ctime, we will usually go ahead and
+ * bump the i_version anyway. Since that has to go to stable storage in some
+ * fashion, we might as well increment it as well.
+ *
+ * With this implementation, the value should always appear to observers to
+ * increase over time if the file has changed. It's recommended to use
+ * inode_eq_iversion() helper to compare values.
+ *
+ * Note that some filesystems (e.g. NFS and AFS) just use the field to store
+ * a server-provided value (for the most part). For that reason, those
+ * filesystems do not set SB_I_VERSION. These filesystems are considered to
+ * have a self-managed i_version.
+ *
+ * Persistently storing the i_version
+ * ----------------------------------
+ * Queries of the i_version field are not gated on them hitting the backing
+ * store. It's always possible that the host could crash after allowing
+ * a query of the value but before it has made it to disk.
+ *
+ * To mitigate this problem, filesystems should always use
+ * inode_set_iversion_queried when loading an existing inode from disk. This
+ * ensures that the next attempted inode increment will result in the value
+ * changing.
+ *
+ * Storing the value to disk therefore does not count as a query, so those
+ * filesystems should use inode_peek_iversion to grab the value to be stored.
+ * There is no need to flag the value as having been queried in that case.
+ */
+
+/*
+ * We borrow the lowest bit in the i_version to use as a flag to tell whether
+ * it has been queried since we last incremented it. If it has, then we must
+ * increment it on the next change. After that, we can clear the flag and
+ * avoid incrementing it again until it has again been queried.
+ */
+#define I_VERSION_QUERIED_SHIFT (1)
+#define I_VERSION_QUERIED       (1ULL << (I_VERSION_QUERIED_SHIFT - 1))
+#define I_VERSION_INCREMENT     (1ULL << I_VERSION_QUERIED_SHIFT)
+
+/**
+ * inode_set_iversion_raw - set i_version to the specified raw value
+ * @inode: inode to set
+ * @val: new i_version value to set
+ *
+ * Set @inode's i_version field to @val. This function is for use by
+ * filesystems that self-manage the i_version.
+ *
+ * For example, the NFS client stores its NFSv4 change attribute in this way,
+ * and the AFS client stores the data_version from the server here.
+ */
+static inline void
+inode_set_iversion_raw(struct inode *inode, u64 val)
+{
+        atomic64_set(&inode->i_version, val);
+}
+
+/**
+ * inode_peek_iversion_raw - grab a "raw" iversion value
+ * @inode: inode from which i_version should be read
+ *
+ * Grab a "raw" inode->i_version value and return it. The i_version is not
+ * flagged or converted in any way. This is mostly used to access a self-managed
+ * i_version.
+ *
+ * With those filesystems, we want to treat the i_version as an entirely
+ * opaque value.
+ */
+static inline u64
+inode_peek_iversion_raw(const struct inode *inode)
+{
+        return atomic64_read(&inode->i_version);
+}
+
+/**
+ * inode_set_iversion - set i_version to a particular value
+ * @inode: inode to set
+ * @val: new i_version value to set
+ *
+ * Set @inode's i_version field to @val. This function is for filesystems with
+ * a kernel-managed i_version, for initializing a newly-created inode from
+ * scratch.
+ *
+ * In this case, we do not set the QUERIED flag since we know that this value
+ * has never been queried.
+ */
+static inline void
+inode_set_iversion(struct inode *inode, u64 val)
+{
+        inode_set_iversion_raw(inode, val << I_VERSION_QUERIED_SHIFT);
+}
+
+/**
+ * inode_set_iversion_queried - set i_version to a particular value as quereied
+ * @inode: inode to set
+ * @val: new i_version value to set
+ *
+ * Set @inode's i_version field to @val, and flag it for increment on the next
+ * change.
+ *
+ * Filesystems that persistently store the i_version on disk should use this
+ * when loading an existing inode from disk.
+ *
+ * When loading in an i_version value from a backing store, we can't be certain
+ * that it wasn't previously viewed before being stored. Thus, we must assume
+ * that it was, to ensure that we don't end up handing out the same value for
+ * different versions of the same inode.
+ */
+static inline void
+inode_set_iversion_queried(struct inode *inode, u64 val)
+{
+        inode_set_iversion_raw(inode, (val << I_VERSION_QUERIED_SHIFT) |
+                                I_VERSION_QUERIED);
+}
+
+/**
+ * inode_maybe_inc_iversion - increments i_version
+ * @inode: inode with the i_version that should be updated
+ * @force: increment the counter even if it's not necessary?
+ *
+ * Every time the inode is modified, the i_version field must be seen to have
+ * changed by any observer.
+ *
+ * If "force" is set or the QUERIED flag is set, then ensure that we increment
+ * the value, and clear the queried flag.
+ *
+ * In the common case where neither is set, then we can return "false" without
+ * updating i_version.
+ *
+ * If this function returns false, and no other metadata has changed, then we
+ * can avoid logging the metadata.
+ */
+static inline bool
+inode_maybe_inc_iversion(struct inode *inode, bool force)
+{
+        u64 cur, old, new;
+
+        /*
+         * The i_version field is not strictly ordered with any other inode
+         * information, but the legacy inode_inc_iversion code used a spinlock
+         * to serialize increments.
+         *
+         * Here, we add full memory barriers to ensure that any de-facto
+         * ordering with other info is preserved.
+         *
+         * This barrier pairs with the barrier in inode_query_iversion()
+         */
+        smp_mb();
+        cur = inode_peek_iversion_raw(inode);
+        for (;;) {
+                /* If flag is clear then we needn't do anything */
+                if (!force && !(cur & I_VERSION_QUERIED))
+                        return false;
+
+                /* Since lowest bit is flag, add 2 to avoid it */
+                new = (cur & ~I_VERSION_QUERIED) + I_VERSION_INCREMENT;
+
+                old = atomic64_cmpxchg(&inode->i_version, cur, new);
+                if (likely(old == cur))
+                        break;
+                cur = old;
+        }
+        return true;
+}
+
+
+/**
+ * inode_inc_iversion - forcibly increment i_version
+ * @inode: inode that needs to be updated
+ *
+ * Forcbily increment the i_version field. This always results in a change to
+ * the observable value.
+ */
+static inline void
+inode_inc_iversion(struct inode *inode)
+{
+        inode_maybe_inc_iversion(inode, true);
+}
+
+/**
+ * inode_iversion_need_inc - is the i_version in need of being incremented?
+ * @inode: inode to check
+ *
+ * Returns whether the inode->i_version counter needs incrementing on the next
+ * change. Just fetch the value and check the QUERIED flag.
+ */
+static inline bool
+inode_iversion_need_inc(struct inode *inode)
+{
+        return inode_peek_iversion_raw(inode) & I_VERSION_QUERIED;
+}
+
+/**
+ * inode_inc_iversion_raw - forcibly increment raw i_version
+ * @inode: inode that needs to be updated
+ *
+ * Forcbily increment the raw i_version field. This always results in a change
+ * to the raw value.
+ *
+ * NFS will use the i_version field to store the value from the server. It
+ * mostly treats it as opaque, but in the case where it holds a write
+ * delegation, it must increment the value itself. This function does that.
+ */
+static inline void
+inode_inc_iversion_raw(struct inode *inode)
+{
+        atomic64_inc(&inode->i_version);
+}
+
+/**
+ * inode_peek_iversion - read i_version without flagging it to be incremented
+ * @inode: inode from which i_version should be read
+ *
+ * Read the inode i_version counter for an inode without registering it as a
+ * query.
+ *
+ * This is typically used by local filesystems that need to store an i_version
+ * on disk. In that situation, it's not necessary to flag it as having been
+ * viewed, as the result won't be used to gauge changes from that point.
+ */
+static inline u64
+inode_peek_iversion(const struct inode *inode)
+{
+        return inode_peek_iversion_raw(inode) >> I_VERSION_QUERIED_SHIFT;
+}
+
+/**
+ * inode_query_iversion - read i_version for later use
+ * @inode: inode from which i_version should be read
+ *
+ * Read the inode i_version counter. This should be used by callers that wish
+ * to store the returned i_version for later comparison. This will guarantee
+ * that a later query of the i_version will result in a different value if
+ * anything has changed.
+ *
+ * In this implementation, we fetch the current value, set the QUERIED flag and
+ * then try to swap it into place with a cmpxchg, if it wasn't already set. If
+ * that fails, we try again with the newly fetched value from the cmpxchg.
+ */
+static inline u64
+inode_query_iversion(struct inode *inode)
+{
+        u64 cur, old, new;
+
+        cur = inode_peek_iversion_raw(inode);
+        for (;;) {
+                /* If flag is already set, then no need to swap */
+                if (cur & I_VERSION_QUERIED) {
+                        /*
+                         * This barrier (and the implicit barrier in the
+                         * cmpxchg below) pairs with the barrier in
+                         * inode_maybe_inc_iversion().
+                         */
+                        smp_mb();
+                        break;
+                }
+
+                new = cur | I_VERSION_QUERIED;
+                old = atomic64_cmpxchg(&inode->i_version, cur, new);
+                if (likely(old == cur))
+                        break;
+                cur = old;
+        }
+        return cur >> I_VERSION_QUERIED_SHIFT;
+}
+
+/**
+ * inode_eq_iversion_raw - check whether the raw i_version counter has changed
+ * @inode: inode to check
+ * @old: old value to check against its i_version
+ *
+ * Compare the current raw i_version counter with a previous one. Returns true
+ * if they are the same or false if they are different.
+ */
+static inline bool
+inode_eq_iversion_raw(const struct inode *inode, u64 old)
+{
+        return inode_peek_iversion_raw(inode) == old;
+}
+
+/**
+ * inode_eq_iversion - check whether the i_version counter has changed
+ * @inode: inode to check
+ * @old: old value to check against its i_version
+ *
+ * Compare an i_version counter with a previous one. Returns true if they are
+ * the same, and false if they are different.
+ *
+ * Note that we don't need to set the QUERIED flag in this case, as the value
+ * in the inode is not being recorded for later use.
+ */
+static inline bool
+inode_eq_iversion(const struct inode *inode, u64 old)
+{
+        return inode_peek_iversion(inode) == old;
+}
+#endif
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 296d1e0ea87b..b708e5169d1d 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -418,26 +418,41 @@ static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
 #define JI_WAIT_DATA (1 << __JI_WAIT_DATA)
 
 /**
- * struct jbd_inode is the structure linking inodes in ordered mode
- *   present in a transaction so that we can sync them during commit.
+ * struct jbd_inode - The jbd_inode type is the structure linking inodes in
+ * ordered mode present in a transaction so that we can sync them during commit.
  */
 struct jbd2_inode {
-        /* Which transaction does this inode belong to? Either the running
-         * transaction or the committing one. [j_list_lock] */
+        /**
+         * @i_transaction:
+         *
+         * Which transaction does this inode belong to? Either the running
+         * transaction or the committing one. [j_list_lock]
+         */
         transaction_t *i_transaction;
 
-        /* Pointer to the running transaction modifying inode's data in case
-         * there is already a committing transaction touching it. [j_list_lock] */
+        /**
+         * @i_next_transaction:
+         *
+         * Pointer to the running transaction modifying inode's data in case
+         * there is already a committing transaction touching it. [j_list_lock]
+         */
         transaction_t *i_next_transaction;
 
-        /* List of inodes in the i_transaction [j_list_lock] */
+        /**
+         * @i_list: List of inodes in the i_transaction [j_list_lock]
+         */
         struct list_head i_list;
 
-        /* VFS inode this inode belongs to [constant during the lifetime
-         * of the structure] */
+        /**
+         * @i_vfs_inode:
+         *
+         * VFS inode this inode belongs to [constant for lifetime of structure]
+         */
         struct inode *i_vfs_inode;
 
-        /* Flags of inode [j_list_lock] */
+        /**
+         * @i_flags: Flags of inode [j_list_lock]
+         */
         unsigned long i_flags;
 };
 
@@ -447,12 +462,20 @@ struct jbd2_revoke_table_s;
  * struct handle_s - The handle_s type is the concrete type associated with
  *     handle_t.
  * @h_transaction: Which compound transaction is this update a part of?
+ * @h_journal: Which journal handle belongs to - used iff h_reserved set.
+ * @h_rsv_handle: Handle reserved for finishing the logical operation.
  * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
- * @h_ref: Reference count on this handle
- * @h_err: Field for caller's use to track errors through large fs operations
- * @h_sync: flag for sync-on-close
- * @h_jdata: flag to force data journaling
- * @h_aborted: flag indicating fatal error on handle
+ * @h_ref: Reference count on this handle.
+ * @h_err: Field for caller's use to track errors through large fs operations.
+ * @h_sync: Flag for sync-on-close.
+ * @h_jdata: Flag to force data journaling.
+ * @h_reserved: Flag for handle for reserved credits.
+ * @h_aborted: Flag indicating fatal error on handle.
+ * @h_type: For handle statistics.
+ * @h_line_no: For handle statistics.
+ * @h_start_jiffies: Handle Start time.
+ * @h_requested_credits: Holds @h_buffer_credits after handle is started.
+ * @saved_alloc_context: Saved context while transaction is open.
  **/
 
 /* Docbook can't yet cope with the bit fields, but will leave the documentation
@@ -462,32 +485,23 @@ struct jbd2_revoke_table_s;
 struct jbd2_journal_handle
 {
         union {
-                /* Which compound transaction is this update a part of? */
                 transaction_t   *h_transaction;
                 /* Which journal handle belongs to - used iff h_reserved set */
                 journal_t       *h_journal;
         };
 
-        /* Handle reserved for finishing the logical operation */
         handle_t                *h_rsv_handle;
-
-        /* Number of remaining buffers we are allowed to dirty: */
         int                     h_buffer_credits;
-
-        /* Reference count on this handle */
         int                     h_ref;
-
-        /* Field for caller's use to track errors through large fs */
-        /* operations */
         int                     h_err;
 
         /* Flags [no locking] */
-        unsigned int    h_sync:         1;      /* sync-on-close */
-        unsigned int    h_jdata:        1;      /* force data journaling */
-        unsigned int    h_reserved:     1;      /* handle with reserved credits */
-        unsigned int    h_aborted:      1;      /* fatal error on handle */
-        unsigned int    h_type:         8;      /* for handle statistics */
-        unsigned int    h_line_no:      16;     /* for handle statistics */
+        unsigned int    h_sync:         1;
+        unsigned int    h_jdata:        1;
+        unsigned int    h_reserved:     1;
+        unsigned int    h_aborted:      1;
+        unsigned int    h_type:         8;
+        unsigned int    h_line_no:      16;
 
         unsigned long           h_start_jiffies;
         unsigned int            h_requested_credits;
@@ -729,228 +743,253 @@ jbd2_time_diff(unsigned long start, unsigned long end)
 /**
  * struct journal_s - The journal_s type is the concrete type associated with
  *     journal_t.
- * @j_flags:  General journaling state flags
- * @j_errno:  Is there an outstanding uncleared error on the journal (from a
- *     prior abort)?
- * @j_sb_buffer: First part of superblock buffer
- * @j_superblock: Second part of superblock buffer
- * @j_format_version: Version of the superblock format
- * @j_state_lock: Protect the various scalars in the journal
- * @j_barrier_count:  Number of processes waiting to create a barrier lock
- * @j_barrier: The barrier lock itself
- * @j_running_transaction: The current running transaction..
- * @j_committing_transaction: the transaction we are pushing to disk
- * @j_checkpoint_transactions: a linked circular list of all transactions
- *  waiting for checkpointing
- * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
- *  to start committing, or for a barrier lock to be released
- * @j_wait_done_commit: Wait queue for waiting for commit to complete
- * @j_wait_commit: Wait queue to trigger commit
- * @j_wait_updates: Wait queue to wait for updates to complete
- * @j_wait_reserved: Wait queue to wait for reserved buffer credits to drop
- * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
- * @j_head: Journal head - identifies the first unused block in the journal
- * @j_tail: Journal tail - identifies the oldest still-used block in the
- *  journal.
- * @j_free: Journal free - how many free blocks are there in the journal?
- * @j_first: The block number of the first usable block
- * @j_last: The block number one beyond the last usable block
- * @j_dev: Device where we store the journal
- * @j_blocksize: blocksize for the location where we store the journal.
- * @j_blk_offset: starting block offset for into the device where we store the
- *     journal
- * @j_fs_dev: Device which holds the client fs.  For internal journal this will
- *     be equal to j_dev
- * @j_reserved_credits: Number of buffers reserved from the running transaction
- * @j_maxlen: Total maximum capacity of the journal region on disk.
- * @j_list_lock: Protects the buffer lists and internal buffer state.
- * @j_inode: Optional inode where we store the journal.  If present, all journal
- *     block numbers are mapped into this inode via bmap().
- * @j_tail_sequence:  Sequence number of the oldest transaction in the log
- * @j_transaction_sequence: Sequence number of the next transaction to grant
- * @j_commit_sequence: Sequence number of the most recently committed
- *  transaction
- * @j_commit_request: Sequence number of the most recent transaction wanting
- *     commit
- * @j_uuid: Uuid of client object.
- * @j_task: Pointer to the current commit thread for this journal
- * @j_max_transaction_buffers:  Maximum number of metadata buffers to allow in a
- *     single compound commit transaction
- * @j_commit_interval: What is the maximum transaction lifetime before we begin
- *  a commit?
- * @j_commit_timer:  The timer used to wakeup the commit thread
- * @j_revoke_lock: Protect the revoke table
- * @j_revoke: The revoke table - maintains the list of revoked blocks in the
- *     current transaction.
- * @j_revoke_table: alternate revoke tables for j_revoke
- * @j_wbuf: array of buffer_heads for jbd2_journal_commit_transaction
- * @j_wbufsize: maximum number of buffer_heads allowed in j_wbuf, the
- *      number that will fit in j_blocksize
- * @j_last_sync_writer: most recent pid which did a synchronous write
- * @j_history_lock: Protect the transactions statistics history
- * @j_proc_entry: procfs entry for the jbd statistics directory
- * @j_stats: Overall statistics
- * @j_private: An opaque pointer to fs-private information.
- * @j_trans_commit_map: Lockdep entity to track transaction commit dependencies
  */
-
 struct journal_s
 {
-        /* General journaling state flags [j_state_lock] */
+        /**
+         * @j_flags: General journaling state flags [j_state_lock]
+         */
         unsigned long           j_flags;
 
-        /*
+        /**
+         * @j_errno:
+         *
          * Is there an outstanding uncleared error on the journal (from a prior
          * abort)? [j_state_lock]
          */
         int                     j_errno;
 
-        /* The superblock buffer */
+        /**
+         * @j_sb_buffer: The first part of the superblock buffer.
+         */
         struct buffer_head      *j_sb_buffer;
+
+        /**
+         * @j_superblock: The second part of the superblock buffer.
+         */
         journal_superblock_t    *j_superblock;
 
-        /* Version of the superblock format */
+        /**
+         * @j_format_version: Version of the superblock format.
+         */
         int                     j_format_version;
 
-        /*
-         * Protect the various scalars in the journal
+        /**
+         * @j_state_lock: Protect the various scalars in the journal.
          */
         rwlock_t                j_state_lock;
 
-        /*
+        /**
+         * @j_barrier_count:
+         *
          * Number of processes waiting to create a barrier lock [j_state_lock]
          */
         int                     j_barrier_count;
 
-        /* The barrier lock itself */
+        /**
+         * @j_barrier: The barrier lock itself.
+         */
         struct mutex            j_barrier;
 
-        /*
+        /**
+         * @j_running_transaction:
+         *
          * Transactions: The current running transaction...
          * [j_state_lock] [caller holding open handle]
          */
         transaction_t           *j_running_transaction;
 
-        /*
+        /**
+         * @j_committing_transaction:
+         *
          * the transaction we are pushing to disk
          * [j_state_lock] [caller holding open handle]
          */
         transaction_t           *j_committing_transaction;
 
-        /*
+        /**
+         * @j_checkpoint_transactions:
+         *
          * ... and a linked circular list of all transactions waiting for
          * checkpointing. [j_list_lock]
          */
         transaction_t           *j_checkpoint_transactions;
 
-        /*
+        /**
+         * @j_wait_transaction_locked:
+         *
          * Wait queue for waiting for a locked transaction to start committing,
-         * or for a barrier lock to be released
+         * or for a barrier lock to be released.
          */
         wait_queue_head_t       j_wait_transaction_locked;
 
-        /* Wait queue for waiting for commit to complete */
+        /**
+         * @j_wait_done_commit: Wait queue for waiting for commit to complete.
+         */
         wait_queue_head_t       j_wait_done_commit;
 
-        /* Wait queue to trigger commit */
+        /**
+         * @j_wait_commit: Wait queue to trigger commit.
+         */
         wait_queue_head_t       j_wait_commit;
 
-        /* Wait queue to wait for updates to complete */
+        /**
+         * @j_wait_updates: Wait queue to wait for updates to complete.
+         */
         wait_queue_head_t       j_wait_updates;
 
-        /* Wait queue to wait for reserved buffer credits to drop */
+        /**
+         * @j_wait_reserved:
+         *
+         * Wait queue to wait for reserved buffer credits to drop.
+         */
         wait_queue_head_t       j_wait_reserved;
 
-        /* Semaphore for locking against concurrent checkpoints */
+        /**
+         * @j_checkpoint_mutex:
+         *
+         * Semaphore for locking against concurrent checkpoints.
+         */
         struct mutex            j_checkpoint_mutex;
 
-        /*
+        /**
+         * @j_chkpt_bhs:
+         *
          * List of buffer heads used by the checkpoint routine.  This
          * was moved from jbd2_log_do_checkpoint() to reduce stack
          * usage.  Access to this array is controlled by the
-         * j_checkpoint_mutex.  [j_checkpoint_mutex]
+         * @j_checkpoint_mutex.  [j_checkpoint_mutex]
          */
         struct buffer_head      *j_chkpt_bhs[JBD2_NR_BATCH];
-        
-        /*
+
+        /**
+         * @j_head:
+         *
          * Journal head: identifies the first unused block in the journal.
          * [j_state_lock]
          */
         unsigned long           j_head;
 
-        /*
+        /**
+         * @j_tail:
+         *
          * Journal tail: identifies the oldest still-used block in the journal.
          * [j_state_lock]
          */
         unsigned long           j_tail;
 
-        /*
+        /**
+         * @j_free:
+         *
          * Journal free: how many free blocks are there in the journal?
          * [j_state_lock]
          */
         unsigned long           j_free;
 
-        /*
-         * Journal start and end: the block numbers of the first usable block
-         * and one beyond the last usable block in the journal. [j_state_lock]
+        /**
+         * @j_first:
+         *
+         * The block number of the first usable block in the journal
+         * [j_state_lock].
          */
         unsigned long           j_first;
+
+        /**
+         * @j_last:
+         *
+         * The block number one beyond the last usable block in the journal
+         * [j_state_lock].
+         */
         unsigned long           j_last;
 
-        /*
-         * Device, blocksize and starting block offset for the location where we
-         * store the journal.
+        /**
+         * @j_dev: Device where we store the journal.
          */
         struct block_device     *j_dev;
+
+        /**
+         * @j_blocksize: Block size for the location where we store the journal.
+         */
         int                     j_blocksize;
+
+        /**
+         * @j_blk_offset:
+         *
+         * Starting block offset into the device where we store the journal.
+         */
         unsigned long long      j_blk_offset;
+
+        /**
+         * @j_devname: Journal device name.
+         */
         char                    j_devname[BDEVNAME_SIZE+24];
 
-        /*
+        /**
+         * @j_fs_dev:
+         *
          * Device which holds the client fs.  For internal journal this will be
          * equal to j_dev.
          */
         struct block_device     *j_fs_dev;
 
-        /* Total maximum capacity of the journal region on disk. */
+        /**
+         * @j_maxlen: Total maximum capacity of the journal region on disk.
+         */
         unsigned int            j_maxlen;
 
-        /* Number of buffers reserved from the running transaction */
+        /**
+         * @j_reserved_credits:
+         *
+         * Number of buffers reserved from the running transaction.
+         */
         atomic_t                j_reserved_credits;
 
-        /*
-         * Protects the buffer lists and internal buffer state.
+        /**
+         * @j_list_lock: Protects the buffer lists and internal buffer state.
          */
         spinlock_t              j_list_lock;
 
-        /* Optional inode where we store the journal.  If present, all */
-        /* journal block numbers are mapped into this inode via */
-        /* bmap(). */
+        /**
+         * @j_inode:
+         *
+         * Optional inode where we store the journal.  If present, all
+         * journal block numbers are mapped into this inode via bmap().
+         */
         struct inode            *j_inode;
 
-        /*
+        /**
+         * @j_tail_sequence:
+         *
          * Sequence number of the oldest transaction in the log [j_state_lock]
          */
         tid_t                   j_tail_sequence;
 
-        /*
+        /**
+         * @j_transaction_sequence:
+         *
          * Sequence number of the next transaction to grant [j_state_lock]
          */
         tid_t                   j_transaction_sequence;
 
-        /*
+        /**
+         * @j_commit_sequence:
+         *
          * Sequence number of the most recently committed transaction
          * [j_state_lock].
          */
         tid_t                   j_commit_sequence;
 
-        /*
+        /**
+         * @j_commit_request:
+         *
          * Sequence number of the most recent transaction wanting commit
          * [j_state_lock]
          */
         tid_t                   j_commit_request;
 
-        /*
+        /**
+         * @j_uuid:
+         *
          * Journal uuid: identifies the object (filesystem, LVM volume etc)
          * backed by this journal.  This will eventually be replaced by an array
          * of uuids, allowing us to index multiple devices within a single
@@ -958,85 +997,151 @@ struct journal_s
          */
         __u8                    j_uuid[16];
 
-        /* Pointer to the current commit thread for this journal */
+        /**
+         * @j_task: Pointer to the current commit thread for this journal.
+         */
         struct task_struct      *j_task;
 
-        /*
+        /**
+         * @j_max_transaction_buffers:
+         *
          * Maximum number of metadata buffers to allow in a single compound
-         * commit transaction
+         * commit transaction.
          */
         int                     j_max_transaction_buffers;
 
-        /*
+        /**
+         * @j_commit_interval:
+         *
          * What is the maximum transaction lifetime before we begin a commit?
          */
         unsigned long           j_commit_interval;
 
-        /* The timer used to wakeup the commit thread: */
+        /**
+         * @j_commit_timer: The timer used to wakeup the commit thread.
+         */
         struct timer_list       j_commit_timer;
 
-        /*
-         * The revoke table: maintains the list of revoked blocks in the
-         * current transaction.  [j_revoke_lock]
+        /**
+         * @j_revoke_lock: Protect the revoke table.
          */
         spinlock_t              j_revoke_lock;
+
+        /**
+         * @j_revoke:
+         *
+         * The revoke table - maintains the list of revoked blocks in the
+         * current transaction.
+         */
         struct jbd2_revoke_table_s *j_revoke;
+
+        /**
+         * @j_revoke_table: Alternate revoke tables for j_revoke.
+         */
         struct jbd2_revoke_table_s *j_revoke_table[2];
 
-        /*
-         * array of bhs for jbd2_journal_commit_transaction
+        /**
+         * @j_wbuf: Array of bhs for jbd2_journal_commit_transaction.
          */
         struct buffer_head      **j_wbuf;
+
+        /**
+         * @j_wbufsize:
+         *
+         * Size of @j_wbuf array.
+         */
         int                     j_wbufsize;
 
-        /*
-         * this is the pid of hte last person to run a synchronous operation
-         * through the journal
+        /**
+         * @j_last_sync_writer:
+         *
+         * The pid of the last person to run a synchronous operation
+         * through the journal.
          */
         pid_t                   j_last_sync_writer;
 
-        /*
-         * the average amount of time in nanoseconds it takes to commit a
+        /**
+         * @j_average_commit_time:
+         *
+         * The average amount of time in nanoseconds it takes to commit a
          * transaction to disk. [j_state_lock]
          */
         u64                     j_average_commit_time;
 
-        /*
-         * minimum and maximum times that we should wait for
-         * additional filesystem operations to get batched into a
-         * synchronous handle in microseconds
+        /**
+         * @j_min_batch_time:
+         *
+         * Minimum time that we should wait for additional filesystem operations
+         * to get batched into a synchronous handle in microseconds.
          */
         u32                     j_min_batch_time;
+
+        /**
+         * @j_max_batch_time:
+         *
+         * Maximum time that we should wait for additional filesystem operations
+         * to get batched into a synchronous handle in microseconds.
+         */
         u32                     j_max_batch_time;
 
-        /* This function is called when a transaction is closed */
+        /**
+         * @j_commit_callback:
+         *
+         * This function is called when a transaction is closed.
+         */
         void                    (*j_commit_callback)(journal_t *,
                                                      transaction_t *);
 
         /*
          * Journal statistics
          */
+
+        /**
+         * @j_history_lock: Protect the transactions statistics history.
+         */
         spinlock_t              j_history_lock;
+
+        /**
+         * @j_proc_entry: procfs entry for the jbd statistics directory.
+         */
         struct proc_dir_entry   *j_proc_entry;
+
+        /**
+         * @j_stats: Overall statistics.
+         */
         struct transaction_stats_s j_stats;
 
-        /* Failed journal commit ID */
+        /**
+         * @j_failed_commit: Failed journal commit ID.
+         */
         unsigned int            j_failed_commit;
 
-        /*
+        /**
+         * @j_private:
+         *
          * An opaque pointer to fs-private information.  ext3 puts its
-         * superblock pointer here
+         * superblock pointer here.
          */
         void *j_private;
 
-        /* Reference to checksum algorithm driver via cryptoapi */
+        /**
+         * @j_chksum_driver:
+         *
+         * Reference to checksum algorithm driver via cryptoapi.
+         */
         struct crypto_shash *j_chksum_driver;
 
-        /* Precomputed journal UUID checksum for seeding other checksums */
+        /**
+         * @j_csum_seed:
+         *
+         * Precomputed journal UUID checksum for seeding other checksums.
+         */
         __u32 j_csum_seed;
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
-        /*
+        /**
+         * @j_trans_commit_map:
+         *
          * Lockdep entity to track transaction commit dependencies. Handles
          * hold this "lock" for read, when we wait for commit, we acquire the
          * "lock" for writing. This matches the properties of jbd2 journalling
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index e0340ca08d98..b6a29c126cc4 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -393,7 +393,7 @@ extern bool ____wrong_branch_error(void);
                 branch = !arch_static_branch_jump(&(x)->key, true);             \
         else                                                                    \
                 branch = ____wrong_branch_error();                              \
-        branch;                                                                 \
+        likely(branch);                                                         \
 })
 
 #define static_branch_unlikely(x)                                               \
@@ -405,7 +405,7 @@ extern bool ____wrong_branch_error(void);
                 branch = arch_static_branch(&(x)->key, false);                  \
         else                                                                    \
                 branch = ____wrong_branch_error();                              \
-        branch;                                                                 \
+        unlikely(branch);                                                       \
 })
 
 #else /* !HAVE_JUMP_LABEL */
diff --git a/include/linux/kallsyms.h b/include/linux/kallsyms.h
index bd118a6c60cb..657a83b943f0 100644
--- a/include/linux/kallsyms.h
+++ b/include/linux/kallsyms.h
@@ -9,6 +9,10 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/stddef.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+
+#include <asm/sections.h>
 
 #define KSYM_NAME_LEN 128
 #define KSYM_SYMBOL_LEN (sizeof("%s+%#lx/%#lx [%s]") + (KSYM_NAME_LEN - 1) + \
@@ -16,6 +20,56 @@
 
 struct module;
 
+static inline int is_kernel_inittext(unsigned long addr)
+{
+        if (addr >= (unsigned long)_sinittext
+            && addr <= (unsigned long)_einittext)
+                return 1;
+        return 0;
+}
+
+static inline int is_kernel_text(unsigned long addr)
+{
+        if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) ||
+            arch_is_kernel_text(addr))
+                return 1;
+        return in_gate_area_no_mm(addr);
+}
+
+static inline int is_kernel(unsigned long addr)
+{
+        if (addr >= (unsigned long)_stext && addr <= (unsigned long)_end)
+                return 1;
+        return in_gate_area_no_mm(addr);
+}
+
+static inline int is_ksym_addr(unsigned long addr)
+{
+        if (IS_ENABLED(CONFIG_KALLSYMS_ALL))
+                return is_kernel(addr);
+
+        return is_kernel_text(addr) || is_kernel_inittext(addr);
+}
+
+static inline void *dereference_symbol_descriptor(void *ptr)
+{
+#ifdef HAVE_DEREFERENCE_FUNCTION_DESCRIPTOR
+        struct module *mod;
+
+        ptr = dereference_kernel_function_descriptor(ptr);
+        if (is_ksym_addr((unsigned long)ptr))
+                return ptr;
+
+        preempt_disable();
+        mod = __module_address((unsigned long)ptr);
+        preempt_enable();
+
+        if (mod)
+                ptr = dereference_module_function_descriptor(mod, ptr);
+#endif
+        return ptr;
+}
+
 #ifdef CONFIG_KALLSYMS
 /* Lookup the address for a symbol. Returns 0 if not found. */
 unsigned long kallsyms_lookup_name(const char *name);
@@ -40,9 +94,6 @@ extern int sprint_symbol(char *buffer, unsigned long address);
 extern int sprint_symbol_no_offset(char *buffer, unsigned long address);
 extern int sprint_backtrace(char *buffer, unsigned long address);
 
-/* Look up a kernel symbol and print it to the kernel messages. */
-extern void __print_symbol(const char *fmt, unsigned long address);
-
 int lookup_symbol_name(unsigned long addr, char *symname);
 int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
 
@@ -112,26 +163,11 @@ static inline int kallsyms_show_value(void)
         return false;
 }
 
-/* Stupid that this does nothing, but I didn't create this mess. */
-#define __print_symbol(fmt, addr)
 #endif /*CONFIG_KALLSYMS*/
 
-/* This macro allows us to keep printk typechecking */
-static __printf(1, 2)
-void __check_printsym_format(const char *fmt, ...)
-{
-}
-
-static inline void print_symbol(const char *fmt, unsigned long addr)
-{
-        __check_printsym_format(fmt, "");
-        __print_symbol(fmt, (unsigned long)
-                       __builtin_extract_return_addr((void *)addr));
-}
-
 static inline void print_ip_sym(unsigned long ip)
 {
-        printk("[<%p>] %pS\n", (void *) ip, (void *) ip);
+        printk("[<%px>] %pS\n", (void *) ip, (void *) ip);
 }
 
 #endif /*_LINUX_KALLSYMS_H*/
diff --git a/include/linux/kasan.h b/include/linux/kasan.h
index e3eb834c9a35..adc13474a53b 100644
--- a/include/linux/kasan.h
+++ b/include/linux/kasan.h
@@ -11,8 +11,6 @@ struct task_struct;
 
 #ifdef CONFIG_KASAN
 
-#define KASAN_SHADOW_SCALE_SHIFT 3
-
 #include <asm/kasan.h>
 #include <asm/pgtable.h>
 
@@ -56,14 +54,14 @@ void kasan_poison_object_data(struct kmem_cache *cache, void *object);
 void kasan_init_slab_obj(struct kmem_cache *cache, const void *object);
 
 void kasan_kmalloc_large(const void *ptr, size_t size, gfp_t flags);
-void kasan_kfree_large(const void *ptr);
-void kasan_poison_kfree(void *ptr);
+void kasan_kfree_large(void *ptr, unsigned long ip);
+void kasan_poison_kfree(void *ptr, unsigned long ip);
 void kasan_kmalloc(struct kmem_cache *s, const void *object, size_t size,
                   gfp_t flags);
 void kasan_krealloc(const void *object, size_t new_size, gfp_t flags);
 
 void kasan_slab_alloc(struct kmem_cache *s, void *object, gfp_t flags);
-bool kasan_slab_free(struct kmem_cache *s, void *object);
+bool kasan_slab_free(struct kmem_cache *s, void *object, unsigned long ip);
 
 struct kasan_cache {
         int alloc_meta_offset;
@@ -108,8 +106,8 @@ static inline void kasan_init_slab_obj(struct kmem_cache *cache,
                                 const void *object) {}
 
 static inline void kasan_kmalloc_large(void *ptr, size_t size, gfp_t flags) {}
-static inline void kasan_kfree_large(const void *ptr) {}
-static inline void kasan_poison_kfree(void *ptr) {}
+static inline void kasan_kfree_large(void *ptr, unsigned long ip) {}
+static inline void kasan_poison_kfree(void *ptr, unsigned long ip) {}
 static inline void kasan_kmalloc(struct kmem_cache *s, const void *object,
                                 size_t size, gfp_t flags) {}
 static inline void kasan_krealloc(const void *object, size_t new_size,
@@ -117,7 +115,8 @@ static inline void kasan_krealloc(const void *object, size_t new_size,
 
 static inline void kasan_slab_alloc(struct kmem_cache *s, void *object,
                                    gfp_t flags) {}
-static inline bool kasan_slab_free(struct kmem_cache *s, void *object)
+static inline bool kasan_slab_free(struct kmem_cache *s, void *object,
+                                   unsigned long ip)
 {
         return false;
 }
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index 7b45959ebd92..e251533a5939 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -113,7 +113,8 @@ struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void);
  * array is a part of the structure and the fifo type where the array is
  * outside of the fifo structure.
  */
-#define __is_kfifo_ptr(fifo)    (sizeof(*fifo) == sizeof(struct __kfifo))
+#define __is_kfifo_ptr(fifo) \
+        (sizeof(*fifo) == sizeof(STRUCT_KFIFO_PTR(typeof(*(fifo)->type))))
 
 /**
  * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index e0a6205caa71..7f6f93c3df9c 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * kobject.h - generic kernel object infrastructure.
  *
@@ -6,8 +7,6 @@
  * Copyright (c) 2006-2008 Greg Kroah-Hartman <greg@kroah.com>
  * Copyright (c) 2006-2008 Novell Inc.
  *
- * This file is released under the GPLv2.
- *
  * Please read Documentation/kobject.txt before using the kobject
  * interface, ESPECIALLY the parts about reference counts and object
  * destructors.
diff --git a/include/linux/kobject_ns.h b/include/linux/kobject_ns.h
index df32d2508290..069aa2ebef90 100644
--- a/include/linux/kobject_ns.h
+++ b/include/linux/kobject_ns.h
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
 /* Kernel object name space definitions
  *
  * Copyright (c) 2002-2003 Patrick Mochel
@@ -7,8 +8,6 @@
  *
  * Split from kobject.h by David Howells (dhowells@redhat.com)
  *
- * This file is released under the GPLv2.
- *
  * Please read Documentation/kobject.txt before using the kobject
  * interface, ESPECIALLY the parts about reference counts and object
  * destructors.
diff --git a/include/linux/led-class-flash.h b/include/linux/led-class-flash.h
index e97966d1fb8d..700efaa9e115 100644
--- a/include/linux/led-class-flash.h
+++ b/include/linux/led-class-flash.h
@@ -121,6 +121,8 @@ extern void led_classdev_flash_unregister(struct led_classdev_flash *fled_cdev);
 static inline int led_set_flash_strobe(struct led_classdev_flash *fled_cdev,
                                         bool state)
 {
+        if (!fled_cdev)
+                return -EINVAL;
         return fled_cdev->ops->strobe_set(fled_cdev, state);
 }
 
@@ -136,6 +138,8 @@ static inline int led_set_flash_strobe(struct led_classdev_flash *fled_cdev,
 static inline int led_get_flash_strobe(struct led_classdev_flash *fled_cdev,
                                         bool *state)
 {
+        if (!fled_cdev)
+                return -EINVAL;
         if (fled_cdev->ops->strobe_get)
                 return fled_cdev->ops->strobe_get(fled_cdev, state);
 
diff --git a/include/linux/libfdt.h b/include/linux/libfdt.h
index 27ba06e5d117..90ed4ebfa692 100644
--- a/include/linux/libfdt.h
+++ b/include/linux/libfdt.h
@@ -3,7 +3,6 @@
 #define _INCLUDE_LIBFDT_H_
 
 #include <linux/libfdt_env.h>
-#include "../../scripts/dtc/libfdt/fdt.h"
 #include "../../scripts/dtc/libfdt/libfdt.h"
 
 #endif /* _INCLUDE_LIBFDT_H_ */
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
index f8109ddb5ef1..ff855ed965fb 100644
--- a/include/linux/libnvdimm.h
+++ b/include/linux/libnvdimm.h
@@ -47,6 +47,17 @@ enum {
 
         /* region flag indicating to direct-map persistent memory by default */
         ND_REGION_PAGEMAP = 0,
+        /*
+         * Platform ensures entire CPU store data path is flushed to pmem on
+         * system power loss.
+         */
+        ND_REGION_PERSIST_CACHE = 1,
+        /*
+         * Platform provides mechanisms to automatically flush outstanding
+         * write data from memory controler to pmem on system power loss.
+         * (ADR)
+         */
+        ND_REGION_PERSIST_MEMCTRL = 2,
 
         /* mark newly adjusted resources as requiring a label update */
         DPA_RESOURCE_ADJUSTED = 1 << 0,
diff --git a/include/linux/lightnvm.h b/include/linux/lightnvm.h
index 2d1d9de06728..7f4b60abdf27 100644
--- a/include/linux/lightnvm.h
+++ b/include/linux/lightnvm.h
@@ -50,10 +50,7 @@ struct nvm_id;
 struct nvm_dev;
 struct nvm_tgt_dev;
 
-typedef int (nvm_l2p_update_fn)(u64, u32, __le64 *, void *);
 typedef int (nvm_id_fn)(struct nvm_dev *, struct nvm_id *);
-typedef int (nvm_get_l2p_tbl_fn)(struct nvm_dev *, u64, u32,
-                                nvm_l2p_update_fn *, void *);
 typedef int (nvm_op_bb_tbl_fn)(struct nvm_dev *, struct ppa_addr, u8 *);
 typedef int (nvm_op_set_bb_fn)(struct nvm_dev *, struct ppa_addr *, int, int);
 typedef int (nvm_submit_io_fn)(struct nvm_dev *, struct nvm_rq *);
@@ -66,7 +63,6 @@ typedef void (nvm_dev_dma_free_fn)(void *, void*, dma_addr_t);
 
 struct nvm_dev_ops {
         nvm_id_fn               *identity;
-        nvm_get_l2p_tbl_fn      *get_l2p_tbl;
         nvm_op_bb_tbl_fn        *get_bb_tbl;
         nvm_op_set_bb_fn        *set_bb_tbl;
 
@@ -112,8 +108,6 @@ enum {
         NVM_RSP_WARN_HIGHECC    = 0x4700,
 
         /* Device opcodes */
-        NVM_OP_HBREAD           = 0x02,
-        NVM_OP_HBWRITE          = 0x81,
         NVM_OP_PWRITE           = 0x91,
         NVM_OP_PREAD            = 0x92,
         NVM_OP_ERASE            = 0x90,
@@ -165,12 +159,16 @@ struct nvm_id_group {
         u8      fmtype;
         u8      num_ch;
         u8      num_lun;
-        u8      num_pln;
-        u16     num_blk;
-        u16     num_pg;
-        u16     fpg_sz;
+        u16     num_chk;
+        u16     clba;
         u16     csecs;
         u16     sos;
+
+        u16     ws_min;
+        u16     ws_opt;
+        u16     ws_seq;
+        u16     ws_per_chk;
+
         u32     trdt;
         u32     trdm;
         u32     tprt;
@@ -181,7 +179,10 @@ struct nvm_id_group {
         u32     mccap;
         u16     cpar;
 
-        struct nvm_id_lp_tbl lptbl;
+        /* 1.2 compatibility */
+        u8      num_pln;
+        u16     num_pg;
+        u16     fpg_sz;
 };
 
 struct nvm_addr_format {
@@ -217,6 +218,10 @@ struct nvm_target {
 
 #define ADDR_EMPTY (~0ULL)
 
+#define NVM_TARGET_DEFAULT_OP (101)
+#define NVM_TARGET_MIN_OP (3)
+#define NVM_TARGET_MAX_OP (80)
+
 #define NVM_VERSION_MAJOR 1
 #define NVM_VERSION_MINOR 0
 #define NVM_VERSION_PATCH 0
@@ -239,7 +244,6 @@ struct nvm_rq {
         void *meta_list;
         dma_addr_t dma_meta_list;
 
-        struct completion *wait;
         nvm_end_io_fn *end_io;
 
         uint8_t opcode;
@@ -268,31 +272,38 @@ enum {
         NVM_BLK_ST_BAD =        0x8,    /* Bad block */
 };
 
+
 /* Device generic information */
 struct nvm_geo {
+        /* generic geometry */
         int nr_chnls;
-        int nr_luns;
-        int luns_per_chnl; /* -1 if channels are not symmetric */
-        int nr_planes;
-        int sec_per_pg; /* only sectors for a single page */
-        int pgs_per_blk;
-        int blks_per_lun;
-        int fpg_size;
-        int pfpg_size; /* size of buffer if all pages are to be read */
+        int all_luns; /* across channels */
+        int nr_luns; /* per channel */
+        int nr_chks; /* per lun */
+
         int sec_size;
         int oob_size;
         int mccap;
-        struct nvm_addr_format ppaf;
 
-        /* Calculated/Cached values. These do not reflect the actual usable
-         * blocks at run-time.
-         */
+        int sec_per_chk;
+        int sec_per_lun;
+
+        int ws_min;
+        int ws_opt;
+        int ws_seq;
+        int ws_per_chk;
+
         int max_rq_size;
-        int plane_mode; /* drive device in single, double or quad mode */
 
+        int op;
+
+        struct nvm_addr_format ppaf;
+
+        /* Legacy 1.2 specific geometry */
+        int plane_mode; /* drive device in single, double or quad mode */
+        int nr_planes;
+        int sec_per_pg; /* only sectors for a single page */
         int sec_per_pl; /* all sectors across planes */
-        int sec_per_blk;
-        int sec_per_lun;
 };
 
 /* sub-device structure */
@@ -320,10 +331,6 @@ struct nvm_dev {
         /* Device information */
         struct nvm_geo geo;
 
-          /* lower page table */
-        int lps_per_blk;
-        int *lptbl;
-
         unsigned long total_secs;
 
         unsigned long *lun_map;
@@ -346,36 +353,6 @@ struct nvm_dev {
         struct list_head targets;
 };
 
-static inline struct ppa_addr linear_to_generic_addr(struct nvm_geo *geo,
-                                                     u64 pba)
-{
-        struct ppa_addr l;
-        int secs, pgs, blks, luns;
-        sector_t ppa = pba;
-
-        l.ppa = 0;
-
-        div_u64_rem(ppa, geo->sec_per_pg, &secs);
-        l.g.sec = secs;
-
-        sector_div(ppa, geo->sec_per_pg);
-        div_u64_rem(ppa, geo->pgs_per_blk, &pgs);
-        l.g.pg = pgs;
-
-        sector_div(ppa, geo->pgs_per_blk);
-        div_u64_rem(ppa, geo->blks_per_lun, &blks);
-        l.g.blk = blks;
-
-        sector_div(ppa, geo->blks_per_lun);
-        div_u64_rem(ppa, geo->luns_per_chnl, &luns);
-        l.g.lun = luns;
-
-        sector_div(ppa, geo->luns_per_chnl);
-        l.g.ch = ppa;
-
-        return l;
-}
-
 static inline struct ppa_addr generic_to_dev_addr(struct nvm_tgt_dev *tgt_dev,
                                                   struct ppa_addr r)
 {
@@ -418,25 +395,6 @@ static inline struct ppa_addr dev_to_generic_addr(struct nvm_tgt_dev *tgt_dev,
         return l;
 }
 
-static inline int ppa_empty(struct ppa_addr ppa_addr)
-{
-        return (ppa_addr.ppa == ADDR_EMPTY);
-}
-
-static inline void ppa_set_empty(struct ppa_addr *ppa_addr)
-{
-        ppa_addr->ppa = ADDR_EMPTY;
-}
-
-static inline int ppa_cmp_blk(struct ppa_addr ppa1, struct ppa_addr ppa2)
-{
-        if (ppa_empty(ppa1) || ppa_empty(ppa2))
-                return 0;
-
-        return ((ppa1.g.ch == ppa2.g.ch) && (ppa1.g.lun == ppa2.g.lun) &&
-                                        (ppa1.g.blk == ppa2.g.blk));
-}
-
 typedef blk_qc_t (nvm_tgt_make_rq_fn)(struct request_queue *, struct bio *);
 typedef sector_t (nvm_tgt_capacity_fn)(void *);
 typedef void *(nvm_tgt_init_fn)(struct nvm_tgt_dev *, struct gendisk *,
@@ -481,17 +439,10 @@ extern int nvm_set_tgt_bb_tbl(struct nvm_tgt_dev *, struct ppa_addr *,
 extern int nvm_max_phys_sects(struct nvm_tgt_dev *);
 extern int nvm_submit_io(struct nvm_tgt_dev *, struct nvm_rq *);
 extern int nvm_submit_io_sync(struct nvm_tgt_dev *, struct nvm_rq *);
-extern int nvm_erase_sync(struct nvm_tgt_dev *, struct ppa_addr *, int);
-extern int nvm_get_l2p_tbl(struct nvm_tgt_dev *, u64, u32, nvm_l2p_update_fn *,
-                           void *);
-extern int nvm_get_area(struct nvm_tgt_dev *, sector_t *, sector_t);
-extern void nvm_put_area(struct nvm_tgt_dev *, sector_t);
 extern void nvm_end_io(struct nvm_rq *);
 extern int nvm_bb_tbl_fold(struct nvm_dev *, u8 *, int);
 extern int nvm_get_tgt_bb_tbl(struct nvm_tgt_dev *, struct ppa_addr, u8 *);
 
-extern void nvm_part_to_tgt(struct nvm_dev *, sector_t *, int);
-
 #else /* CONFIG_NVM */
 struct nvm_dev_ops;
 
diff --git a/include/linux/livepatch.h b/include/linux/livepatch.h
index fc5c1be3f6f4..4754f01c1abb 100644
--- a/include/linux/livepatch.h
+++ b/include/linux/livepatch.h
@@ -40,7 +40,6 @@
  * @new_func:   pointer to the patched function code
  * @old_sympos: a hint indicating which symbol position the old function
  *              can be found (optional)
- * @immediate:  patch the func immediately, bypassing safety mechanisms
  * @old_addr:   the address of the function being patched
  * @kobj:       kobject for sysfs resources
  * @stack_node: list node for klp_ops func_stack list
@@ -76,7 +75,6 @@ struct klp_func {
          * in kallsyms for the given object is used.
          */
         unsigned long old_sympos;
-        bool immediate;
 
         /* internal */
         unsigned long old_addr;
@@ -137,7 +135,6 @@ struct klp_object {
  * struct klp_patch - patch structure for live patching
  * @mod:        reference to the live patch module
  * @objs:       object entries for kernel objects to be patched
- * @immediate:  patch all funcs immediately, bypassing safety mechanisms
  * @list:       list node for global list of registered patches
  * @kobj:       kobject for sysfs resources
  * @enabled:    the patch is enabled (but operation may be incomplete)
@@ -147,7 +144,6 @@ struct klp_patch {
         /* external */
         struct module *mod;
         struct klp_object *objs;
-        bool immediate;
 
         /* internal */
         struct list_head list;
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index d7d313fb9cd4..4fd95dbeb52f 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -17,6 +17,7 @@
 #include <net/ipv6.h>
 #include <linux/fs.h>
 #include <linux/kref.h>
+#include <linux/refcount.h>
 #include <linux/utsname.h>
 #include <linux/lockd/bind.h>
 #include <linux/lockd/xdr.h>
@@ -58,7 +59,7 @@ struct nlm_host {
         u32                     h_state;        /* pseudo-state counter */
         u32                     h_nsmstate;     /* true remote NSM state */
         u32                     h_pidcount;     /* Pseudopids */
-        atomic_t                h_count;        /* reference count */
+        refcount_t              h_count;        /* reference count */
         struct mutex            h_mutex;        /* mutex for pmap binding */
         unsigned long           h_nextrebind;   /* next portmap call */
         unsigned long           h_expires;      /* eligible for GC */
@@ -83,7 +84,7 @@ struct nlm_host {
 
 struct nsm_handle {
         struct list_head        sm_link;
-        atomic_t                sm_count;
+        refcount_t              sm_count;
         char                    *sm_mon_name;
         char                    *sm_name;
         struct sockaddr_storage sm_addr;
@@ -122,7 +123,7 @@ static inline struct sockaddr *nlm_srcaddr(const struct nlm_host *host)
  */
 struct nlm_lockowner {
         struct list_head list;
-        atomic_t count;
+        refcount_t count;
 
         struct nlm_host *host;
         fl_owner_t owner;
@@ -136,7 +137,7 @@ struct nlm_wait;
  */
 #define NLMCLNT_OHSIZE          ((__NEW_UTS_LEN) + 10u)
 struct nlm_rqst {
-        atomic_t                a_count;
+        refcount_t              a_count;
         unsigned int            a_flags;        /* initial RPC task flags */
         struct nlm_host *       a_host;         /* host handle */
         struct nlm_args         a_args;         /* arguments */
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 795634ee5aa5..6fc77d4dbdcd 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -337,9 +337,9 @@ extern void lock_release(struct lockdep_map *lock, int nested,
 /*
  * Same "read" as for lock_acquire(), except -1 means any.
  */
-extern int lock_is_held_type(struct lockdep_map *lock, int read);
+extern int lock_is_held_type(const struct lockdep_map *lock, int read);
 
-static inline int lock_is_held(struct lockdep_map *lock)
+static inline int lock_is_held(const struct lockdep_map *lock)
 {
         return lock_is_held_type(lock, -1);
 }
diff --git a/include/linux/lockref.h b/include/linux/lockref.h
index ef3c9342e119..2eac32095113 100644
--- a/include/linux/lockref.h
+++ b/include/linux/lockref.h
@@ -44,7 +44,7 @@ extern void lockref_mark_dead(struct lockref *);
 extern int lockref_get_not_dead(struct lockref *);
 
 /* Must be called under spinlock for reliable results */
-static inline int __lockref_is_dead(const struct lockref *l)
+static inline bool __lockref_is_dead(const struct lockref *l)
 {
         return ((int)l->count < 0);
 }
diff --git a/include/linux/mdio.h b/include/linux/mdio.h
index ca08ab16ecdc..2cfffe586885 100644
--- a/include/linux/mdio.h
+++ b/include/linux/mdio.h
@@ -12,6 +12,7 @@
 #include <uapi/linux/mdio.h>
 #include <linux/mod_devicetable.h>
 
+struct gpio_desc;
 struct mii_bus;
 
 /* Multiple levels of nesting are possible. However typically this is
@@ -39,6 +40,9 @@ struct mdio_device {
         /* Bus address of the MDIO device (0-31) */
         int addr;
         int flags;
+        struct gpio_desc *reset;
+        unsigned int reset_assert_delay;
+        unsigned int reset_deassert_delay;
 };
 #define to_mdio_device(d) container_of(d, struct mdio_device, dev)
 
@@ -71,6 +75,7 @@ void mdio_device_free(struct mdio_device *mdiodev);
 struct mdio_device *mdio_device_create(struct mii_bus *bus, int addr);
 int mdio_device_register(struct mdio_device *mdiodev);
 void mdio_device_remove(struct mdio_device *mdiodev);
+void mdio_device_reset(struct mdio_device *mdiodev, int value);
 int mdio_driver_register(struct mdio_driver *drv);
 void mdio_driver_unregister(struct mdio_driver *drv);
 int mdio_device_bus_match(struct device *dev, struct device_driver *drv);
@@ -257,6 +262,9 @@ static inline u16 ethtool_adv_to_mmd_eee_adv_t(u32 adv)
         return reg;
 }
 
+int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
+int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
+
 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
 int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum);
 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 7ed0f7782d16..8be5077efb5f 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -332,8 +332,8 @@ void memblock_enforce_memory_limit(phys_addr_t memory_limit);
 void memblock_cap_memory_range(phys_addr_t base, phys_addr_t size);
 void memblock_mem_limit_remove_map(phys_addr_t limit);
 bool memblock_is_memory(phys_addr_t addr);
-int memblock_is_map_memory(phys_addr_t addr);
-int memblock_is_region_memory(phys_addr_t base, phys_addr_t size);
+bool memblock_is_map_memory(phys_addr_t addr);
+bool memblock_is_region_memory(phys_addr_t base, phys_addr_t size);
 bool memblock_is_reserved(phys_addr_t addr);
 bool memblock_is_region_reserved(phys_addr_t base, phys_addr_t size);
 
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 69966c461d1c..882046863581 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -108,7 +108,10 @@ struct lruvec_stat {
  */
 struct mem_cgroup_per_node {
         struct lruvec           lruvec;
-        struct lruvec_stat __percpu *lruvec_stat;
+
+        struct lruvec_stat __percpu *lruvec_stat_cpu;
+        atomic_long_t           lruvec_stat[NR_VM_NODE_STAT_ITEMS];
+
         unsigned long           lru_zone_size[MAX_NR_ZONES][NR_LRU_LISTS];
 
         struct mem_cgroup_reclaim_iter  iter[DEF_PRIORITY + 1];
@@ -227,10 +230,10 @@ struct mem_cgroup {
         spinlock_t              move_lock;
         struct task_struct      *move_lock_task;
         unsigned long           move_lock_flags;
-        /*
-         * percpu counter.
-         */
-        struct mem_cgroup_stat_cpu __percpu *stat;
+
+        struct mem_cgroup_stat_cpu __percpu *stat_cpu;
+        atomic_long_t           stat[MEMCG_NR_STAT];
+        atomic_long_t           events[MEMCG_NR_EVENTS];
 
         unsigned long           socket_pressure;
 
@@ -265,6 +268,12 @@ struct mem_cgroup {
         /* WARNING: nodeinfo must be the last member here */
 };
 
+/*
+ * size of first charge trial. "32" comes from vmscan.c's magic value.
+ * TODO: maybe necessary to use big numbers in big irons.
+ */
+#define MEMCG_CHARGE_BATCH 32U
+
 extern struct mem_cgroup *root_mem_cgroup;
 
 static inline bool mem_cgroup_disabled(void)
@@ -272,13 +281,6 @@ static inline bool mem_cgroup_disabled(void)
         return !cgroup_subsys_enabled(memory_cgrp_subsys);
 }
 
-static inline void mem_cgroup_event(struct mem_cgroup *memcg,
-                                    enum memcg_event_item event)
-{
-        this_cpu_inc(memcg->stat->events[event]);
-        cgroup_file_notify(&memcg->events_file);
-}
-
 bool mem_cgroup_low(struct mem_cgroup *root, struct mem_cgroup *memcg);
 
 int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
@@ -492,32 +494,38 @@ void unlock_page_memcg(struct page *page);
 static inline unsigned long memcg_page_state(struct mem_cgroup *memcg,
                                              int idx)
 {
-        long val = 0;
-        int cpu;
-
-        for_each_possible_cpu(cpu)
-                val += per_cpu(memcg->stat->count[idx], cpu);
-
-        if (val < 0)
-                val = 0;
-
-        return val;
+        long x = atomic_long_read(&memcg->stat[idx]);
+#ifdef CONFIG_SMP
+        if (x < 0)
+                x = 0;
+#endif
+        return x;
 }
 
 /* idx can be of type enum memcg_stat_item or node_stat_item */
 static inline void __mod_memcg_state(struct mem_cgroup *memcg,
                                      int idx, int val)
 {
-        if (!mem_cgroup_disabled())
-                __this_cpu_add(memcg->stat->count[idx], val);
+        long x;
+
+        if (mem_cgroup_disabled())
+                return;
+
+        x = val + __this_cpu_read(memcg->stat_cpu->count[idx]);
+        if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
+                atomic_long_add(x, &memcg->stat[idx]);
+                x = 0;
+        }
+        __this_cpu_write(memcg->stat_cpu->count[idx], x);
 }
 
 /* idx can be of type enum memcg_stat_item or node_stat_item */
 static inline void mod_memcg_state(struct mem_cgroup *memcg,
                                    int idx, int val)
 {
-        if (!mem_cgroup_disabled())
-                this_cpu_add(memcg->stat->count[idx], val);
+        preempt_disable();
+        __mod_memcg_state(memcg, idx, val);
+        preempt_enable();
 }
 
 /**
@@ -555,87 +563,108 @@ static inline unsigned long lruvec_page_state(struct lruvec *lruvec,
                                               enum node_stat_item idx)
 {
         struct mem_cgroup_per_node *pn;
-        long val = 0;
-        int cpu;
+        long x;
 
         if (mem_cgroup_disabled())
                 return node_page_state(lruvec_pgdat(lruvec), idx);
 
         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
-        for_each_possible_cpu(cpu)
-                val += per_cpu(pn->lruvec_stat->count[idx], cpu);
-
-        if (val < 0)
-                val = 0;
-
-        return val;
+        x = atomic_long_read(&pn->lruvec_stat[idx]);
+#ifdef CONFIG_SMP
+        if (x < 0)
+                x = 0;
+#endif
+        return x;
 }
 
 static inline void __mod_lruvec_state(struct lruvec *lruvec,
                                       enum node_stat_item idx, int val)
 {
         struct mem_cgroup_per_node *pn;
+        long x;
 
+        /* Update node */
         __mod_node_page_state(lruvec_pgdat(lruvec), idx, val);
+
         if (mem_cgroup_disabled())
                 return;
+
         pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
+
+        /* Update memcg */
         __mod_memcg_state(pn->memcg, idx, val);
-        __this_cpu_add(pn->lruvec_stat->count[idx], val);
+
+        /* Update lruvec */
+        x = val + __this_cpu_read(pn->lruvec_stat_cpu->count[idx]);
+        if (unlikely(abs(x) > MEMCG_CHARGE_BATCH)) {
+                atomic_long_add(x, &pn->lruvec_stat[idx]);
+                x = 0;
+        }
+        __this_cpu_write(pn->lruvec_stat_cpu->count[idx], x);
 }
 
 static inline void mod_lruvec_state(struct lruvec *lruvec,
                                     enum node_stat_item idx, int val)
 {
-        struct mem_cgroup_per_node *pn;
-
-        mod_node_page_state(lruvec_pgdat(lruvec), idx, val);
-        if (mem_cgroup_disabled())
-                return;
-        pn = container_of(lruvec, struct mem_cgroup_per_node, lruvec);
-        mod_memcg_state(pn->memcg, idx, val);
-        this_cpu_add(pn->lruvec_stat->count[idx], val);
+        preempt_disable();
+        __mod_lruvec_state(lruvec, idx, val);
+        preempt_enable();
 }
 
 static inline void __mod_lruvec_page_state(struct page *page,
                                            enum node_stat_item idx, int val)
 {
-        struct mem_cgroup_per_node *pn;
+        pg_data_t *pgdat = page_pgdat(page);
+        struct lruvec *lruvec;
 
-        __mod_node_page_state(page_pgdat(page), idx, val);
-        if (mem_cgroup_disabled() || !page->mem_cgroup)
+        /* Untracked pages have no memcg, no lruvec. Update only the node */
+        if (!page->mem_cgroup) {
+                __mod_node_page_state(pgdat, idx, val);
                 return;
-        __mod_memcg_state(page->mem_cgroup, idx, val);
-        pn = page->mem_cgroup->nodeinfo[page_to_nid(page)];
-        __this_cpu_add(pn->lruvec_stat->count[idx], val);
+        }
+
+        lruvec = mem_cgroup_lruvec(pgdat, page->mem_cgroup);
+        __mod_lruvec_state(lruvec, idx, val);
 }
 
 static inline void mod_lruvec_page_state(struct page *page,
                                          enum node_stat_item idx, int val)
 {
-        struct mem_cgroup_per_node *pn;
-
-        mod_node_page_state(page_pgdat(page), idx, val);
-        if (mem_cgroup_disabled() || !page->mem_cgroup)
-                return;
-        mod_memcg_state(page->mem_cgroup, idx, val);
-        pn = page->mem_cgroup->nodeinfo[page_to_nid(page)];
-        this_cpu_add(pn->lruvec_stat->count[idx], val);
+        preempt_disable();
+        __mod_lruvec_page_state(page, idx, val);
+        preempt_enable();
 }
 
 unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
                                                 gfp_t gfp_mask,
                                                 unsigned long *total_scanned);
 
+/* idx can be of type enum memcg_event_item or vm_event_item */
+static inline void __count_memcg_events(struct mem_cgroup *memcg,
+                                        int idx, unsigned long count)
+{
+        unsigned long x;
+
+        if (mem_cgroup_disabled())
+                return;
+
+        x = count + __this_cpu_read(memcg->stat_cpu->events[idx]);
+        if (unlikely(x > MEMCG_CHARGE_BATCH)) {
+                atomic_long_add(x, &memcg->events[idx]);
+                x = 0;
+        }
+        __this_cpu_write(memcg->stat_cpu->events[idx], x);
+}
+
 static inline void count_memcg_events(struct mem_cgroup *memcg,
-                                      enum vm_event_item idx,
-                                      unsigned long count)
+                                      int idx, unsigned long count)
 {
-        if (!mem_cgroup_disabled())
-                this_cpu_add(memcg->stat->events[idx], count);
+        preempt_disable();
+        __count_memcg_events(memcg, idx, count);
+        preempt_enable();
 }
 
-/* idx can be of type enum memcg_stat_item or node_stat_item */
+/* idx can be of type enum memcg_event_item or vm_event_item */
 static inline void count_memcg_page_event(struct page *page,
                                           int idx)
 {
@@ -654,12 +683,20 @@ static inline void count_memcg_event_mm(struct mm_struct *mm,
         rcu_read_lock();
         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
         if (likely(memcg)) {
-                this_cpu_inc(memcg->stat->events[idx]);
+                count_memcg_events(memcg, idx, 1);
                 if (idx == OOM_KILL)
                         cgroup_file_notify(&memcg->events_file);
         }
         rcu_read_unlock();
 }
+
+static inline void mem_cgroup_event(struct mem_cgroup *memcg,
+                                    enum memcg_event_item event)
+{
+        count_memcg_events(memcg, event, 1);
+        cgroup_file_notify(&memcg->events_file);
+}
+
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 void mem_cgroup_split_huge_fixup(struct page *head);
 #endif
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 58e110aee7ab..aba5f86eb038 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -13,6 +13,7 @@ struct pglist_data;
 struct mem_section;
 struct memory_block;
 struct resource;
+struct vmem_altmap;
 
 #ifdef CONFIG_MEMORY_HOTPLUG
 /*
@@ -125,24 +126,26 @@ static inline bool movable_node_is_enabled(void)
 
 #ifdef CONFIG_MEMORY_HOTREMOVE
 extern bool is_pageblock_removable_nolock(struct page *page);
-extern int arch_remove_memory(u64 start, u64 size);
+extern int arch_remove_memory(u64 start, u64 size,
+                struct vmem_altmap *altmap);
 extern int __remove_pages(struct zone *zone, unsigned long start_pfn,
-        unsigned long nr_pages);
+        unsigned long nr_pages, struct vmem_altmap *altmap);
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 
 /* reasonably generic interface to expand the physical pages */
-extern int __add_pages(int nid, unsigned long start_pfn,
-        unsigned long nr_pages, bool want_memblock);
+extern int __add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
+                struct vmem_altmap *altmap, bool want_memblock);
 
 #ifndef CONFIG_ARCH_HAS_ADD_PAGES
 static inline int add_pages(int nid, unsigned long start_pfn,
-                            unsigned long nr_pages, bool want_memblock)
+                unsigned long nr_pages, struct vmem_altmap *altmap,
+                bool want_memblock)
 {
-        return __add_pages(nid, start_pfn, nr_pages, want_memblock);
+        return __add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
 }
 #else /* ARCH_HAS_ADD_PAGES */
-int add_pages(int nid, unsigned long start_pfn,
-              unsigned long nr_pages, bool want_memblock);
+int add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
+                struct vmem_altmap *altmap, bool want_memblock);
 #endif /* ARCH_HAS_ADD_PAGES */
 
 #ifdef CONFIG_NUMA
@@ -318,15 +321,17 @@ extern int walk_memory_range(unsigned long start_pfn, unsigned long end_pfn,
                 void *arg, int (*func)(struct memory_block *, void *));
 extern int add_memory(int nid, u64 start, u64 size);
 extern int add_memory_resource(int nid, struct resource *resource, bool online);
-extern int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock);
+extern int arch_add_memory(int nid, u64 start, u64 size,
+                struct vmem_altmap *altmap, bool want_memblock);
 extern void move_pfn_range_to_zone(struct zone *zone, unsigned long start_pfn,
-                unsigned long nr_pages);
+                unsigned long nr_pages, struct vmem_altmap *altmap);
 extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
 extern bool is_memblock_offlined(struct memory_block *mem);
 extern void remove_memory(int nid, u64 start, u64 size);
-extern int sparse_add_one_section(struct pglist_data *pgdat, unsigned long start_pfn);
+extern int sparse_add_one_section(struct pglist_data *pgdat,
+                unsigned long start_pfn, struct vmem_altmap *altmap);
 extern void sparse_remove_one_section(struct zone *zone, struct mem_section *ms,
-                unsigned long map_offset);
+                unsigned long map_offset, struct vmem_altmap *altmap);
 extern struct page *sparse_decode_mem_map(unsigned long coded_mem_map,
                                           unsigned long pnum);
 extern bool allow_online_pfn_range(int nid, unsigned long pfn, unsigned long nr_pages,
diff --git a/include/linux/memremap.h b/include/linux/memremap.h
index 10d23c367048..7b4899c06f49 100644
--- a/include/linux/memremap.h
+++ b/include/linux/memremap.h
@@ -26,18 +26,6 @@ struct vmem_altmap {
         unsigned long alloc;
 };
 
-unsigned long vmem_altmap_offset(struct vmem_altmap *altmap);
-void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns);
-
-#ifdef CONFIG_ZONE_DEVICE
-struct vmem_altmap *to_vmem_altmap(unsigned long memmap_start);
-#else
-static inline struct vmem_altmap *to_vmem_altmap(unsigned long memmap_start)
-{
-        return NULL;
-}
-#endif
-
 /*
  * Specialize ZONE_DEVICE memory into multiple types each having differents
  * usage.
@@ -125,8 +113,9 @@ typedef void (*dev_page_free_t)(struct page *page, void *data);
 struct dev_pagemap {
         dev_page_fault_t page_fault;
         dev_page_free_t page_free;
-        struct vmem_altmap *altmap;
-        const struct resource *res;
+        struct vmem_altmap altmap;
+        bool altmap_valid;
+        struct resource res;
         struct percpu_ref *ref;
         struct device *dev;
         void *data;
@@ -134,15 +123,17 @@ struct dev_pagemap {
 };
 
 #ifdef CONFIG_ZONE_DEVICE
-void *devm_memremap_pages(struct device *dev, struct resource *res,
-                struct percpu_ref *ref, struct vmem_altmap *altmap);
-struct dev_pagemap *find_dev_pagemap(resource_size_t phys);
+void *devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap);
+struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
+                struct dev_pagemap *pgmap);
+
+unsigned long vmem_altmap_offset(struct vmem_altmap *altmap);
+void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns);
 
 static inline bool is_zone_device_page(const struct page *page);
 #else
 static inline void *devm_memremap_pages(struct device *dev,
-                struct resource *res, struct percpu_ref *ref,
-                struct vmem_altmap *altmap)
+                struct dev_pagemap *pgmap)
 {
         /*
          * Fail attempts to call devm_memremap_pages() without
@@ -153,11 +144,22 @@ static inline void *devm_memremap_pages(struct device *dev,
         return ERR_PTR(-ENXIO);
 }
 
-static inline struct dev_pagemap *find_dev_pagemap(resource_size_t phys)
+static inline struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
+                struct dev_pagemap *pgmap)
 {
         return NULL;
 }
-#endif
+
+static inline unsigned long vmem_altmap_offset(struct vmem_altmap *altmap)
+{
+        return 0;
+}
+
+static inline void vmem_altmap_free(struct vmem_altmap *altmap,
+                unsigned long nr_pfns)
+{
+}
+#endif /* CONFIG_ZONE_DEVICE */
 
 #if defined(CONFIG_DEVICE_PRIVATE) || defined(CONFIG_DEVICE_PUBLIC)
 static inline bool is_device_private_page(const struct page *page)
@@ -173,39 +175,6 @@ static inline bool is_device_public_page(const struct page *page)
 }
 #endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */
 
-/**
- * get_dev_pagemap() - take a new live reference on the dev_pagemap for @pfn
- * @pfn: page frame number to lookup page_map
- * @pgmap: optional known pgmap that already has a reference
- *
- * @pgmap allows the overhead of a lookup to be bypassed when @pfn lands in the
- * same mapping.
- */
-static inline struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
-                struct dev_pagemap *pgmap)
-{
-        const struct resource *res = pgmap ? pgmap->res : NULL;
-        resource_size_t phys = PFN_PHYS(pfn);
-
-        /*
-         * In the cached case we're already holding a live reference so
-         * we can simply do a blind increment
-         */
-        if (res && phys >= res->start && phys <= res->end) {
-                percpu_ref_get(pgmap->ref);
-                return pgmap;
-        }
-
-        /* fall back to slow path lookup */
-        rcu_read_lock();
-        pgmap = find_dev_pagemap(phys);
-        if (pgmap && !percpu_ref_tryget_live(pgmap->ref))
-                pgmap = NULL;
-        rcu_read_unlock();
-
-        return pgmap;
-}
-
 static inline void put_dev_pagemap(struct dev_pagemap *pgmap)
 {
         if (pgmap)
diff --git a/include/linux/mfd/axp20x.h b/include/linux/mfd/axp20x.h
index 78dc85365c4f..080798f17ece 100644
--- a/include/linux/mfd/axp20x.h
+++ b/include/linux/mfd/axp20x.h
@@ -645,11 +645,6 @@ struct axp20x_dev {
         const struct regmap_irq_chip    *regmap_irq_chip;
 };
 
-struct axp288_extcon_pdata {
-        /* GPIO pin control to switch D+/D- lines b/w PMIC and SOC */
-        struct gpio_desc *gpio_mux_cntl;
-};
-
 /* generic helper function for reading 9-16 bit wide regs */
 static inline int axp20x_read_variable_width(struct regmap *regmap,
         unsigned int reg, unsigned int width)
diff --git a/include/linux/mfd/cros_ec.h b/include/linux/mfd/cros_ec.h
index 4e887ba22635..c61535979b8f 100644
--- a/include/linux/mfd/cros_ec.h
+++ b/include/linux/mfd/cros_ec.h
@@ -322,6 +322,10 @@ extern struct attribute_group cros_ec_attr_group;
 extern struct attribute_group cros_ec_lightbar_attr_group;
 extern struct attribute_group cros_ec_vbc_attr_group;
 
+/* debugfs stuff */
+int cros_ec_debugfs_init(struct cros_ec_dev *ec);
+void cros_ec_debugfs_remove(struct cros_ec_dev *ec);
+
 /* ACPI GPE handler */
 #ifdef CONFIG_ACPI
 
diff --git a/include/linux/mfd/cros_ec_commands.h b/include/linux/mfd/cros_ec_commands.h
index 2b16e95b9bb8..2b96e630e3b6 100644
--- a/include/linux/mfd/cros_ec_commands.h
+++ b/include/linux/mfd/cros_ec_commands.h
@@ -291,6 +291,9 @@ enum host_event_code {
         /* EC desires to change state of host-controlled USB mux */
         EC_HOST_EVENT_USB_MUX = 28,
 
+        /* EC RTC event occurred */
+        EC_HOST_EVENT_RTC = 26,
+
         /*
          * The high bit of the event mask is not used as a host event code.  If
          * it reads back as set, then the entire event mask should be
@@ -799,6 +802,8 @@ enum ec_feature_code {
         EC_FEATURE_USB_MUX = 23,
         /* Motion Sensor code has an internal software FIFO */
         EC_FEATURE_MOTION_SENSE_FIFO = 24,
+        /* EC has RTC feature that can be controlled by host commands */
+        EC_FEATURE_RTC = 27,
 };
 
 #define EC_FEATURE_MASK_0(event_code) (1UL << (event_code % 32))
@@ -1709,6 +1714,9 @@ struct ec_response_rtc {
 #define EC_CMD_RTC_SET_VALUE 0x46
 #define EC_CMD_RTC_SET_ALARM 0x47
 
+/* Pass as param to SET_ALARM to clear the current alarm */
+#define EC_RTC_ALARM_CLEAR 0
+
 /*****************************************************************************/
 /* Port80 log access */
 
@@ -2904,16 +2912,33 @@ enum usb_pd_control_mux {
         USB_PD_CTRL_MUX_AUTO = 5,
 };
 
+enum usb_pd_control_swap {
+        USB_PD_CTRL_SWAP_NONE = 0,
+        USB_PD_CTRL_SWAP_DATA = 1,
+        USB_PD_CTRL_SWAP_POWER = 2,
+        USB_PD_CTRL_SWAP_VCONN = 3,
+        USB_PD_CTRL_SWAP_COUNT
+};
+
 struct ec_params_usb_pd_control {
         uint8_t port;
         uint8_t role;
         uint8_t mux;
+        uint8_t swap;
 } __packed;
 
 #define PD_CTRL_RESP_ENABLED_COMMS      (1 << 0) /* Communication enabled */
 #define PD_CTRL_RESP_ENABLED_CONNECTED  (1 << 1) /* Device connected */
 #define PD_CTRL_RESP_ENABLED_PD_CAPABLE (1 << 2) /* Partner is PD capable */
 
+#define PD_CTRL_RESP_ROLE_POWER         BIT(0) /* 0=SNK/1=SRC */
+#define PD_CTRL_RESP_ROLE_DATA          BIT(1) /* 0=UFP/1=DFP */
+#define PD_CTRL_RESP_ROLE_VCONN         BIT(2) /* Vconn status */
+#define PD_CTRL_RESP_ROLE_DR_POWER      BIT(3) /* Partner is dualrole power */
+#define PD_CTRL_RESP_ROLE_DR_DATA       BIT(4) /* Partner is dualrole data */
+#define PD_CTRL_RESP_ROLE_USB_COMM      BIT(5) /* Partner USB comm capable */
+#define PD_CTRL_RESP_ROLE_EXT_POWERED   BIT(6) /* Partner externally powerd */
+
 struct ec_response_usb_pd_control_v1 {
         uint8_t enabled;
         uint8_t role;
diff --git a/include/linux/mfd/palmas.h b/include/linux/mfd/palmas.h
index 3c8568aa82a5..75e5c8ff85fc 100644
--- a/include/linux/mfd/palmas.h
+++ b/include/linux/mfd/palmas.h
@@ -3733,6 +3733,9 @@ enum usb_irq_events {
 #define TPS65917_REGEN3_CTRL_MODE_ACTIVE                        0x01
 #define TPS65917_REGEN3_CTRL_MODE_ACTIVE_SHIFT                  0x00
 
+/* POWERHOLD Mask field for PRIMARY_SECONDARY_PAD2 register */
+#define TPS65917_PRIMARY_SECONDARY_PAD2_GPIO_5_MASK             0xC
+
 /* Registers for function RESOURCE */
 #define TPS65917_REGEN1_CTRL                                    0x2
 #define TPS65917_PLLEN_CTRL                                     0x3
diff --git a/include/linux/mfd/rave-sp.h b/include/linux/mfd/rave-sp.h
new file mode 100644
index 000000000000..796fb9794c9e
--- /dev/null
+++ b/include/linux/mfd/rave-sp.h
@@ -0,0 +1,60 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+
+/*
+ * Core definitions for RAVE SP MFD driver.
+ *
+ * Copyright (C) 2017 Zodiac Inflight Innovations
+ */
+
+#ifndef _LINUX_RAVE_SP_H_
+#define _LINUX_RAVE_SP_H_
+
+#include <linux/notifier.h>
+
+enum rave_sp_command {
+        RAVE_SP_CMD_GET_FIRMWARE_VERSION        = 0x20,
+        RAVE_SP_CMD_GET_BOOTLOADER_VERSION      = 0x21,
+        RAVE_SP_CMD_BOOT_SOURCE                 = 0x26,
+        RAVE_SP_CMD_GET_BOARD_COPPER_REV        = 0x2B,
+        RAVE_SP_CMD_GET_GPIO_STATE              = 0x2F,
+
+        RAVE_SP_CMD_STATUS                      = 0xA0,
+        RAVE_SP_CMD_SW_WDT                      = 0xA1,
+        RAVE_SP_CMD_PET_WDT                     = 0xA2,
+        RAVE_SP_CMD_RESET                       = 0xA7,
+        RAVE_SP_CMD_RESET_REASON                = 0xA8,
+
+        RAVE_SP_CMD_REQ_COPPER_REV              = 0xB6,
+        RAVE_SP_CMD_GET_I2C_DEVICE_STATUS       = 0xBA,
+        RAVE_SP_CMD_GET_SP_SILICON_REV          = 0xB9,
+        RAVE_SP_CMD_CONTROL_EVENTS              = 0xBB,
+
+        RAVE_SP_EVNT_BASE                       = 0xE0,
+};
+
+struct rave_sp;
+
+static inline unsigned long rave_sp_action_pack(u8 event, u8 value)
+{
+        return ((unsigned long)value << 8) | event;
+}
+
+static inline u8 rave_sp_action_unpack_event(unsigned long action)
+{
+        return action;
+}
+
+static inline u8 rave_sp_action_unpack_value(unsigned long action)
+{
+        return action >> 8;
+}
+
+int rave_sp_exec(struct rave_sp *sp,
+                 void *__data,  size_t data_size,
+                 void *reply_data, size_t reply_data_size);
+
+struct device;
+int devm_rave_sp_register_event_notifier(struct device *dev,
+                                         struct notifier_block *nb);
+
+#endif /* _LINUX_RAVE_SP_H_ */
diff --git a/include/linux/mfd/stm32-lptimer.h b/include/linux/mfd/stm32-lptimer.h
index 77c7cf40d9b4..605f62264825 100644
--- a/include/linux/mfd/stm32-lptimer.h
+++ b/include/linux/mfd/stm32-lptimer.h
@@ -1,13 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * STM32 Low-Power Timer parent driver.
- *
  * Copyright (C) STMicroelectronics 2017
- *
  * Author: Fabrice Gasnier <fabrice.gasnier@st.com>
- *
  * Inspired by Benjamin Gaignard's stm32-timers driver
- *
- * License terms:  GNU General Public License (GPL), version 2
  */
 
 #ifndef _LINUX_STM32_LPTIMER_H_
diff --git a/include/linux/mfd/stm32-timers.h b/include/linux/mfd/stm32-timers.h
index ce7346e7f77a..2aadab6f34a1 100644
--- a/include/linux/mfd/stm32-timers.h
+++ b/include/linux/mfd/stm32-timers.h
@@ -1,9 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Copyright (C) STMicroelectronics 2016
- *
  * Author: Benjamin Gaignard <benjamin.gaignard@st.com>
- *
- * License terms:  GNU General Public License (GPL), version 2
  */
 
 #ifndef _LINUX_STM32_GPTIMER_H_
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index e1cfe9194129..396a103c8bc6 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -25,26 +25,6 @@
                 writew((val) >> 16, (addr) + 2); \
         } while (0)
 
-#define CNF_CMD     0x04
-#define CNF_CTL_BASE   0x10
-#define CNF_INT_PIN  0x3d
-#define CNF_STOP_CLK_CTL 0x40
-#define CNF_GCLK_CTL 0x41
-#define CNF_SD_CLK_MODE 0x42
-#define CNF_PIN_STATUS 0x44
-#define CNF_PWR_CTL_1 0x48
-#define CNF_PWR_CTL_2 0x49
-#define CNF_PWR_CTL_3 0x4a
-#define CNF_CARD_DETECT_MODE 0x4c
-#define CNF_SD_SLOT 0x50
-#define CNF_EXT_GCLK_CTL_1 0xf0
-#define CNF_EXT_GCLK_CTL_2 0xf1
-#define CNF_EXT_GCLK_CTL_3 0xf9
-#define CNF_SD_LED_EN_1 0xfa
-#define CNF_SD_LED_EN_2 0xfe
-
-#define   SDCREN 0x2   /* Enable access to MMC CTL regs. (flag in COMMAND_REG)*/
-
 #define sd_config_write8(base, shift, reg, val) \
         tmio_iowrite8((val), (base) + ((reg) << (shift)))
 #define sd_config_write16(base, shift, reg, val) \
diff --git a/include/linux/mlx5/device.h b/include/linux/mlx5/device.h
index 409ffb14298a..e5258ee4e38b 100644
--- a/include/linux/mlx5/device.h
+++ b/include/linux/mlx5/device.h
@@ -79,6 +79,11 @@
                      << __mlx5_dw_bit_off(typ, fld))); \
 } while (0)
 
+#define MLX5_ARRAY_SET(typ, p, fld, idx, v) do { \
+        BUILD_BUG_ON(__mlx5_bit_off(typ, fld) % 32); \
+        MLX5_SET(typ, p, fld[idx], v); \
+} 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)) = \
@@ -244,6 +249,8 @@ enum {
                                           MLX5_NON_FP_BFREGS_PER_UAR,
         MLX5_UARS_IN_PAGE               = PAGE_SIZE / MLX5_ADAPTER_PAGE_SIZE,
         MLX5_NON_FP_BFREGS_IN_PAGE      = MLX5_NON_FP_BFREGS_PER_UAR * MLX5_UARS_IN_PAGE,
+        MLX5_MIN_DYN_BFREGS             = 512,
+        MLX5_MAX_DYN_BFREGS             = 1024,
 };
 
 enum {
@@ -284,6 +291,7 @@ enum {
         MLX5_EVENT_QUEUE_TYPE_QP = 0,
         MLX5_EVENT_QUEUE_TYPE_RQ = 1,
         MLX5_EVENT_QUEUE_TYPE_SQ = 2,
+        MLX5_EVENT_QUEUE_TYPE_DCT = 6,
 };
 
 enum mlx5_event {
@@ -319,6 +327,8 @@ enum mlx5_event {
         MLX5_EVENT_TYPE_PAGE_FAULT         = 0xc,
         MLX5_EVENT_TYPE_NIC_VPORT_CHANGE   = 0xd,
 
+        MLX5_EVENT_TYPE_DCT_DRAINED        = 0x1c,
+
         MLX5_EVENT_TYPE_FPGA_ERROR         = 0x20,
 };
 
@@ -611,6 +621,11 @@ struct mlx5_eqe_pps {
         u8              rsvd2[12];
 } __packed;
 
+struct mlx5_eqe_dct {
+        __be32  reserved[6];
+        __be32  dctn;
+};
+
 union ev_data {
         __be32                          raw[7];
         struct mlx5_eqe_cmd             cmd;
@@ -626,6 +641,7 @@ union ev_data {
         struct mlx5_eqe_vport_change    vport_change;
         struct mlx5_eqe_port_module     port_module;
         struct mlx5_eqe_pps             pps;
+        struct mlx5_eqe_dct             dct;
 } __packed;
 
 struct mlx5_eqe {
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index a0610427e168..6ed79a8a8318 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -155,6 +155,13 @@ enum mlx5_dcbx_oper_mode {
         MLX5E_DCBX_PARAM_VER_OPER_AUTO  = 0x3,
 };
 
+enum mlx5_dct_atomic_mode {
+        MLX5_ATOMIC_MODE_DCT_OFF        = 20,
+        MLX5_ATOMIC_MODE_DCT_NONE       = 0 << MLX5_ATOMIC_MODE_DCT_OFF,
+        MLX5_ATOMIC_MODE_DCT_IB_COMP    = 1 << MLX5_ATOMIC_MODE_DCT_OFF,
+        MLX5_ATOMIC_MODE_DCT_CX         = 2 << MLX5_ATOMIC_MODE_DCT_OFF,
+};
+
 enum {
         MLX5_ATOMIC_OPS_CMP_SWAP        = 1 << 0,
         MLX5_ATOMIC_OPS_FETCH_ADD       = 1 << 1,
@@ -231,6 +238,9 @@ struct mlx5_bfreg_info {
         u32                     ver;
         bool                    lib_uar_4k;
         u32                     num_sys_pages;
+        u32                     num_static_sys_pages;
+        u32                     total_num_bfregs;
+        u32                     num_dyn_bfregs;
 };
 
 struct mlx5_cmd_first {
@@ -430,6 +440,7 @@ enum mlx5_res_type {
         MLX5_RES_SRQ    = 3,
         MLX5_RES_XSRQ   = 4,
         MLX5_RES_XRQ    = 5,
+        MLX5_RES_DCT    = MLX5_EVENT_QUEUE_TYPE_DCT,
 };
 
 struct mlx5_core_rsc_common {
@@ -788,6 +799,7 @@ struct mlx5_clock {
         u32                        nominal_c_mult;
         unsigned long              overflow_period;
         struct delayed_work        overflow_work;
+        struct mlx5_core_dev      *mdev;
         struct ptp_clock          *ptp;
         struct ptp_clock_info      ptp_info;
         struct mlx5_pps            pps_info;
@@ -826,7 +838,7 @@ struct mlx5_core_dev {
         struct mlx5e_resources  mlx5e_res;
         struct {
                 struct mlx5_rsvd_gids   reserved_gids;
-                atomic_t                roce_en;
+                u32                     roce_en;
         } roce;
 #ifdef CONFIG_MLX5_FPGA
         struct mlx5_fpga_device *fpga;
@@ -835,6 +847,8 @@ struct mlx5_core_dev {
         struct cpu_rmap         *rmap;
 #endif
         struct mlx5_clock        clock;
+        struct mlx5_ib_clock_info  *clock_info;
+        struct page             *clock_info_page;
 };
 
 struct mlx5_db {
@@ -1103,7 +1117,7 @@ void mlx5_free_bfreg(struct mlx5_core_dev *mdev, struct mlx5_sq_bfreg *bfreg);
 unsigned int mlx5_core_reserved_gids_count(struct mlx5_core_dev *dev);
 int mlx5_core_roce_gid_set(struct mlx5_core_dev *dev, unsigned int index,
                            u8 roce_version, u8 roce_l3_type, const u8 *gid,
-                           const u8 *mac, bool vlan, u16 vlan_id);
+                           const u8 *mac, bool vlan, u16 vlan_id, u8 port_num);
 
 static inline int fw_initializing(struct mlx5_core_dev *dev)
 {
@@ -1225,6 +1239,31 @@ static inline bool mlx5_rl_is_supported(struct mlx5_core_dev *dev)
         return !!(dev->priv.rl_table.max_size);
 }
 
+static inline int mlx5_core_is_mp_slave(struct mlx5_core_dev *dev)
+{
+        return MLX5_CAP_GEN(dev, affiliate_nic_vport_criteria) &&
+               MLX5_CAP_GEN(dev, num_vhca_ports) <= 1;
+}
+
+static inline int mlx5_core_is_mp_master(struct mlx5_core_dev *dev)
+{
+        return MLX5_CAP_GEN(dev, num_vhca_ports) > 1;
+}
+
+static inline int mlx5_core_mp_enabled(struct mlx5_core_dev *dev)
+{
+        return mlx5_core_is_mp_slave(dev) ||
+               mlx5_core_is_mp_master(dev);
+}
+
+static inline int mlx5_core_native_port_num(struct mlx5_core_dev *dev)
+{
+        if (!mlx5_core_mp_enabled(dev))
+                return 1;
+
+        return MLX5_CAP_GEN(dev, native_port_num);
+}
+
 enum {
         MLX5_TRIGGERED_CMD_COMP = (u64)1 << 32,
 };
@@ -1238,7 +1277,7 @@ mlx5_get_vector_affinity(struct mlx5_core_dev *dev, int vector)
         int eqn;
         int err;
 
-        err = mlx5_vector2eqn(dev, vector, &eqn, &irq);
+        err = mlx5_vector2eqn(dev, MLX5_EQ_VEC_COMP_BASE + vector, &eqn, &irq);
         if (err)
                 return NULL;
 
diff --git a/include/linux/mlx5/fs.h b/include/linux/mlx5/fs.h
index b25e7baa273e..a0b48afcb422 100644
--- a/include/linux/mlx5/fs.h
+++ b/include/linux/mlx5/fs.h
@@ -95,6 +95,10 @@ struct mlx5_flow_destination {
 struct mlx5_flow_namespace *
 mlx5_get_flow_namespace(struct mlx5_core_dev *dev,
                         enum mlx5_flow_namespace_type type);
+struct mlx5_flow_namespace *
+mlx5_get_flow_vport_acl_namespace(struct mlx5_core_dev *dev,
+                                  enum mlx5_flow_namespace_type type,
+                                  int vport);
 
 struct mlx5_flow_table *
 mlx5_create_auto_grouped_flow_table(struct mlx5_flow_namespace *ns,
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index 1391a82da98e..f4e417686f62 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -502,7 +502,7 @@ struct mlx5_ifc_ads_bits {
         u8         dei_cfi[0x1];
         u8         eth_prio[0x3];
         u8         sl[0x4];
-        u8         port[0x8];
+        u8         vhca_port_num[0x8];
         u8         rmac_47_32[0x10];
 
         u8         rmac_31_0[0x20];
@@ -794,7 +794,10 @@ enum {
 };
 
 struct mlx5_ifc_cmd_hca_cap_bits {
-        u8         reserved_at_0[0x80];
+        u8         reserved_at_0[0x30];
+        u8         vhca_id[0x10];
+
+        u8         reserved_at_40[0x40];
 
         u8         log_max_srq_sz[0x8];
         u8         log_max_qp_sz[0x8];
@@ -1023,13 +1026,21 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         reserved_at_3b8[0x3];
         u8         log_min_stride_sz_sq[0x5];
 
-        u8         reserved_at_3c0[0x1b];
+        u8         hairpin[0x1];
+        u8         reserved_at_3c1[0x2];
+        u8         log_max_hairpin_queues[0x5];
+        u8         reserved_at_3c8[0x3];
+        u8         log_max_hairpin_wq_data_sz[0x5];
+        u8         reserved_at_3d0[0x3];
+        u8         log_max_hairpin_num_packets[0x5];
+        u8         reserved_at_3d8[0x3];
         u8         log_max_wq_sz[0x5];
 
         u8         nic_vport_change_event[0x1];
         u8         disable_local_lb_uc[0x1];
         u8         disable_local_lb_mc[0x1];
-        u8         reserved_at_3e3[0x8];
+        u8         log_min_hairpin_wq_data_sz[0x5];
+        u8         reserved_at_3e8[0x3];
         u8         log_max_vlan_list[0x5];
         u8         reserved_at_3f0[0x3];
         u8         log_max_current_mc_list[0x5];
@@ -1067,7 +1078,12 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         reserved_at_5f8[0x3];
         u8         log_max_xrq[0x5];
 
-        u8         reserved_at_600[0x200];
+        u8         affiliate_nic_vport_criteria[0x8];
+        u8         native_port_num[0x8];
+        u8         num_vhca_ports[0x8];
+        u8         reserved_at_618[0x6];
+        u8         sw_owner_id[0x1];
+        u8         reserved_at_61f[0x1e1];
 };
 
 enum mlx5_flow_destination_type {
@@ -1163,7 +1179,12 @@ struct mlx5_ifc_wq_bits {
         u8         reserved_at_118[0x3];
         u8         log_wq_sz[0x5];
 
-        u8         reserved_at_120[0x15];
+        u8         reserved_at_120[0x3];
+        u8         log_hairpin_num_packets[0x5];
+        u8         reserved_at_128[0x3];
+        u8         log_hairpin_data_sz[0x5];
+        u8         reserved_at_130[0x5];
+
         u8         log_wqe_num_of_strides[0x3];
         u8         two_byte_shift_en[0x1];
         u8         reserved_at_139[0x4];
@@ -2483,7 +2504,8 @@ struct mlx5_ifc_sqc_bits {
         u8         state[0x4];
         u8         reg_umr[0x1];
         u8         allow_swp[0x1];
-        u8         reserved_at_e[0x12];
+        u8         hairpin[0x1];
+        u8         reserved_at_f[0x11];
 
         u8         reserved_at_20[0x8];
         u8         user_index[0x18];
@@ -2491,7 +2513,13 @@ struct mlx5_ifc_sqc_bits {
         u8         reserved_at_40[0x8];
         u8         cqn[0x18];
 
-        u8         reserved_at_60[0x90];
+        u8         reserved_at_60[0x8];
+        u8         hairpin_peer_rq[0x18];
+
+        u8         reserved_at_80[0x10];
+        u8         hairpin_peer_vhca[0x10];
+
+        u8         reserved_at_a0[0x50];
 
         u8         packet_pacing_rate_limit_index[0x10];
         u8         tis_lst_sz[0x10];
@@ -2563,7 +2591,8 @@ struct mlx5_ifc_rqc_bits {
         u8         state[0x4];
         u8         reserved_at_c[0x1];
         u8         flush_in_error_en[0x1];
-        u8         reserved_at_e[0x12];
+        u8         hairpin[0x1];
+        u8         reserved_at_f[0x11];
 
         u8         reserved_at_20[0x8];
         u8         user_index[0x18];
@@ -2577,7 +2606,13 @@ struct mlx5_ifc_rqc_bits {
         u8         reserved_at_80[0x8];
         u8         rmpn[0x18];
 
-        u8         reserved_at_a0[0xe0];
+        u8         reserved_at_a0[0x8];
+        u8         hairpin_peer_sq[0x18];
+
+        u8         reserved_at_c0[0x10];
+        u8         hairpin_peer_vhca[0x10];
+
+        u8         reserved_at_e0[0xa0];
 
         struct mlx5_ifc_wq_bits wq;
 };
@@ -2616,7 +2651,12 @@ struct mlx5_ifc_nic_vport_context_bits {
         u8         event_on_mc_address_change[0x1];
         u8         event_on_uc_address_change[0x1];
 
-        u8         reserved_at_40[0xf0];
+        u8         reserved_at_40[0xc];
+
+        u8         affiliation_criteria[0x4];
+        u8         affiliated_vhca_id[0x10];
+
+        u8         reserved_at_60[0xd0];
 
         u8         mtu[0x10];
 
@@ -3259,7 +3299,8 @@ struct mlx5_ifc_set_roce_address_in_bits {
         u8         op_mod[0x10];
 
         u8         roce_address_index[0x10];
-        u8         reserved_at_50[0x10];
+        u8         reserved_at_50[0xc];
+        u8         vhca_port_num[0x4];
 
         u8         reserved_at_60[0x20];
 
@@ -3879,7 +3920,8 @@ struct mlx5_ifc_query_roce_address_in_bits {
         u8         op_mod[0x10];
 
         u8         roce_address_index[0x10];
-        u8         reserved_at_50[0x10];
+        u8         reserved_at_50[0xc];
+        u8         vhca_port_num[0x4];
 
         u8         reserved_at_60[0x20];
 };
@@ -5311,7 +5353,9 @@ struct mlx5_ifc_modify_nic_vport_context_out_bits {
 };
 
 struct mlx5_ifc_modify_nic_vport_field_select_bits {
-        u8         reserved_at_0[0x14];
+        u8         reserved_at_0[0x12];
+        u8         affiliation[0x1];
+        u8         reserved_at_e[0x1];
         u8         disable_uc_local_lb[0x1];
         u8         disable_mc_local_lb[0x1];
         u8         node_guid[0x1];
@@ -5532,6 +5576,7 @@ struct mlx5_ifc_init_hca_in_bits {
         u8         op_mod[0x10];
 
         u8         reserved_at_40[0x40];
+        u8         sw_owner_id[4][0x20];
 };
 
 struct mlx5_ifc_init2rtr_qp_out_bits {
diff --git a/include/linux/mlx5/qp.h b/include/linux/mlx5/qp.h
index 62af7512dabb..4778d41085d4 100644
--- a/include/linux/mlx5/qp.h
+++ b/include/linux/mlx5/qp.h
@@ -473,6 +473,11 @@ struct mlx5_core_qp {
         int                     pid;
 };
 
+struct mlx5_core_dct {
+        struct mlx5_core_qp     mqp;
+        struct completion       drained;
+};
+
 struct mlx5_qp_path {
         u8                      fl_free_ar;
         u8                      rsvd3;
@@ -549,6 +554,9 @@ static inline struct mlx5_core_mkey *__mlx5_mr_lookup(struct mlx5_core_dev *dev,
         return radix_tree_lookup(&dev->priv.mkey_table.tree, key);
 }
 
+int mlx5_core_create_dct(struct mlx5_core_dev *dev,
+                         struct mlx5_core_dct *qp,
+                         u32 *in, int inlen);
 int mlx5_core_create_qp(struct mlx5_core_dev *dev,
                         struct mlx5_core_qp *qp,
                         u32 *in,
@@ -558,8 +566,12 @@ int mlx5_core_qp_modify(struct mlx5_core_dev *dev, u16 opcode,
                         struct mlx5_core_qp *qp);
 int mlx5_core_destroy_qp(struct mlx5_core_dev *dev,
                          struct mlx5_core_qp *qp);
+int mlx5_core_destroy_dct(struct mlx5_core_dev *dev,
+                          struct mlx5_core_dct *dct);
 int mlx5_core_qp_query(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp,
                        u32 *out, int outlen);
+int mlx5_core_dct_query(struct mlx5_core_dev *dev, struct mlx5_core_dct *dct,
+                        u32 *out, int outlen);
 
 int mlx5_core_set_delay_drop(struct mlx5_core_dev *dev,
                              u32 timeout_usec);
diff --git a/include/linux/mlx5/transobj.h b/include/linux/mlx5/transobj.h
index 88441f5ece25..7e8f281f8c00 100644
--- a/include/linux/mlx5/transobj.h
+++ b/include/linux/mlx5/transobj.h
@@ -75,4 +75,27 @@ int mlx5_core_modify_rqt(struct mlx5_core_dev *dev, u32 rqtn, u32 *in,
                          int inlen);
 void mlx5_core_destroy_rqt(struct mlx5_core_dev *dev, u32 rqtn);
 
+struct mlx5_hairpin_params {
+        u8  log_data_size;
+        u8  log_num_packets;
+        u16 q_counter;
+        int num_channels;
+};
+
+struct mlx5_hairpin {
+        struct mlx5_core_dev *func_mdev;
+        struct mlx5_core_dev *peer_mdev;
+
+        int num_channels;
+
+        u32 *rqn;
+        u32 *sqn;
+};
+
+struct mlx5_hairpin *
+mlx5_core_hairpin_create(struct mlx5_core_dev *func_mdev,
+                         struct mlx5_core_dev *peer_mdev,
+                         struct mlx5_hairpin_params *params);
+
+void mlx5_core_hairpin_destroy(struct mlx5_hairpin *pair);
 #endif /* __TRANSOBJ_H__ */
diff --git a/include/linux/mlx5/vport.h b/include/linux/mlx5/vport.h
index aaa0bb9e7655..64e193e87394 100644
--- a/include/linux/mlx5/vport.h
+++ b/include/linux/mlx5/vport.h
@@ -116,4 +116,8 @@ int mlx5_core_modify_hca_vport_context(struct mlx5_core_dev *dev,
                                        struct mlx5_hca_vport_context *req);
 int mlx5_nic_vport_update_local_lb(struct mlx5_core_dev *mdev, bool enable);
 int mlx5_nic_vport_query_local_lb(struct mlx5_core_dev *mdev, bool *status);
+
+int mlx5_nic_vport_affiliate_multiport(struct mlx5_core_dev *master_mdev,
+                                       struct mlx5_core_dev *port_mdev);
+int mlx5_nic_vport_unaffiliate_multiport(struct mlx5_core_dev *port_mdev);
 #endif /* __MLX5_VPORT_H__ */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index ea818ff739cd..ad06d42adb1a 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1312,8 +1312,6 @@ void free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
                 unsigned long end, unsigned long floor, unsigned long ceiling);
 int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
                         struct vm_area_struct *vma);
-void unmap_mapping_range(struct address_space *mapping,
-                loff_t const holebegin, loff_t const holelen, int even_cows);
 int follow_pte_pmd(struct mm_struct *mm, unsigned long address,
                              unsigned long *start, unsigned long *end,
                              pte_t **ptepp, pmd_t **pmdpp, spinlock_t **ptlp);
@@ -1324,12 +1322,6 @@ int follow_phys(struct vm_area_struct *vma, unsigned long address,
 int generic_access_phys(struct vm_area_struct *vma, unsigned long addr,
                         void *buf, int len, int write);
 
-static inline void unmap_shared_mapping_range(struct address_space *mapping,
-                loff_t const holebegin, loff_t const holelen)
-{
-        unmap_mapping_range(mapping, holebegin, holelen, 0);
-}
-
 extern void truncate_pagecache(struct inode *inode, loff_t new);
 extern void truncate_setsize(struct inode *inode, loff_t newsize);
 void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to);
@@ -1344,6 +1336,10 @@ extern int handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
 extern int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
                             unsigned long address, unsigned int fault_flags,
                             bool *unlocked);
+void unmap_mapping_pages(struct address_space *mapping,
+                pgoff_t start, pgoff_t nr, bool even_cows);
+void unmap_mapping_range(struct address_space *mapping,
+                loff_t const holebegin, loff_t const holelen, int even_cows);
 #else
 static inline int handle_mm_fault(struct vm_area_struct *vma,
                 unsigned long address, unsigned int flags)
@@ -1360,10 +1356,20 @@ static inline int fixup_user_fault(struct task_struct *tsk,
         BUG();
         return -EFAULT;
 }
+static inline void unmap_mapping_pages(struct address_space *mapping,
+                pgoff_t start, pgoff_t nr, bool even_cows) { }
+static inline void unmap_mapping_range(struct address_space *mapping,
+                loff_t const holebegin, loff_t const holelen, int even_cows) { }
 #endif
 
-extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len,
-                unsigned int gup_flags);
+static inline void unmap_shared_mapping_range(struct address_space *mapping,
+                loff_t const holebegin, loff_t const holelen)
+{
+        unmap_mapping_range(mapping, holebegin, holelen, 0);
+}
+
+extern int access_process_vm(struct task_struct *tsk, unsigned long addr,
+                void *buf, int len, unsigned int gup_flags);
 extern int access_remote_vm(struct mm_struct *mm, unsigned long addr,
                 void *buf, int len, unsigned int gup_flags);
 extern int __access_remote_vm(struct task_struct *tsk, struct mm_struct *mm,
@@ -2069,8 +2075,8 @@ static inline void zero_resv_unavail(void) {}
 #endif
 
 extern void set_dma_reserve(unsigned long new_dma_reserve);
-extern void memmap_init_zone(unsigned long, int, unsigned long,
-                                unsigned long, enum memmap_context);
+extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long,
+                enum memmap_context, struct vmem_altmap *);
 extern void setup_per_zone_wmarks(void);
 extern int __meminit init_per_zone_wmark_min(void);
 extern void mem_init(void);
@@ -2538,7 +2544,8 @@ void sparse_mem_maps_populate_node(struct page **map_map,
                                    unsigned long map_count,
                                    int nodeid);
 
-struct page *sparse_mem_map_populate(unsigned long pnum, int nid);
+struct page *sparse_mem_map_populate(unsigned long pnum, int nid,
+                struct vmem_altmap *altmap);
 pgd_t *vmemmap_pgd_populate(unsigned long addr, int node);
 p4d_t *vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node);
 pud_t *vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node);
@@ -2546,20 +2553,17 @@ pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node);
 pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node);
 void *vmemmap_alloc_block(unsigned long size, int node);
 struct vmem_altmap;
-void *__vmemmap_alloc_block_buf(unsigned long size, int node,
-                struct vmem_altmap *altmap);
-static inline void *vmemmap_alloc_block_buf(unsigned long size, int node)
-{
-        return __vmemmap_alloc_block_buf(size, node, NULL);
-}
-
+void *vmemmap_alloc_block_buf(unsigned long size, int node);
+void *altmap_alloc_block_buf(unsigned long size, struct vmem_altmap *altmap);
 void vmemmap_verify(pte_t *, int, unsigned long, unsigned long);
 int vmemmap_populate_basepages(unsigned long start, unsigned long end,
                                int node);
-int vmemmap_populate(unsigned long start, unsigned long end, int node);
+int vmemmap_populate(unsigned long start, unsigned long end, int node,
+                struct vmem_altmap *altmap);
 void vmemmap_populate_print_last(void);
 #ifdef CONFIG_MEMORY_HOTPLUG
-void vmemmap_free(unsigned long start, unsigned long end);
+void vmemmap_free(unsigned long start, unsigned long end,
+                struct vmem_altmap *altmap);
 #endif
 void register_page_bootmem_memmap(unsigned long section_nr, struct page *map,
                                   unsigned long nr_pages);
@@ -2570,8 +2574,8 @@ enum mf_flags {
         MF_MUST_KILL = 1 << 2,
         MF_SOFT_OFFLINE = 1 << 3,
 };
-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 memory_failure(unsigned long pfn, int flags);
+extern void memory_failure_queue(unsigned long pfn, int flags);
 extern int unpoison_memory(unsigned long pfn);
 extern int get_hwpoison_page(struct page *page);
 #define put_hwpoison_page(page) put_page(page)
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index cfd0ac4e5e0e..fd1af6b9591d 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -31,28 +31,56 @@ struct hmm;
  * it to keep track of whatever it is we are using the page for at the
  * moment. Note that we have no way to track which tasks are using
  * a page, though if it is a pagecache page, rmap structures can tell us
- * who is mapping it.
+ * who is mapping it. If you allocate the page using alloc_pages(), you
+ * can use some of the space in struct page for your own purposes.
  *
- * The objects in struct page are organized in double word blocks in
- * order to allows us to use atomic double word operations on portions
- * of struct page. That is currently only used by slub but the arrangement
- * allows the use of atomic double word operations on the flags/mapping
- * and lru list pointers also.
+ * Pages that were once in the page cache may be found under the RCU lock
+ * even after they have been recycled to a different purpose.  The page
+ * cache reads and writes some of the fields in struct page to pin the
+ * page before checking that it's still in the page cache.  It is vital
+ * that all users of struct page:
+ * 1. Use the first word as PageFlags.
+ * 2. Clear or preserve bit 0 of page->compound_head.  It is used as
+ *    PageTail for compound pages, and the page cache must not see false
+ *    positives.  Some users put a pointer here (guaranteed to be at least
+ *    4-byte aligned), other users avoid using the field altogether.
+ * 3. page->_refcount must either not be used, or must be used in such a
+ *    way that other CPUs temporarily incrementing and then decrementing the
+ *    refcount does not cause problems.  On receiving the page from
+ *    alloc_pages(), the refcount will be positive.
+ * 4. Either preserve page->_mapcount or restore it to -1 before freeing it.
+ *
+ * If you allocate pages of order > 0, you can use the fields in the struct
+ * page associated with each page, but bear in mind that the pages may have
+ * been inserted individually into the page cache, so you must use the above
+ * four fields in a compatible way for each struct page.
+ *
+ * SLUB uses cmpxchg_double() to atomically update its freelist and
+ * counters.  That requires that freelist & counters be adjacent and
+ * double-word aligned.  We align all struct pages to double-word
+ * boundaries, and ensure that 'freelist' is aligned within the
+ * struct.
  */
+#ifdef CONFIG_HAVE_ALIGNED_STRUCT_PAGE
+#define _struct_page_alignment  __aligned(2 * sizeof(unsigned long))
+#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE)
+#define _slub_counter_t         unsigned long
+#else
+#define _slub_counter_t         unsigned int
+#endif
+#else /* !CONFIG_HAVE_ALIGNED_STRUCT_PAGE */
+#define _struct_page_alignment
+#define _slub_counter_t         unsigned int
+#endif /* !CONFIG_HAVE_ALIGNED_STRUCT_PAGE */
+
 struct page {
         /* First double word block */
         unsigned long flags;            /* Atomic flags, some possibly
                                          * updated asynchronously */
         union {
-                struct address_space *mapping;  /* If low bit clear, points to
-                                                 * inode address_space, or NULL.
-                                                 * If page mapped as anonymous
-                                                 * memory, low bit is set, and
-                                                 * it points to anon_vma object
-                                                 * or KSM private structure. See
-                                                 * PAGE_MAPPING_ANON and
-                                                 * PAGE_MAPPING_KSM.
-                                                 */
+                /* See page-flags.h for the definition of PAGE_MAPPING_FLAGS */
+                struct address_space *mapping;
+
                 void *s_mem;                    /* slab first object */
                 atomic_t compound_mapcount;     /* first tail page */
                 /* page_deferred_list().next     -- second tail page */
@@ -66,40 +94,27 @@ struct page {
         };
 
         union {
-#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
-        defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
-                /* Used for cmpxchg_double in slub */
-                unsigned long counters;
-#else
-                /*
-                 * Keep _refcount separate from slub cmpxchg_double data.
-                 * As the rest of the double word is protected by slab_lock
-                 * but _refcount is not.
-                 */
-                unsigned counters;
-#endif
-                struct {
+                _slub_counter_t counters;
+                unsigned int active;            /* SLAB */
+                struct {                        /* SLUB */
+                        unsigned inuse:16;
+                        unsigned objects:15;
+                        unsigned frozen:1;
+                };
+                int units;                      /* SLOB */
+
+                struct {                        /* Page cache */
+                        /*
+                         * Count of ptes mapped in mms, to show when
+                         * page is mapped & limit reverse map searches.
+                         *
+                         * Extra information about page type may be
+                         * stored here for pages that are never mapped,
+                         * in which case the value MUST BE <= -2.
+                         * See page-flags.h for more details.
+                         */
+                        atomic_t _mapcount;
 
-                        union {
-                                /*
-                                 * Count of ptes mapped in mms, to show when
-                                 * page is mapped & limit reverse map searches.
-                                 *
-                                 * Extra information about page type may be
-                                 * stored here for pages that are never mapped,
-                                 * in which case the value MUST BE <= -2.
-                                 * See page-flags.h for more details.
-                                 */
-                                atomic_t _mapcount;
-
-                                unsigned int active;            /* SLAB */
-                                struct {                        /* SLUB */
-                                        unsigned inuse:16;
-                                        unsigned objects:15;
-                                        unsigned frozen:1;
-                                };
-                                int units;                      /* SLOB */
-                        };
                         /*
                          * Usage count, *USE WRAPPER FUNCTION* when manual
                          * accounting. See page_ref.h
@@ -109,8 +124,6 @@ struct page {
         };
 
         /*
-         * Third double word block
-         *
          * WARNING: bit 0 of the first word encode PageTail(). That means
          * the rest users of the storage space MUST NOT use the bit to
          * avoid collision and false-positive PageTail().
@@ -145,19 +158,9 @@ struct page {
                         unsigned long compound_head; /* If bit zero is set */
 
                         /* First tail page only */
-#ifdef CONFIG_64BIT
-                        /*
-                         * On 64 bit system we have enough space in struct page
-                         * to encode compound_dtor and compound_order with
-                         * unsigned int. It can help compiler generate better or
-                         * smaller code on some archtectures.
-                         */
-                        unsigned int compound_dtor;
-                        unsigned int compound_order;
-#else
-                        unsigned short int compound_dtor;
-                        unsigned short int compound_order;
-#endif
+                        unsigned char compound_dtor;
+                        unsigned char compound_order;
+                        /* two/six bytes available here */
                 };
 
 #if defined(CONFIG_TRANSPARENT_HUGEPAGE) && USE_SPLIT_PMD_PTLOCKS
@@ -171,15 +174,14 @@ struct page {
 #endif
         };
 
-        /* Remainder is not double word aligned */
         union {
-                unsigned long private;          /* Mapping-private opaque data:
-                                                 * usually used for buffer_heads
-                                                 * if PagePrivate set; used for
-                                                 * swp_entry_t if PageSwapCache;
-                                                 * indicates order in the buddy
-                                                 * system if PG_buddy is set.
-                                                 */
+                /*
+                 * Mapping-private opaque data:
+                 * Usually used for buffer_heads if PagePrivate
+                 * Used for swp_entry_t if PageSwapCache
+                 * Indicates order in the buddy system if PageBuddy
+                 */
+                unsigned long private;
 #if USE_SPLIT_PTE_PTLOCKS
 #if ALLOC_SPLIT_PTLOCKS
                 spinlock_t *ptl;
@@ -212,15 +214,7 @@ struct page {
 #ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
         int _last_cpupid;
 #endif
-}
-/*
- * The struct page can be forced to be double word aligned so that atomic ops
- * on double words work. The SLUB allocator can make use of such a feature.
- */
-#ifdef CONFIG_HAVE_ALIGNED_STRUCT_PAGE
-        __aligned(2 * sizeof(unsigned long))
-#endif
-;
+} _struct_page_alignment;
 
 #define PAGE_FRAG_CACHE_MAX_SIZE        __ALIGN_MASK(32768, ~PAGE_MASK)
 #define PAGE_FRAG_CACHE_MAX_ORDER       get_order(PAGE_FRAG_CACHE_MAX_SIZE)
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index e7743eca1021..85146235231e 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -324,6 +324,7 @@ struct mmc_host {
 #define MMC_CAP_DRIVER_TYPE_A   (1 << 23)       /* Host supports Driver Type A */
 #define MMC_CAP_DRIVER_TYPE_C   (1 << 24)       /* Host supports Driver Type C */
 #define MMC_CAP_DRIVER_TYPE_D   (1 << 25)       /* Host supports Driver Type D */
+#define MMC_CAP_DONE_COMPLETE   (1 << 27)       /* RW reqs can be completed within mmc_request_done() */
 #define MMC_CAP_CD_WAKE         (1 << 28)       /* Enable card detect wake */
 #define MMC_CAP_CMD_DURING_TFR  (1 << 29)       /* Commands during data transfer */
 #define MMC_CAP_CMD23           (1 << 30)       /* CMD23 supported. */
@@ -380,6 +381,7 @@ struct mmc_host {
         unsigned int            doing_retune:1; /* re-tuning in progress */
         unsigned int            retune_now:1;   /* do re-tuning at next req */
         unsigned int            retune_paused:1; /* re-tuning is temporarily disabled */
+        unsigned int            use_blk_mq:1;   /* use blk-mq */
 
         int                     rescan_disable; /* disable card detection */
         int                     rescan_entered; /* used with nonremovable devices */
@@ -422,9 +424,6 @@ struct mmc_host {
 
         struct dentry           *debugfs_root;
 
-        struct mmc_async_req    *areq;          /* active async req */
-        struct mmc_context_info context_info;   /* async synchronization info */
-
         /* Ongoing data transfer that allows commands during transfer */
         struct mmc_request      *ongoing_mrq;
 
diff --git a/include/linux/mmc/slot-gpio.h b/include/linux/mmc/slot-gpio.h
index 82f0d289f110..91f1ba0663c8 100644
--- a/include/linux/mmc/slot-gpio.h
+++ b/include/linux/mmc/slot-gpio.h
@@ -33,5 +33,6 @@ void mmc_gpio_set_cd_isr(struct mmc_host *host,
                          irqreturn_t (*isr)(int irq, void *dev_id));
 void mmc_gpiod_request_cd_irq(struct mmc_host *host);
 bool mmc_can_gpio_cd(struct mmc_host *host);
+bool mmc_can_gpio_ro(struct mmc_host *host);
 
 #endif
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index b25dc9db19fc..2d07a1ed5a31 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -2,6 +2,7 @@
 #ifndef _LINUX_MMU_NOTIFIER_H
 #define _LINUX_MMU_NOTIFIER_H
 
+#include <linux/types.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/mm_types.h>
@@ -10,6 +11,9 @@
 struct mmu_notifier;
 struct mmu_notifier_ops;
 
+/* mmu_notifier_ops flags */
+#define MMU_INVALIDATE_DOES_NOT_BLOCK   (0x01)
+
 #ifdef CONFIG_MMU_NOTIFIER
 
 /*
@@ -27,6 +31,15 @@ struct mmu_notifier_mm {
 
 struct mmu_notifier_ops {
         /*
+         * Flags to specify behavior of callbacks for this MMU notifier.
+         * Used to determine which context an operation may be called.
+         *
+         * MMU_INVALIDATE_DOES_NOT_BLOCK: invalidate_range_* callbacks do not
+         *      block
+         */
+        int flags;
+
+        /*
          * Called either by mmu_notifier_unregister or when the mm is
          * being destroyed by exit_mmap, always before all pages are
          * freed. This can run concurrently with other mmu notifier
@@ -137,6 +150,10 @@ struct mmu_notifier_ops {
          * page. Pages will no longer be referenced by the linux
          * address space but may still be referenced by sptes until
          * the last refcount is dropped.
+         *
+         * If both of these callbacks cannot block, and invalidate_range
+         * cannot block, mmu_notifier_ops.flags should have
+         * MMU_INVALIDATE_DOES_NOT_BLOCK set.
          */
         void (*invalidate_range_start)(struct mmu_notifier *mn,
                                        struct mm_struct *mm,
@@ -159,12 +176,13 @@ struct mmu_notifier_ops {
          * external TLB range needs to be flushed. For more in depth
          * discussion on this see Documentation/vm/mmu_notifier.txt
          *
-         * The invalidate_range() function is called under the ptl
-         * spin-lock and not allowed to sleep.
-         *
          * Note that this function might be called with just a sub-range
          * of what was passed to invalidate_range_start()/end(), if
          * called between those functions.
+         *
+         * If this callback cannot block, and invalidate_range_{start,end}
+         * cannot block, mmu_notifier_ops.flags should have
+         * MMU_INVALIDATE_DOES_NOT_BLOCK set.
          */
         void (*invalidate_range)(struct mmu_notifier *mn, struct mm_struct *mm,
                                  unsigned long start, unsigned long end);
@@ -218,6 +236,7 @@ extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                                   bool only_end);
 extern void __mmu_notifier_invalidate_range(struct mm_struct *mm,
                                   unsigned long start, unsigned long end);
+extern bool mm_has_blockable_invalidate_notifiers(struct mm_struct *mm);
 
 static inline void mmu_notifier_release(struct mm_struct *mm)
 {
@@ -457,6 +476,11 @@ static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
 {
 }
 
+static inline bool mm_has_blockable_invalidate_notifiers(struct mm_struct *mm)
+{
+        return false;
+}
+
 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
 {
 }
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 67f2e3c38939..7522a6987595 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -1166,8 +1166,16 @@ extern unsigned long usemap_size(void);
 
 /*
  * We use the lower bits of the mem_map pointer to store
- * a little bit of information.  There should be at least
- * 3 bits here due to 32-bit alignment.
+ * a little bit of information.  The pointer is calculated
+ * as mem_map - section_nr_to_pfn(pnum).  The result is
+ * aligned to the minimum alignment of the two values:
+ *   1. All mem_map arrays are page-aligned.
+ *   2. section_nr_to_pfn() always clears PFN_SECTION_SHIFT
+ *      lowest bits.  PFN_SECTION_SHIFT is arch-specific
+ *      (equal SECTION_SIZE_BITS - PAGE_SHIFT), and the
+ *      worst combination is powerpc with 256k pages,
+ *      which results in PFN_SECTION_SHIFT equal 6.
+ * To sum it up, at least 6 bits are available.
  */
 #define SECTION_MARKED_PRESENT  (1UL<<0)
 #define SECTION_HAS_MEM_MAP     (1UL<<1)
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index abb6dc2ebbf8..48fb2b43c35a 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -229,6 +229,12 @@ struct hda_device_id {
         unsigned long driver_data;
 };
 
+struct sdw_device_id {
+        __u16 mfg_id;
+        __u16 part_id;
+        kernel_ulong_t driver_data;
+};
+
 /*
  * Struct used for matching a device
  */
@@ -452,6 +458,19 @@ struct spi_device_id {
         kernel_ulong_t driver_data;     /* Data private to the driver */
 };
 
+/* SLIMbus */
+
+#define SLIMBUS_NAME_SIZE       32
+#define SLIMBUS_MODULE_PREFIX   "slim:"
+
+struct slim_device_id {
+        __u16 manf_id, prod_code;
+        __u16 dev_index, instance;
+
+        /* Data private to the driver */
+        kernel_ulong_t driver_data;
+};
+
 #define SPMI_NAME_SIZE  32
 #define SPMI_MODULE_PREFIX "spmi:"
 
diff --git a/include/linux/module.h b/include/linux/module.h
index c69b49abe877..d44df9b2c131 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -19,6 +19,7 @@
 #include <linux/jump_label.h>
 #include <linux/export.h>
 #include <linux/rbtree_latch.h>
+#include <linux/error-injection.h>
 
 #include <linux/percpu.h>
 #include <asm/module.h>
@@ -475,6 +476,11 @@ struct module {
         ctor_fn_t *ctors;
         unsigned int num_ctors;
 #endif
+
+#ifdef CONFIG_FUNCTION_ERROR_INJECTION
+        struct error_injection_entry *ei_funcs;
+        unsigned int num_ei_funcs;
+#endif
 } ____cacheline_aligned __randomize_layout;
 #ifndef MODULE_ARCH_INIT
 #define MODULE_ARCH_INIT {}
@@ -485,7 +491,7 @@ extern struct mutex module_mutex;
 /* FIXME: It'd be nice to isolate modules during init, too, so they
    aren't used before they (may) fail.  But presently too much code
    (IDE & SCSI) require entry into the module during init.*/
-static inline int module_is_live(struct module *mod)
+static inline bool module_is_live(struct module *mod)
 {
         return mod->state != MODULE_STATE_GOING;
 }
@@ -606,6 +612,9 @@ int ref_module(struct module *a, struct module *b);
         __mod ? __mod->name : "kernel";         \
 })
 
+/* Dereference module function descriptor */
+void *dereference_module_function_descriptor(struct module *mod, void *ptr);
+
 /* For kallsyms to ask for address resolution.  namebuf should be at
  * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
  * found, otherwise NULL. */
@@ -760,6 +769,13 @@ static inline bool is_module_sig_enforced(void)
         return false;
 }
 
+/* Dereference module function descriptor */
+static inline
+void *dereference_module_function_descriptor(struct module *mod, void *ptr)
+{
+        return ptr;
+}
+
 #endif /* CONFIG_MODULES */
 
 #ifdef CONFIG_SYSFS
@@ -801,6 +817,15 @@ static inline void module_bug_finalize(const Elf_Ehdr *hdr,
 static inline void module_bug_cleanup(struct module *mod) {}
 #endif  /* CONFIG_GENERIC_BUG */
 
+#ifdef RETPOLINE
+extern bool retpoline_module_ok(bool has_retpoline);
+#else
+static inline bool retpoline_module_ok(bool has_retpoline)
+{
+        return true;
+}
+#endif
+
 #ifdef CONFIG_MODULE_SIG
 static inline bool module_sig_ok(struct module *module)
 {
diff --git a/include/linux/mtd/map.h b/include/linux/mtd/map.h
index 3aa56e3104bb..b5b43f94f311 100644
--- a/include/linux/mtd/map.h
+++ b/include/linux/mtd/map.h
@@ -270,75 +270,67 @@ void map_destroy(struct mtd_info *mtd);
 #define INVALIDATE_CACHED_RANGE(map, from, size) \
         do { if (map->inval_cache) map->inval_cache(map, from, size); } while (0)
 
-
-static inline int map_word_equal(struct map_info *map, map_word val1, map_word val2)
-{
-        int i;
-
-        for (i = 0; i < map_words(map); i++) {
-                if (val1.x[i] != val2.x[i])
-                        return 0;
-        }
-
-        return 1;
-}
-
-static inline map_word map_word_and(struct map_info *map, map_word val1, map_word val2)
-{
-        map_word r;
-        int i;
-
-        for (i = 0; i < map_words(map); i++)
-                r.x[i] = val1.x[i] & val2.x[i];
-
-        return r;
-}
-
-static inline map_word map_word_clr(struct map_info *map, map_word val1, map_word val2)
-{
-        map_word r;
-        int i;
-
-        for (i = 0; i < map_words(map); i++)
-                r.x[i] = val1.x[i] & ~val2.x[i];
-
-        return r;
-}
-
-static inline map_word map_word_or(struct map_info *map, map_word val1, map_word val2)
-{
-        map_word r;
-        int i;
-
-        for (i = 0; i < map_words(map); i++)
-                r.x[i] = val1.x[i] | val2.x[i];
-
-        return r;
-}
-
-static inline int map_word_andequal(struct map_info *map, map_word val1, map_word val2, map_word val3)
-{
-        int i;
-
-        for (i = 0; i < map_words(map); i++) {
-                if ((val1.x[i] & val2.x[i]) != val3.x[i])
-                        return 0;
-        }
-
-        return 1;
-}
-
-static inline int map_word_bitsset(struct map_info *map, map_word val1, map_word val2)
-{
-        int i;
-
-        for (i = 0; i < map_words(map); i++) {
-                if (val1.x[i] & val2.x[i])
-                        return 1;
-        }
-
-        return 0;
-}
+#define map_word_equal(map, val1, val2)                                 \
+({                                                                      \
+        int i, ret = 1;                                                 \
+        for (i = 0; i < map_words(map); i++)                            \
+                if ((val1).x[i] != (val2).x[i]) {                       \
+                        ret = 0;                                        \
+                        break;                                          \
+                }                                                       \
+        ret;                                                            \
+})
+
+#define map_word_and(map, val1, val2)                                   \
+({                                                                      \
+        map_word r;                                                     \
+        int i;                                                          \
+        for (i = 0; i < map_words(map); i++)                            \
+                r.x[i] = (val1).x[i] & (val2).x[i];                     \
+        r;                                                              \
+})
+
+#define map_word_clr(map, val1, val2)                                   \
+({                                                                      \
+        map_word r;                                                     \
+        int i;                                                          \
+        for (i = 0; i < map_words(map); i++)                            \
+                r.x[i] = (val1).x[i] & ~(val2).x[i];                    \
+        r;                                                              \
+})
+
+#define map_word_or(map, val1, val2)                                    \
+({                                                                      \
+        map_word r;                                                     \
+        int i;                                                          \
+        for (i = 0; i < map_words(map); i++)                            \
+                r.x[i] = (val1).x[i] | (val2).x[i];                     \
+        r;                                                              \
+})
+
+#define map_word_andequal(map, val1, val2, val3)                        \
+({                                                                      \
+        int i, ret = 1;                                                 \
+        for (i = 0; i < map_words(map); i++) {                          \
+                if (((val1).x[i] & (val2).x[i]) != (val2).x[i]) {       \
+                        ret = 0;                                        \
+                        break;                                          \
+                }                                                       \
+        }                                                               \
+        ret;                                                            \
+})
+
+#define map_word_bitsset(map, val1, val2)                               \
+({                                                                      \
+        int i, ret = 0;                                                 \
+        for (i = 0; i < map_words(map); i++) {                          \
+                if ((val1).x[i] & (val2).x[i]) {                        \
+                        ret = 1;                                        \
+                        break;                                          \
+                }                                                       \
+        }                                                               \
+        ret;                                                            \
+})
 
 static inline map_word map_word_load(struct map_info *map, const void *ptr)
 {
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index cd55bf14ad51..205ededccc60 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -489,6 +489,34 @@ static inline uint32_t mtd_mod_by_eb(uint64_t sz, struct mtd_info *mtd)
         return do_div(sz, mtd->erasesize);
 }
 
+/**
+ * mtd_align_erase_req - Adjust an erase request to align things on eraseblock
+ *                       boundaries.
+ * @mtd: the MTD device this erase request applies on
+ * @req: the erase request to adjust
+ *
+ * This function will adjust @req->addr and @req->len to align them on
+ * @mtd->erasesize. Of course we expect @mtd->erasesize to be != 0.
+ */
+static inline void mtd_align_erase_req(struct mtd_info *mtd,
+                                       struct erase_info *req)
+{
+        u32 mod;
+
+        if (WARN_ON(!mtd->erasesize))
+                return;
+
+        mod = mtd_mod_by_eb(req->addr, mtd);
+        if (mod) {
+                req->addr -= mod;
+                req->len += mod;
+        }
+
+        mod = mtd_mod_by_eb(req->addr + req->len, mtd);
+        if (mod)
+                req->len += mtd->erasesize - mod;
+}
+
 static inline uint32_t mtd_div_by_ws(uint64_t sz, struct mtd_info *mtd)
 {
         if (mtd->writesize_shift)
diff --git a/include/linux/mtd/rawnand.h b/include/linux/mtd/rawnand.h
index 749bb08c4772..56c5570aadbe 100644
--- a/include/linux/mtd/rawnand.h
+++ b/include/linux/mtd/rawnand.h
@@ -133,12 +133,6 @@ enum nand_ecc_algo {
  */
 #define NAND_ECC_GENERIC_ERASED_CHECK   BIT(0)
 #define NAND_ECC_MAXIMIZE               BIT(1)
-/*
- * If your controller already sends the required NAND commands when
- * reading or writing a page, then the framework is not supposed to
- * send READ0 and SEQIN/PAGEPROG respectively.
- */
-#define NAND_ECC_CUSTOM_PAGE_ACCESS     BIT(2)
 
 /* Bit mask for flags passed to do_nand_read_ecc */
 #define NAND_GET_DEVICE         0x80
@@ -191,11 +185,6 @@ enum nand_ecc_algo {
 /* Non chip related options */
 /* This option skips the bbt scan during initialization. */
 #define NAND_SKIP_BBTSCAN       0x00010000
-/*
- * This option is defined if the board driver allocates its own buffers
- * (e.g. because it needs them DMA-coherent).
- */
-#define NAND_OWN_BUFFERS        0x00020000
 /* Chip may not exist, so silence any errors in scan */
 #define NAND_SCAN_SILENT_NODEV  0x00040000
 /*
@@ -525,6 +514,8 @@ static const struct nand_ecc_caps __name = {			\
  * @postpad:    padding information for syndrome based ECC generators
  * @options:    ECC specific options (see NAND_ECC_XXX flags defined above)
  * @priv:       pointer to private ECC control data
+ * @calc_buf:   buffer for calculated ECC, size is oobsize.
+ * @code_buf:   buffer for ECC read from flash, size is oobsize.
  * @hwctl:      function to control hardware ECC generator. Must only
  *              be provided if an hardware ECC is available
  * @calculate:  function for ECC calculation or readback from ECC hardware
@@ -575,6 +566,8 @@ struct nand_ecc_ctrl {
         int postpad;
         unsigned int options;
         void *priv;
+        u8 *calc_buf;
+        u8 *code_buf;
         void (*hwctl)(struct mtd_info *mtd, int mode);
         int (*calculate)(struct mtd_info *mtd, const uint8_t *dat,
                         uint8_t *ecc_code);
@@ -602,26 +595,6 @@ struct nand_ecc_ctrl {
                         int page);
 };
 
-static inline int nand_standard_page_accessors(struct nand_ecc_ctrl *ecc)
-{
-        return !(ecc->options & NAND_ECC_CUSTOM_PAGE_ACCESS);
-}
-
-/**
- * struct nand_buffers - buffer structure for read/write
- * @ecccalc:    buffer pointer for calculated ECC, size is oobsize.
- * @ecccode:    buffer pointer for ECC read from flash, size is oobsize.
- * @databuf:    buffer pointer for data, size is (page size + oobsize).
- *
- * Do not change the order of buffers. databuf and oobrbuf must be in
- * consecutive order.
- */
-struct nand_buffers {
-        uint8_t *ecccalc;
-        uint8_t *ecccode;
-        uint8_t *databuf;
-};
-
 /**
  * struct nand_sdr_timings - SDR NAND chip timings
  *
@@ -762,6 +735,350 @@ struct nand_manufacturer_ops {
 };
 
 /**
+ * struct nand_op_cmd_instr - Definition of a command instruction
+ * @opcode: the command to issue in one cycle
+ */
+struct nand_op_cmd_instr {
+        u8 opcode;
+};
+
+/**
+ * struct nand_op_addr_instr - Definition of an address instruction
+ * @naddrs: length of the @addrs array
+ * @addrs: array containing the address cycles to issue
+ */
+struct nand_op_addr_instr {
+        unsigned int naddrs;
+        const u8 *addrs;
+};
+
+/**
+ * struct nand_op_data_instr - Definition of a data instruction
+ * @len: number of data bytes to move
+ * @in: buffer to fill when reading from the NAND chip
+ * @out: buffer to read from when writing to the NAND chip
+ * @force_8bit: force 8-bit access
+ *
+ * Please note that "in" and "out" are inverted from the ONFI specification
+ * and are from the controller perspective, so a "in" is a read from the NAND
+ * chip while a "out" is a write to the NAND chip.
+ */
+struct nand_op_data_instr {
+        unsigned int len;
+        union {
+                void *in;
+                const void *out;
+        } buf;
+        bool force_8bit;
+};
+
+/**
+ * struct nand_op_waitrdy_instr - Definition of a wait ready instruction
+ * @timeout_ms: maximum delay while waiting for the ready/busy pin in ms
+ */
+struct nand_op_waitrdy_instr {
+        unsigned int timeout_ms;
+};
+
+/**
+ * enum nand_op_instr_type - Definition of all instruction types
+ * @NAND_OP_CMD_INSTR: command instruction
+ * @NAND_OP_ADDR_INSTR: address instruction
+ * @NAND_OP_DATA_IN_INSTR: data in instruction
+ * @NAND_OP_DATA_OUT_INSTR: data out instruction
+ * @NAND_OP_WAITRDY_INSTR: wait ready instruction
+ */
+enum nand_op_instr_type {
+        NAND_OP_CMD_INSTR,
+        NAND_OP_ADDR_INSTR,
+        NAND_OP_DATA_IN_INSTR,
+        NAND_OP_DATA_OUT_INSTR,
+        NAND_OP_WAITRDY_INSTR,
+};
+
+/**
+ * struct nand_op_instr - Instruction object
+ * @type: the instruction type
+ * @cmd/@addr/@data/@waitrdy: extra data associated to the instruction.
+ *                            You'll have to use the appropriate element
+ *                            depending on @type
+ * @delay_ns: delay the controller should apply after the instruction has been
+ *            issued on the bus. Most modern controllers have internal timings
+ *            control logic, and in this case, the controller driver can ignore
+ *            this field.
+ */
+struct nand_op_instr {
+        enum nand_op_instr_type type;
+        union {
+                struct nand_op_cmd_instr cmd;
+                struct nand_op_addr_instr addr;
+                struct nand_op_data_instr data;
+                struct nand_op_waitrdy_instr waitrdy;
+        } ctx;
+        unsigned int delay_ns;
+};
+
+/*
+ * Special handling must be done for the WAITRDY timeout parameter as it usually
+ * is either tPROG (after a prog), tR (before a read), tRST (during a reset) or
+ * tBERS (during an erase) which all of them are u64 values that cannot be
+ * divided by usual kernel macros and must be handled with the special
+ * DIV_ROUND_UP_ULL() macro.
+ */
+#define __DIVIDE(dividend, divisor) ({                                  \
+        sizeof(dividend) == sizeof(u32) ?                               \
+                DIV_ROUND_UP(dividend, divisor) :                       \
+                DIV_ROUND_UP_ULL(dividend, divisor);                    \
+                })
+#define PSEC_TO_NSEC(x) __DIVIDE(x, 1000)
+#define PSEC_TO_MSEC(x) __DIVIDE(x, 1000000000)
+
+#define NAND_OP_CMD(id, ns)                                             \
+        {                                                               \
+                .type = NAND_OP_CMD_INSTR,                              \
+                .ctx.cmd.opcode = id,                                   \
+                .delay_ns = ns,                                         \
+        }
+
+#define NAND_OP_ADDR(ncycles, cycles, ns)                               \
+        {                                                               \
+                .type = NAND_OP_ADDR_INSTR,                             \
+                .ctx.addr = {                                           \
+                        .naddrs = ncycles,                              \
+                        .addrs = cycles,                                \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+
+#define NAND_OP_DATA_IN(l, b, ns)                                       \
+        {                                                               \
+                .type = NAND_OP_DATA_IN_INSTR,                          \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.in = b,                                    \
+                        .force_8bit = false,                            \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+
+#define NAND_OP_DATA_OUT(l, b, ns)                                      \
+        {                                                               \
+                .type = NAND_OP_DATA_OUT_INSTR,                         \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.out = b,                                   \
+                        .force_8bit = false,                            \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+
+#define NAND_OP_8BIT_DATA_IN(l, b, ns)                                  \
+        {                                                               \
+                .type = NAND_OP_DATA_IN_INSTR,                          \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.in = b,                                    \
+                        .force_8bit = true,                             \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+
+#define NAND_OP_8BIT_DATA_OUT(l, b, ns)                                 \
+        {                                                               \
+                .type = NAND_OP_DATA_OUT_INSTR,                         \
+                .ctx.data = {                                           \
+                        .len = l,                                       \
+                        .buf.out = b,                                   \
+                        .force_8bit = true,                             \
+                },                                                      \
+                .delay_ns = ns,                                         \
+        }
+
+#define NAND_OP_WAIT_RDY(tout_ms, ns)                                   \
+        {                                                               \
+                .type = NAND_OP_WAITRDY_INSTR,                          \
+                .ctx.waitrdy.timeout_ms = tout_ms,                      \
+                .delay_ns = ns,                                         \
+        }
+
+/**
+ * struct nand_subop - a sub operation
+ * @instrs: array of instructions
+ * @ninstrs: length of the @instrs array
+ * @first_instr_start_off: offset to start from for the first instruction
+ *                         of the sub-operation
+ * @last_instr_end_off: offset to end at (excluded) for the last instruction
+ *                      of the sub-operation
+ *
+ * Both @first_instr_start_off and @last_instr_end_off only apply to data or
+ * address instructions.
+ *
+ * When an operation cannot be handled as is by the NAND controller, it will
+ * be split by the parser into sub-operations which will be passed to the
+ * controller driver.
+ */
+struct nand_subop {
+        const struct nand_op_instr *instrs;
+        unsigned int ninstrs;
+        unsigned int first_instr_start_off;
+        unsigned int last_instr_end_off;
+};
+
+int nand_subop_get_addr_start_off(const struct nand_subop *subop,
+                                  unsigned int op_id);
+int nand_subop_get_num_addr_cyc(const struct nand_subop *subop,
+                                unsigned int op_id);
+int nand_subop_get_data_start_off(const struct nand_subop *subop,
+                                  unsigned int op_id);
+int nand_subop_get_data_len(const struct nand_subop *subop,
+                            unsigned int op_id);
+
+/**
+ * struct nand_op_parser_addr_constraints - Constraints for address instructions
+ * @maxcycles: maximum number of address cycles the controller can issue in a
+ *             single step
+ */
+struct nand_op_parser_addr_constraints {
+        unsigned int maxcycles;
+};
+
+/**
+ * struct nand_op_parser_data_constraints - Constraints for data instructions
+ * @maxlen: maximum data length that the controller can handle in a single step
+ */
+struct nand_op_parser_data_constraints {
+        unsigned int maxlen;
+};
+
+/**
+ * struct nand_op_parser_pattern_elem - One element of a pattern
+ * @type: the instructuction type
+ * @optional: whether this element of the pattern is optional or mandatory
+ * @addr/@data: address or data constraint (number of cycles or data length)
+ */
+struct nand_op_parser_pattern_elem {
+        enum nand_op_instr_type type;
+        bool optional;
+        union {
+                struct nand_op_parser_addr_constraints addr;
+                struct nand_op_parser_data_constraints data;
+        } ctx;
+};
+
+#define NAND_OP_PARSER_PAT_CMD_ELEM(_opt)                       \
+        {                                                       \
+                .type = NAND_OP_CMD_INSTR,                      \
+                .optional = _opt,                               \
+        }
+
+#define NAND_OP_PARSER_PAT_ADDR_ELEM(_opt, _maxcycles)          \
+        {                                                       \
+                .type = NAND_OP_ADDR_INSTR,                     \
+                .optional = _opt,                               \
+                .ctx.addr.maxcycles = _maxcycles,               \
+        }
+
+#define NAND_OP_PARSER_PAT_DATA_IN_ELEM(_opt, _maxlen)          \
+        {                                                       \
+                .type = NAND_OP_DATA_IN_INSTR,                  \
+                .optional = _opt,                               \
+                .ctx.data.maxlen = _maxlen,                     \
+        }
+
+#define NAND_OP_PARSER_PAT_DATA_OUT_ELEM(_opt, _maxlen)         \
+        {                                                       \
+                .type = NAND_OP_DATA_OUT_INSTR,                 \
+                .optional = _opt,                               \
+                .ctx.data.maxlen = _maxlen,                     \
+        }
+
+#define NAND_OP_PARSER_PAT_WAITRDY_ELEM(_opt)                   \
+        {                                                       \
+                .type = NAND_OP_WAITRDY_INSTR,                  \
+                .optional = _opt,                               \
+        }
+
+/**
+ * struct nand_op_parser_pattern - NAND sub-operation pattern descriptor
+ * @elems: array of pattern elements
+ * @nelems: number of pattern elements in @elems array
+ * @exec: the function that will issue a sub-operation
+ *
+ * A pattern is a list of elements, each element reprensenting one instruction
+ * with its constraints. The pattern itself is used by the core to match NAND
+ * chip operation with NAND controller operations.
+ * Once a match between a NAND controller operation pattern and a NAND chip
+ * operation (or a sub-set of a NAND operation) is found, the pattern ->exec()
+ * hook is called so that the controller driver can issue the operation on the
+ * bus.
+ *
+ * Controller drivers should declare as many patterns as they support and pass
+ * this list of patterns (created with the help of the following macro) to
+ * the nand_op_parser_exec_op() helper.
+ */
+struct nand_op_parser_pattern {
+        const struct nand_op_parser_pattern_elem *elems;
+        unsigned int nelems;
+        int (*exec)(struct nand_chip *chip, const struct nand_subop *subop);
+};
+
+#define NAND_OP_PARSER_PATTERN(_exec, ...)                                                      \
+        {                                                                                       \
+                .exec = _exec,                                                                  \
+                .elems = (struct nand_op_parser_pattern_elem[]) { __VA_ARGS__ },                \
+                .nelems = sizeof((struct nand_op_parser_pattern_elem[]) { __VA_ARGS__ }) /      \
+                          sizeof(struct nand_op_parser_pattern_elem),                           \
+        }
+
+/**
+ * struct nand_op_parser - NAND controller operation parser descriptor
+ * @patterns: array of supported patterns
+ * @npatterns: length of the @patterns array
+ *
+ * The parser descriptor is just an array of supported patterns which will be
+ * iterated by nand_op_parser_exec_op() everytime it tries to execute an
+ * NAND operation (or tries to determine if a specific operation is supported).
+ *
+ * It is worth mentioning that patterns will be tested in their declaration
+ * order, and the first match will be taken, so it's important to order patterns
+ * appropriately so that simple/inefficient patterns are placed at the end of
+ * the list. Usually, this is where you put single instruction patterns.
+ */
+struct nand_op_parser {
+        const struct nand_op_parser_pattern *patterns;
+        unsigned int npatterns;
+};
+
+#define NAND_OP_PARSER(...)                                                                     \
+        {                                                                                       \
+                .patterns = (struct nand_op_parser_pattern[]) { __VA_ARGS__ },                  \
+                .npatterns = sizeof((struct nand_op_parser_pattern[]) { __VA_ARGS__ }) /        \
+                             sizeof(struct nand_op_parser_pattern),                             \
+        }
+
+/**
+ * struct nand_operation - NAND operation descriptor
+ * @instrs: array of instructions to execute
+ * @ninstrs: length of the @instrs array
+ *
+ * The actual operation structure that will be passed to chip->exec_op().
+ */
+struct nand_operation {
+        const struct nand_op_instr *instrs;
+        unsigned int ninstrs;
+};
+
+#define NAND_OPERATION(_instrs)                                 \
+        {                                                       \
+                .instrs = _instrs,                              \
+                .ninstrs = ARRAY_SIZE(_instrs),                 \
+        }
+
+int nand_op_parser_exec_op(struct nand_chip *chip,
+                           const struct nand_op_parser *parser,
+                           const struct nand_operation *op, bool check_only);
+
+/**
  * struct nand_chip - NAND Private Flash Chip Data
  * @mtd:                MTD device registered to the MTD framework
  * @IO_ADDR_R:          [BOARDSPECIFIC] address to read the 8 I/O lines of the
@@ -787,10 +1104,13 @@ struct nand_manufacturer_ops {
  *                      commands to the chip.
  * @waitfunc:           [REPLACEABLE] hardwarespecific function for wait on
  *                      ready.
+ * @exec_op:            controller specific method to execute NAND operations.
+ *                      This method replaces ->cmdfunc(),
+ *                      ->{read,write}_{buf,byte,word}(), ->dev_ready() and
+ *                      ->waifunc().
  * @setup_read_retry:   [FLASHSPECIFIC] flash (vendor) specific function for
  *                      setting the read-retry mode. Mostly needed for MLC NAND.
  * @ecc:                [BOARDSPECIFIC] ECC control structure
- * @buffers:            buffer structure for read/write
  * @buf_align:          minimum buffer alignment required by a platform
  * @hwcontrol:          platform-specific hardware control structure
  * @erase:              [REPLACEABLE] erase function
@@ -830,6 +1150,7 @@ struct nand_manufacturer_ops {
  * @numchips:           [INTERN] number of physical chips
  * @chipsize:           [INTERN] the size of one chip for multichip arrays
  * @pagemask:           [INTERN] page number mask = number of (pages / chip) - 1
+ * @data_buf:           [INTERN] buffer for data, size is (page size + oobsize).
  * @pagebuf:            [INTERN] holds the pagenumber which is currently in
  *                      data_buf.
  * @pagebuf_bitflips:   [INTERN] holds the bitflip count for the page which is
@@ -886,6 +1207,9 @@ struct nand_chip {
         void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column,
                         int page_addr);
         int(*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
+        int (*exec_op)(struct nand_chip *chip,
+                       const struct nand_operation *op,
+                       bool check_only);
         int (*erase)(struct mtd_info *mtd, int page);
         int (*scan_bbt)(struct mtd_info *mtd);
         int (*onfi_set_features)(struct mtd_info *mtd, struct nand_chip *chip,
@@ -896,7 +1220,6 @@ struct nand_chip {
         int (*setup_data_interface)(struct mtd_info *mtd, int chipnr,
                                     const struct nand_data_interface *conf);
 
-
         int chip_delay;
         unsigned int options;
         unsigned int bbt_options;
@@ -908,6 +1231,7 @@ struct nand_chip {
         int numchips;
         uint64_t chipsize;
         int pagemask;
+        u8 *data_buf;
         int pagebuf;
         unsigned int pagebuf_bitflips;
         int subpagesize;
@@ -928,7 +1252,7 @@ struct nand_chip {
         u16 max_bb_per_die;
         u32 blocks_per_die;
 
-        struct nand_data_interface *data_interface;
+        struct nand_data_interface data_interface;
 
         int read_retries;
 
@@ -938,7 +1262,6 @@ struct nand_chip {
         struct nand_hw_control *controller;
 
         struct nand_ecc_ctrl ecc;
-        struct nand_buffers *buffers;
         unsigned long buf_align;
         struct nand_hw_control hwcontrol;
 
@@ -956,6 +1279,15 @@ struct nand_chip {
         } manufacturer;
 };
 
+static inline int nand_exec_op(struct nand_chip *chip,
+                               const struct nand_operation *op)
+{
+        if (!chip->exec_op)
+                return -ENOTSUPP;
+
+        return chip->exec_op(chip, op, false);
+}
+
 extern const struct mtd_ooblayout_ops nand_ooblayout_sp_ops;
 extern const struct mtd_ooblayout_ops nand_ooblayout_lp_ops;
 
@@ -1225,8 +1557,7 @@ static inline int onfi_get_sync_timing_mode(struct nand_chip *chip)
         return le16_to_cpu(chip->onfi_params.src_sync_timing_mode);
 }
 
-int onfi_init_data_interface(struct nand_chip *chip,
-                             struct nand_data_interface *iface,
+int onfi_fill_data_interface(struct nand_chip *chip,
                              enum nand_data_interface_type type,
                              int timing_mode);
 
@@ -1269,8 +1600,6 @@ static inline int jedec_feature(struct nand_chip *chip)
 
 /* get timing characteristics from ONFI timing mode. */
 const struct nand_sdr_timings *onfi_async_timing_mode_to_sdr_timings(int mode);
-/* get data interface from ONFI timing mode 0, used after reset. */
-const struct nand_data_interface *nand_get_default_data_interface(void);
 
 int nand_check_erased_ecc_chunk(void *data, int datalen,
                                 void *ecc, int ecclen,
@@ -1316,9 +1645,45 @@ int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
 /* Reset and initialize a NAND device */
 int nand_reset(struct nand_chip *chip, int chipnr);
 
+/* NAND operation helpers */
+int nand_reset_op(struct nand_chip *chip);
+int nand_readid_op(struct nand_chip *chip, u8 addr, void *buf,
+                   unsigned int len);
+int nand_status_op(struct nand_chip *chip, u8 *status);
+int nand_exit_status_op(struct nand_chip *chip);
+int nand_erase_op(struct nand_chip *chip, unsigned int eraseblock);
+int nand_read_page_op(struct nand_chip *chip, unsigned int page,
+                      unsigned int offset_in_page, void *buf, unsigned int len);
+int nand_change_read_column_op(struct nand_chip *chip,
+                               unsigned int offset_in_page, void *buf,
+                               unsigned int len, bool force_8bit);
+int nand_read_oob_op(struct nand_chip *chip, unsigned int page,
+                     unsigned int offset_in_page, void *buf, unsigned int len);
+int nand_prog_page_begin_op(struct nand_chip *chip, unsigned int page,
+                            unsigned int offset_in_page, const void *buf,
+                            unsigned int len);
+int nand_prog_page_end_op(struct nand_chip *chip);
+int nand_prog_page_op(struct nand_chip *chip, unsigned int page,
+                      unsigned int offset_in_page, const void *buf,
+                      unsigned int len);
+int nand_change_write_column_op(struct nand_chip *chip,
+                                unsigned int offset_in_page, const void *buf,
+                                unsigned int len, bool force_8bit);
+int nand_read_data_op(struct nand_chip *chip, void *buf, unsigned int len,
+                      bool force_8bit);
+int nand_write_data_op(struct nand_chip *chip, const void *buf,
+                       unsigned int len, bool force_8bit);
+
 /* Free resources held by the NAND device */
 void nand_cleanup(struct nand_chip *chip);
 
 /* Default extended ID decoding function */
 void nand_decode_ext_id(struct nand_chip *chip);
+
+/*
+ * External helper for controller drivers that have to implement the WAITRDY
+ * instruction and have no physical pin to check it.
+ */
+int nand_soft_waitrdy(struct nand_chip *chip, unsigned long timeout_ms);
+
 #endif /* __LINUX_MTD_RAWNAND_H */
diff --git a/include/linux/mtd/spi-nor.h b/include/linux/mtd/spi-nor.h
index d0c66a0975cf..de36969eb359 100644
--- a/include/linux/mtd/spi-nor.h
+++ b/include/linux/mtd/spi-nor.h
@@ -61,6 +61,7 @@
 #define SPINOR_OP_RDSFDP        0x5a    /* Read SFDP */
 #define SPINOR_OP_RDCR          0x35    /* Read configuration register */
 #define SPINOR_OP_RDFSR         0x70    /* Read flag status register */
+#define SPINOR_OP_CLFSR         0x50    /* Clear flag status register */
 
 /* 4-byte address opcodes - used on Spansion and some Macronix flashes. */
 #define SPINOR_OP_READ_4B       0x13    /* Read data bytes (low frequency) */
@@ -130,7 +131,10 @@
 #define EVCR_QUAD_EN_MICRON     BIT(7)  /* Micron Quad I/O */
 
 /* Flag Status Register bits */
-#define FSR_READY               BIT(7)
+#define FSR_READY               BIT(7)  /* Device status, 0 = Busy, 1 = Ready */
+#define FSR_E_ERR               BIT(5)  /* Erase operation status */
+#define FSR_P_ERR               BIT(4)  /* Program operation status */
+#define FSR_PT_ERR              BIT(1)  /* Protection error bit */
 
 /* Configuration Register bits. */
 #define CR_QUAD_EN_SPAN         BIT(1)  /* Spansion Quad I/O */
@@ -399,4 +403,10 @@ struct spi_nor_hwcaps {
 int spi_nor_scan(struct spi_nor *nor, const char *name,
                  const struct spi_nor_hwcaps *hwcaps);
 
+/**
+ * spi_nor_restore_addr_mode() - restore the status of SPI NOR
+ * @nor:        the spi_nor structure
+ */
+void spi_nor_restore(struct spi_nor *nor);
+
 #endif
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index 153274f78402..f25c13423bd4 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -138,9 +138,9 @@ extern void __mutex_init(struct mutex *lock, const char *name,
  * mutex_is_locked - is the mutex locked
  * @lock: the mutex to be queried
  *
- * Returns 1 if the mutex is locked, 0 if unlocked.
+ * Returns true if the mutex is locked, false if unlocked.
  */
-static inline int mutex_is_locked(struct mutex *lock)
+static inline bool mutex_is_locked(struct mutex *lock)
 {
         /*
          * XXX think about spin_is_locked
diff --git a/include/linux/mux/consumer.h b/include/linux/mux/consumer.h
index ea96d4c82be7..5fc6bb2fefad 100644
--- a/include/linux/mux/consumer.h
+++ b/include/linux/mux/consumer.h
@@ -1,13 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * mux/consumer.h - definitions for the multiplexer consumer interface
  *
  * Copyright (C) 2017 Axentia Technologies AB
  *
  * Author: Peter Rosin <peda@axentia.se>
- *
- * 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_MUX_CONSUMER_H
diff --git a/include/linux/mux/driver.h b/include/linux/mux/driver.h
index 35c3579c3304..627a2c6bc02d 100644
--- a/include/linux/mux/driver.h
+++ b/include/linux/mux/driver.h
@@ -1,13 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * mux/driver.h - definitions for the multiplexer driver interface
  *
  * Copyright (C) 2017 Axentia Technologies AB
  *
  * Author: Peter Rosin <peda@axentia.se>
- *
- * 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_MUX_DRIVER_H
diff --git a/include/linux/net.h b/include/linux/net.h
index caeb159abda5..91216b16feb7 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -147,7 +147,7 @@ struct proto_ops {
         int             (*getname)   (struct socket *sock,
                                       struct sockaddr *addr,
                                       int *sockaddr_len, int peer);
-        unsigned int    (*poll)      (struct file *file, struct socket *sock,
+        __poll_t        (*poll)      (struct file *file, struct socket *sock,
                                       struct poll_table_struct *wait);
         int             (*ioctl)     (struct socket *sock, unsigned int cmd,
                                       unsigned long arg);
@@ -306,7 +306,6 @@ int kernel_sendpage(struct socket *sock, struct page *page, int offset,
                     size_t size, int flags);
 int kernel_sendpage_locked(struct sock *sk, struct page *page, int offset,
                            size_t size, int flags);
-int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg);
 int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how);
 
 /* Routine returns the IP overhead imposed by a (caller-protected) socket. */
diff --git a/include/linux/net_dim.h b/include/linux/net_dim.h
new file mode 100644
index 000000000000..bebeaad897cc
--- /dev/null
+++ b/include/linux/net_dim.h
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2016, Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2017-2018, Broadcom Limited. 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 NET_DIM_H
+#define NET_DIM_H
+
+#include <linux/module.h>
+
+struct net_dim_cq_moder {
+        u16 usec;
+        u16 pkts;
+        u8 cq_period_mode;
+};
+
+struct net_dim_sample {
+        ktime_t time;
+        u32     pkt_ctr;
+        u32     byte_ctr;
+        u16     event_ctr;
+};
+
+struct net_dim_stats {
+        int ppms; /* packets per msec */
+        int bpms; /* bytes per msec */
+        int epms; /* events per msec */
+};
+
+struct net_dim { /* Adaptive Moderation */
+        u8                                      state;
+        struct net_dim_stats                    prev_stats;
+        struct net_dim_sample                   start_sample;
+        struct work_struct                      work;
+        u8                                      profile_ix;
+        u8                                      mode;
+        u8                                      tune_state;
+        u8                                      steps_right;
+        u8                                      steps_left;
+        u8                                      tired;
+};
+
+enum {
+        NET_DIM_CQ_PERIOD_MODE_START_FROM_EQE = 0x0,
+        NET_DIM_CQ_PERIOD_MODE_START_FROM_CQE = 0x1,
+        NET_DIM_CQ_PERIOD_NUM_MODES
+};
+
+/* Adaptive moderation logic */
+enum {
+        NET_DIM_START_MEASURE,
+        NET_DIM_MEASURE_IN_PROGRESS,
+        NET_DIM_APPLY_NEW_PROFILE,
+};
+
+enum {
+        NET_DIM_PARKING_ON_TOP,
+        NET_DIM_PARKING_TIRED,
+        NET_DIM_GOING_RIGHT,
+        NET_DIM_GOING_LEFT,
+};
+
+enum {
+        NET_DIM_STATS_WORSE,
+        NET_DIM_STATS_SAME,
+        NET_DIM_STATS_BETTER,
+};
+
+enum {
+        NET_DIM_STEPPED,
+        NET_DIM_TOO_TIRED,
+        NET_DIM_ON_EDGE,
+};
+
+#define NET_DIM_PARAMS_NUM_PROFILES 5
+/* Adaptive moderation profiles */
+#define NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE 256
+#define NET_DIM_DEF_PROFILE_CQE 1
+#define NET_DIM_DEF_PROFILE_EQE 1
+
+/* All profiles sizes must be NET_PARAMS_DIM_NUM_PROFILES */
+#define NET_DIM_EQE_PROFILES { \
+        {1,   NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
+        {8,   NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
+        {64,  NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
+        {128, NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
+        {256, NET_DIM_DEFAULT_RX_CQ_MODERATION_PKTS_FROM_EQE}, \
+}
+
+#define NET_DIM_CQE_PROFILES { \
+        {2,  256},             \
+        {8,  128},             \
+        {16, 64},              \
+        {32, 64},              \
+        {64, 64}               \
+}
+
+static const struct net_dim_cq_moder
+profile[NET_DIM_CQ_PERIOD_NUM_MODES][NET_DIM_PARAMS_NUM_PROFILES] = {
+        NET_DIM_EQE_PROFILES,
+        NET_DIM_CQE_PROFILES,
+};
+
+static inline struct net_dim_cq_moder net_dim_get_profile(u8 cq_period_mode,
+                                                          int ix)
+{
+        struct net_dim_cq_moder cq_moder;
+
+        cq_moder = profile[cq_period_mode][ix];
+        cq_moder.cq_period_mode = cq_period_mode;
+        return cq_moder;
+}
+
+static inline struct net_dim_cq_moder net_dim_get_def_profile(u8 rx_cq_period_mode)
+{
+        int default_profile_ix;
+
+        if (rx_cq_period_mode == NET_DIM_CQ_PERIOD_MODE_START_FROM_CQE)
+                default_profile_ix = NET_DIM_DEF_PROFILE_CQE;
+        else /* NET_DIM_CQ_PERIOD_MODE_START_FROM_EQE */
+                default_profile_ix = NET_DIM_DEF_PROFILE_EQE;
+
+        return net_dim_get_profile(rx_cq_period_mode, default_profile_ix);
+}
+
+static inline bool net_dim_on_top(struct net_dim *dim)
+{
+        switch (dim->tune_state) {
+        case NET_DIM_PARKING_ON_TOP:
+        case NET_DIM_PARKING_TIRED:
+                return true;
+        case NET_DIM_GOING_RIGHT:
+                return (dim->steps_left > 1) && (dim->steps_right == 1);
+        default: /* NET_DIM_GOING_LEFT */
+                return (dim->steps_right > 1) && (dim->steps_left == 1);
+        }
+}
+
+static inline void net_dim_turn(struct net_dim *dim)
+{
+        switch (dim->tune_state) {
+        case NET_DIM_PARKING_ON_TOP:
+        case NET_DIM_PARKING_TIRED:
+                break;
+        case NET_DIM_GOING_RIGHT:
+                dim->tune_state = NET_DIM_GOING_LEFT;
+                dim->steps_left = 0;
+                break;
+        case NET_DIM_GOING_LEFT:
+                dim->tune_state = NET_DIM_GOING_RIGHT;
+                dim->steps_right = 0;
+                break;
+        }
+}
+
+static inline int net_dim_step(struct net_dim *dim)
+{
+        if (dim->tired == (NET_DIM_PARAMS_NUM_PROFILES * 2))
+                return NET_DIM_TOO_TIRED;
+
+        switch (dim->tune_state) {
+        case NET_DIM_PARKING_ON_TOP:
+        case NET_DIM_PARKING_TIRED:
+                break;
+        case NET_DIM_GOING_RIGHT:
+                if (dim->profile_ix == (NET_DIM_PARAMS_NUM_PROFILES - 1))
+                        return NET_DIM_ON_EDGE;
+                dim->profile_ix++;
+                dim->steps_right++;
+                break;
+        case NET_DIM_GOING_LEFT:
+                if (dim->profile_ix == 0)
+                        return NET_DIM_ON_EDGE;
+                dim->profile_ix--;
+                dim->steps_left++;
+                break;
+        }
+
+        dim->tired++;
+        return NET_DIM_STEPPED;
+}
+
+static inline void net_dim_park_on_top(struct net_dim *dim)
+{
+        dim->steps_right  = 0;
+        dim->steps_left   = 0;
+        dim->tired        = 0;
+        dim->tune_state   = NET_DIM_PARKING_ON_TOP;
+}
+
+static inline void net_dim_park_tired(struct net_dim *dim)
+{
+        dim->steps_right  = 0;
+        dim->steps_left   = 0;
+        dim->tune_state   = NET_DIM_PARKING_TIRED;
+}
+
+static inline void net_dim_exit_parking(struct net_dim *dim)
+{
+        dim->tune_state = dim->profile_ix ? NET_DIM_GOING_LEFT :
+                                          NET_DIM_GOING_RIGHT;
+        net_dim_step(dim);
+}
+
+#define IS_SIGNIFICANT_DIFF(val, ref) \
+        (((100 * abs((val) - (ref))) / (ref)) > 10) /* more than 10% difference */
+
+static inline int net_dim_stats_compare(struct net_dim_stats *curr,
+                                        struct net_dim_stats *prev)
+{
+        if (!prev->bpms)
+                return curr->bpms ? NET_DIM_STATS_BETTER :
+                                    NET_DIM_STATS_SAME;
+
+        if (IS_SIGNIFICANT_DIFF(curr->bpms, prev->bpms))
+                return (curr->bpms > prev->bpms) ? NET_DIM_STATS_BETTER :
+                                                   NET_DIM_STATS_WORSE;
+
+        if (!prev->ppms)
+                return curr->ppms ? NET_DIM_STATS_BETTER :
+                                    NET_DIM_STATS_SAME;
+
+        if (IS_SIGNIFICANT_DIFF(curr->ppms, prev->ppms))
+                return (curr->ppms > prev->ppms) ? NET_DIM_STATS_BETTER :
+                                                   NET_DIM_STATS_WORSE;
+
+        if (!prev->epms)
+                return NET_DIM_STATS_SAME;
+
+        if (IS_SIGNIFICANT_DIFF(curr->epms, prev->epms))
+                return (curr->epms < prev->epms) ? NET_DIM_STATS_BETTER :
+                                                   NET_DIM_STATS_WORSE;
+
+        return NET_DIM_STATS_SAME;
+}
+
+static inline bool net_dim_decision(struct net_dim_stats *curr_stats,
+                                    struct net_dim *dim)
+{
+        int prev_state = dim->tune_state;
+        int prev_ix = dim->profile_ix;
+        int stats_res;
+        int step_res;
+
+        switch (dim->tune_state) {
+        case NET_DIM_PARKING_ON_TOP:
+                stats_res = net_dim_stats_compare(curr_stats, &dim->prev_stats);
+                if (stats_res != NET_DIM_STATS_SAME)
+                        net_dim_exit_parking(dim);
+                break;
+
+        case NET_DIM_PARKING_TIRED:
+                dim->tired--;
+                if (!dim->tired)
+                        net_dim_exit_parking(dim);
+                break;
+
+        case NET_DIM_GOING_RIGHT:
+        case NET_DIM_GOING_LEFT:
+                stats_res = net_dim_stats_compare(curr_stats, &dim->prev_stats);
+                if (stats_res != NET_DIM_STATS_BETTER)
+                        net_dim_turn(dim);
+
+                if (net_dim_on_top(dim)) {
+                        net_dim_park_on_top(dim);
+                        break;
+                }
+
+                step_res = net_dim_step(dim);
+                switch (step_res) {
+                case NET_DIM_ON_EDGE:
+                        net_dim_park_on_top(dim);
+                        break;
+                case NET_DIM_TOO_TIRED:
+                        net_dim_park_tired(dim);
+                        break;
+                }
+
+                break;
+        }
+
+        if ((prev_state      != NET_DIM_PARKING_ON_TOP) ||
+            (dim->tune_state != NET_DIM_PARKING_ON_TOP))
+                dim->prev_stats = *curr_stats;
+
+        return dim->profile_ix != prev_ix;
+}
+
+static inline void net_dim_sample(u16 event_ctr,
+                                  u64 packets,
+                                  u64 bytes,
+                                  struct net_dim_sample *s)
+{
+        s->time      = ktime_get();
+        s->pkt_ctr   = packets;
+        s->byte_ctr  = bytes;
+        s->event_ctr = event_ctr;
+}
+
+#define NET_DIM_NEVENTS 64
+#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)
+#define BIT_GAP(bits, end, start) ((((end) - (start)) + BIT_ULL(bits)) & (BIT_ULL(bits) - 1))
+
+static inline void net_dim_calc_stats(struct net_dim_sample *start,
+                                      struct net_dim_sample *end,
+                                      struct net_dim_stats *curr_stats)
+{
+        /* u32 holds up to 71 minutes, should be enough */
+        u32 delta_us = ktime_us_delta(end->time, start->time);
+        u32 npkts = BIT_GAP(BITS_PER_TYPE(u32), end->pkt_ctr, start->pkt_ctr);
+        u32 nbytes = BIT_GAP(BITS_PER_TYPE(u32), end->byte_ctr,
+                             start->byte_ctr);
+
+        if (!delta_us)
+                return;
+
+        curr_stats->ppms = DIV_ROUND_UP(npkts * USEC_PER_MSEC, delta_us);
+        curr_stats->bpms = DIV_ROUND_UP(nbytes * USEC_PER_MSEC, delta_us);
+        curr_stats->epms = DIV_ROUND_UP(NET_DIM_NEVENTS * USEC_PER_MSEC,
+                                        delta_us);
+}
+
+static inline void net_dim(struct net_dim *dim,
+                           struct net_dim_sample end_sample)
+{
+        struct net_dim_stats curr_stats;
+        u16 nevents;
+
+        switch (dim->state) {
+        case NET_DIM_MEASURE_IN_PROGRESS:
+                nevents = BIT_GAP(BITS_PER_TYPE(u16),
+                                  end_sample.event_ctr,
+                                  dim->start_sample.event_ctr);
+                if (nevents < NET_DIM_NEVENTS)
+                        break;
+                net_dim_calc_stats(&dim->start_sample, &end_sample,
+                                   &curr_stats);
+                if (net_dim_decision(&curr_stats, dim)) {
+                        dim->state = NET_DIM_APPLY_NEW_PROFILE;
+                        schedule_work(&dim->work);
+                        break;
+                }
+                /* fall through */
+        case NET_DIM_START_MEASURE:
+                dim->state = NET_DIM_MEASURE_IN_PROGRESS;
+                break;
+        case NET_DIM_APPLY_NEW_PROFILE:
+                break;
+        }
+}
+
+#endif /* NET_DIM_H */
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index b1b0ca7ccb2b..db84c516bcfb 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -78,6 +78,8 @@ enum {
         NETIF_F_HW_ESP_TX_CSUM_BIT,     /* ESP with TX checksum offload */
         NETIF_F_RX_UDP_TUNNEL_PORT_BIT, /* Offload of RX port for UDP tunnels */
 
+        NETIF_F_GRO_HW_BIT,             /* Hardware Generic receive offload */
+
         /*
          * Add your fresh new feature above and remember to update
          * netdev_features_strings[] in net/core/ethtool.c and maybe
@@ -97,6 +99,7 @@ enum {
 #define NETIF_F_FRAGLIST        __NETIF_F(FRAGLIST)
 #define NETIF_F_FSO             __NETIF_F(FSO)
 #define NETIF_F_GRO             __NETIF_F(GRO)
+#define NETIF_F_GRO_HW          __NETIF_F(GRO_HW)
 #define NETIF_F_GSO             __NETIF_F(GSO)
 #define NETIF_F_GSO_ROBUST      __NETIF_F(GSO_ROBUST)
 #define NETIF_F_HIGHDMA         __NETIF_F(HIGHDMA)
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index ef789e1d679e..5eef6c8e2741 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -44,6 +44,7 @@
 #include <net/dcbnl.h>
 #endif
 #include <net/netprio_cgroup.h>
+#include <net/xdp.h>
 
 #include <linux/netdev_features.h>
 #include <linux/neighbour.h>
@@ -686,6 +687,7 @@ struct netdev_rx_queue {
 #endif
         struct kobject                  kobj;
         struct net_device               *dev;
+        struct xdp_rxq_info             xdp_rxq;
 } ____cacheline_aligned_in_smp;
 
 /*
@@ -778,6 +780,7 @@ enum tc_setup_type {
         TC_SETUP_BLOCK,
         TC_SETUP_QDISC_CBS,
         TC_SETUP_QDISC_RED,
+        TC_SETUP_QDISC_PRIO,
 };
 
 /* These structures hold the attributes of bpf state that are being passed
@@ -802,9 +805,11 @@ enum bpf_netdev_command {
         BPF_OFFLOAD_VERIFIER_PREP,
         BPF_OFFLOAD_TRANSLATE,
         BPF_OFFLOAD_DESTROY,
+        BPF_OFFLOAD_MAP_ALLOC,
+        BPF_OFFLOAD_MAP_FREE,
 };
 
-struct bpf_ext_analyzer_ops;
+struct bpf_prog_offload_ops;
 struct netlink_ext_ack;
 
 struct netdev_bpf {
@@ -820,16 +825,22 @@ struct netdev_bpf {
                 struct {
                         u8 prog_attached;
                         u32 prog_id;
+                        /* flags with which program was installed */
+                        u32 prog_flags;
                 };
                 /* BPF_OFFLOAD_VERIFIER_PREP */
                 struct {
                         struct bpf_prog *prog;
-                        const struct bpf_ext_analyzer_ops *ops; /* callee set */
+                        const struct bpf_prog_offload_ops *ops; /* callee set */
                 } verifier;
                 /* BPF_OFFLOAD_TRANSLATE, BPF_OFFLOAD_DESTROY */
                 struct {
                         struct bpf_prog *prog;
                 } offload;
+                /* BPF_OFFLOAD_MAP_ALLOC, BPF_OFFLOAD_MAP_FREE */
+                struct {
+                        struct bpf_offloaded_map *offmap;
+                };
         };
 };
 
@@ -840,6 +851,7 @@ struct xfrmdev_ops {
         void    (*xdo_dev_state_free) (struct xfrm_state *x);
         bool    (*xdo_dev_offload_ok) (struct sk_buff *skb,
                                        struct xfrm_state *x);
+        void    (*xdo_dev_state_advance_esn) (struct xfrm_state *x);
 };
 #endif
 
@@ -1458,8 +1470,6 @@ enum netdev_priv_flags {
  *      @base_addr:     Device I/O address
  *      @irq:           Device IRQ number
  *
- *      @carrier_changes:       Stats to monitor carrier on<->off transitions
- *
  *      @state:         Generic network queuing layer state, see netdev_state_t
  *      @dev_list:      The global list of network devices
  *      @napi_list:     List entry used for polling NAPI devices
@@ -1495,6 +1505,8 @@ enum netdev_priv_flags {
  *                      do not use this in drivers
  *      @rx_nohandler:  nohandler dropped packets by core network on
  *                      inactive devices, do not use this in drivers
+ *      @carrier_up_count:      Number of times the carrier has been up
+ *      @carrier_down_count:    Number of times the carrier has been down
  *
  *      @wireless_handlers:     List of functions to handle Wireless Extensions,
  *                              instead of ioctl,
@@ -1669,8 +1681,6 @@ struct net_device {
         unsigned long           base_addr;
         int                     irq;
 
-        atomic_t                carrier_changes;
-
         /*
          *      Some hardware also needs these fields (state,dev_list,
          *      napi_list,unreg_list,close_list) but they are not
@@ -1708,6 +1718,10 @@ struct net_device {
         atomic_long_t           tx_dropped;
         atomic_long_t           rx_nohandler;
 
+        /* Stats to monitor link on/off, flapping */
+        atomic_t                carrier_up_count;
+        atomic_t                carrier_down_count;
+
 #ifdef CONFIG_WIRELESS_EXT
         const struct iw_handler_def *wireless_handlers;
         struct iw_public_data   *wireless_data;
@@ -1724,7 +1738,7 @@ struct net_device {
         const struct ndisc_ops *ndisc_ops;
 #endif
 
-#ifdef CONFIG_XFRM
+#ifdef CONFIG_XFRM_OFFLOAD
         const struct xfrmdev_ops *xfrmdev_ops;
 #endif
 
@@ -1801,12 +1815,9 @@ struct net_device {
         /* Interface address info used in eth_type_trans() */
         unsigned char           *dev_addr;
 
-#ifdef CONFIG_SYSFS
         struct netdev_rx_queue  *_rx;
-
         unsigned int            num_rx_queues;
         unsigned int            real_num_rx_queues;
-#endif
 
         struct bpf_prog __rcu   *xdp_prog;
         unsigned long           gro_flush_timeout;
@@ -2751,7 +2762,8 @@ static inline bool dev_validate_header(const struct net_device *dev,
         return false;
 }
 
-typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
+typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr,
+                           int len, int size);
 int register_gifconf(unsigned int family, gifconf_func_t *gifconf);
 static inline int unregister_gifconf(unsigned int family)
 {
@@ -2791,7 +2803,9 @@ struct softnet_data {
         struct Qdisc            *output_queue;
         struct Qdisc            **output_queue_tailp;
         struct sk_buff          *completion_queue;
-
+#ifdef CONFIG_XFRM_OFFLOAD
+        struct sk_buff_head     xfrm_backlog;
+#endif
 #ifdef CONFIG_RPS
         /* input_queue_head should be written by cpu owning this struct,
          * and only read by other cpus. Worth using a cache line.
@@ -3214,6 +3228,12 @@ static inline int netif_set_real_num_rx_queues(struct net_device *dev,
 }
 #endif
 
+static inline struct netdev_rx_queue *
+__netif_get_rx_queue(struct net_device *dev, unsigned int rxq)
+{
+        return dev->_rx + rxq;
+}
+
 #ifdef CONFIG_SYSFS
 static inline unsigned int get_netdev_rx_queue_index(
                 struct netdev_rx_queue *queue)
@@ -3302,7 +3322,9 @@ int netdev_rx_handler_register(struct net_device *dev,
 void netdev_rx_handler_unregister(struct net_device *dev);
 
 bool dev_valid_name(const char *name);
-int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
+int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr,
+                bool *need_copyout);
+int dev_ifconf(struct net *net, struct ifconf *, int);
 int dev_ethtool(struct net *net, struct ifreq *);
 unsigned int dev_get_flags(const struct net_device *);
 int __dev_change_flags(struct net_device *, unsigned int flags);
@@ -3315,6 +3337,7 @@ int dev_get_alias(const struct net_device *, char *, size_t);
 int dev_change_net_namespace(struct net_device *, struct net *, const char *);
 int __dev_set_mtu(struct net_device *, int);
 int dev_set_mtu(struct net_device *, int);
+int dev_change_tx_queue_len(struct net_device *, unsigned long);
 void dev_set_group(struct net_device *, int);
 int dev_set_mac_address(struct net_device *, struct sockaddr *);
 int dev_change_carrier(struct net_device *, bool new_carrier);
@@ -3323,14 +3346,15 @@ int dev_get_phys_port_id(struct net_device *dev,
 int dev_get_phys_port_name(struct net_device *dev,
                            char *name, size_t len);
 int dev_change_proto_down(struct net_device *dev, bool proto_down);
-struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev);
+struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev, bool *again);
 struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                                     struct netdev_queue *txq, int *ret);
 
 typedef int (*bpf_op_t)(struct net_device *dev, struct netdev_bpf *bpf);
 int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack,
                       int fd, u32 flags);
-u8 __dev_xdp_attached(struct net_device *dev, bpf_op_t xdp_op, u32 *prog_id);
+void __dev_xdp_query(struct net_device *dev, bpf_op_t xdp_op,
+                     struct netdev_bpf *xdp);
 
 int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
@@ -4399,11 +4423,11 @@ do {								\
  * file/line information and a backtrace.
  */
 #define netdev_WARN(dev, format, args...)                       \
-        WARN(1, "netdevice: %s%s\n" format, netdev_name(dev),   \
+        WARN(1, "netdevice: %s%s: " format, netdev_name(dev),   \
              netdev_reg_state(dev), ##args)
 
-#define netdev_WARN_ONCE(dev, condition, format, arg...)                \
-        WARN_ONCE(1, "netdevice: %s%s\n" format, netdev_name(dev)       \
+#define netdev_WARN_ONCE(dev, format, args...)                          \
+        WARN_ONCE(1, "netdevice: %s%s: " format, netdev_name(dev),      \
                   netdev_reg_state(dev), ##args)
 
 /* netif printk helpers, similar to netdev_printk */
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index b24e9b101651..85a1a0b32c66 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -67,6 +67,7 @@ struct nf_hook_ops {
         struct net_device       *dev;
         void                    *priv;
         u_int8_t                pf;
+        bool                    nat_hook;
         unsigned int            hooknum;
         /* Hooks are ordered in ascending priority. */
         int                     priority;
@@ -77,17 +78,28 @@ struct nf_hook_entry {
         void                            *priv;
 };
 
+struct nf_hook_entries_rcu_head {
+        struct rcu_head head;
+        void    *allocation;
+};
+
 struct nf_hook_entries {
         u16                             num_hook_entries;
         /* padding */
         struct nf_hook_entry            hooks[];
 
-        /* trailer: pointers to original orig_ops of each hook.
-         *
-         * This is not part of struct nf_hook_entry since its only
-         * needed in slow path (hook register/unregister).
+        /* trailer: pointers to original orig_ops of each hook,
+         * followed by rcu_head and scratch space used for freeing
+         * the structure via call_rcu.
          *
+         *   This is not part of struct nf_hook_entry since its only
+         *   needed in slow path (hook register/unregister):
          * const struct nf_hook_ops     *orig_ops[]
+         *
+         *   For the same reason, we store this at end -- its
+         *   only needed when a hook is deleted, not during
+         *   packet path processing:
+         * struct nf_hook_entries_rcu_head     head
          */
 };
 
@@ -184,7 +196,7 @@ static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
                           struct net_device *indev, struct net_device *outdev,
                           int (*okfn)(struct net *, struct sock *, struct sk_buff *))
 {
-        struct nf_hook_entries *hook_head;
+        struct nf_hook_entries *hook_head = NULL;
         int ret = 1;
 
 #ifdef HAVE_JUMP_LABEL
@@ -195,7 +207,33 @@ static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
 #endif
 
         rcu_read_lock();
-        hook_head = rcu_dereference(net->nf.hooks[pf][hook]);
+        switch (pf) {
+        case NFPROTO_IPV4:
+                hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]);
+                break;
+        case NFPROTO_IPV6:
+                hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]);
+                break;
+        case NFPROTO_ARP:
+#ifdef CONFIG_NETFILTER_FAMILY_ARP
+                hook_head = rcu_dereference(net->nf.hooks_arp[hook]);
+#endif
+                break;
+        case NFPROTO_BRIDGE:
+#ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
+                hook_head = rcu_dereference(net->nf.hooks_bridge[hook]);
+#endif
+                break;
+#if IS_ENABLED(CONFIG_DECNET)
+        case NFPROTO_DECNET:
+                hook_head = rcu_dereference(net->nf.hooks_decnet[hook]);
+                break;
+#endif
+        default:
+                WARN_ON_ONCE(1);
+                break;
+        }
+
         if (hook_head) {
                 struct nf_hook_state state;
 
@@ -271,64 +309,16 @@ int skb_make_writable(struct sk_buff *skb, unsigned int writable_len);
 struct flowi;
 struct nf_queue_entry;
 
-struct nf_afinfo {
-        unsigned short  family;
-        __sum16         (*checksum)(struct sk_buff *skb, unsigned int hook,
-                                    unsigned int dataoff, u_int8_t protocol);
-        __sum16         (*checksum_partial)(struct sk_buff *skb,
-                                            unsigned int hook,
-                                            unsigned int dataoff,
-                                            unsigned int len,
-                                            u_int8_t protocol);
-        int             (*route)(struct net *net, struct dst_entry **dst,
-                                 struct flowi *fl, bool strict);
-        void            (*saveroute)(const struct sk_buff *skb,
-                                     struct nf_queue_entry *entry);
-        int             (*reroute)(struct net *net, struct sk_buff *skb,
-                                   const struct nf_queue_entry *entry);
-        int             route_key_size;
-};
-
-extern const struct nf_afinfo __rcu *nf_afinfo[NFPROTO_NUMPROTO];
-static inline const struct nf_afinfo *nf_get_afinfo(unsigned short family)
-{
-        return rcu_dereference(nf_afinfo[family]);
-}
-
-static inline __sum16
-nf_checksum(struct sk_buff *skb, unsigned int hook, unsigned int dataoff,
-            u_int8_t protocol, unsigned short family)
-{
-        const struct nf_afinfo *afinfo;
-        __sum16 csum = 0;
-
-        rcu_read_lock();
-        afinfo = nf_get_afinfo(family);
-        if (afinfo)
-                csum = afinfo->checksum(skb, hook, dataoff, protocol);
-        rcu_read_unlock();
-        return csum;
-}
-
-static inline __sum16
-nf_checksum_partial(struct sk_buff *skb, unsigned int hook,
-                    unsigned int dataoff, unsigned int len,
-                    u_int8_t protocol, unsigned short family)
-{
-        const struct nf_afinfo *afinfo;
-        __sum16 csum = 0;
-
-        rcu_read_lock();
-        afinfo = nf_get_afinfo(family);
-        if (afinfo)
-                csum = afinfo->checksum_partial(skb, hook, dataoff, len,
-                                                protocol);
-        rcu_read_unlock();
-        return csum;
-}
+__sum16 nf_checksum(struct sk_buff *skb, unsigned int hook,
+                    unsigned int dataoff, u_int8_t protocol,
+                    unsigned short family);
 
-int nf_register_afinfo(const struct nf_afinfo *afinfo);
-void nf_unregister_afinfo(const struct nf_afinfo *afinfo);
+__sum16 nf_checksum_partial(struct sk_buff *skb, unsigned int hook,
+                            unsigned int dataoff, unsigned int len,
+                            u_int8_t protocol, unsigned short family);
+int nf_route(struct net *net, struct dst_entry **dst, struct flowi *fl,
+             bool strict, unsigned short family);
+int nf_reroute(struct sk_buff *skb, struct nf_queue_entry *entry);
 
 #include <net/flow.h>
 extern void (*nf_nat_decode_session_hook)(struct sk_buff *, struct flowi *);
diff --git a/include/linux/netfilter/ipset/ip_set.h b/include/linux/netfilter/ipset/ip_set.h
index 8e42253e5d4d..34fc80f3eb90 100644
--- a/include/linux/netfilter/ipset/ip_set.h
+++ b/include/linux/netfilter/ipset/ip_set.h
@@ -122,6 +122,8 @@ struct ip_set_ext {
         u64 bytes;
         char *comment;
         u32 timeout;
+        u8 packets_op;
+        u8 bytes_op;
 };
 
 struct ip_set;
@@ -339,6 +341,10 @@ extern int ip_set_get_extensions(struct ip_set *set, struct nlattr *tb[],
                                  struct ip_set_ext *ext);
 extern int ip_set_put_extensions(struct sk_buff *skb, const struct ip_set *set,
                                  const void *e, bool active);
+extern bool ip_set_match_extensions(struct ip_set *set,
+                                    const struct ip_set_ext *ext,
+                                    struct ip_set_ext *mext,
+                                    u32 flags, void *data);
 
 static inline int
 ip_set_get_hostipaddr4(struct nlattr *nla, u32 *ipaddr)
diff --git a/include/linux/netfilter/ipset/ip_set_counter.h b/include/linux/netfilter/ipset/ip_set_counter.h
index bb6fba480118..3d33a2c3f39f 100644
--- a/include/linux/netfilter/ipset/ip_set_counter.h
+++ b/include/linux/netfilter/ipset/ip_set_counter.h
@@ -34,20 +34,33 @@ ip_set_get_packets(const struct ip_set_counter *counter)
         return (u64)atomic64_read(&(counter)->packets);
 }
 
+static inline bool
+ip_set_match_counter(u64 counter, u64 match, u8 op)
+{
+        switch (op) {
+        case IPSET_COUNTER_NONE:
+                return true;
+        case IPSET_COUNTER_EQ:
+                return counter == match;
+        case IPSET_COUNTER_NE:
+                return counter != match;
+        case IPSET_COUNTER_LT:
+                return counter < match;
+        case IPSET_COUNTER_GT:
+                return counter > match;
+        }
+        return false;
+}
+
 static inline void
 ip_set_update_counter(struct ip_set_counter *counter,
-                      const struct ip_set_ext *ext,
-                      struct ip_set_ext *mext, u32 flags)
+                      const struct ip_set_ext *ext, u32 flags)
 {
         if (ext->packets != ULLONG_MAX &&
             !(flags & IPSET_FLAG_SKIP_COUNTER_UPDATE)) {
                 ip_set_add_bytes(ext->bytes, counter);
                 ip_set_add_packets(ext->packets, counter);
         }
-        if (flags & IPSET_FLAG_MATCH_COUNTERS) {
-                mext->packets = ip_set_get_packets(counter);
-                mext->bytes = ip_set_get_bytes(counter);
-        }
 }
 
 static inline bool
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 495ba4dd9da5..34551f8aaf9d 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -67,8 +67,7 @@ static inline bool lockdep_nfnl_is_held(__u8 subsys_id)
  * @ss: The nfnetlink subsystem ID
  *
  * Return the value of the specified RCU-protected pointer, but omit
- * both the smp_read_barrier_depends() and the READ_ONCE(), because
- * caller holds the NFNL subsystem mutex.
+ * the READ_ONCE(), because caller holds the NFNL subsystem mutex.
  */
 #define nfnl_dereference(p, ss)                                 \
         rcu_dereference_protected(p, lockdep_nfnl_is_held(ss))
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index 33f7530f96b9..1313b35c3ab7 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -320,6 +320,8 @@ int xt_find_revision(u8 af, const char *name, u8 revision, int target,
 
 struct xt_table *xt_find_table_lock(struct net *net, u_int8_t af,
                                     const char *name);
+struct xt_table *xt_request_find_table_lock(struct net *net, u_int8_t af,
+                                            const char *name);
 void xt_table_unlock(struct xt_table *t);
 
 int xt_proto_init(struct net *net, u_int8_t af);
diff --git a/include/linux/netfilter_defs.h b/include/linux/netfilter_defs.h
index dc6111adea06..8dddfb151f00 100644
--- a/include/linux/netfilter_defs.h
+++ b/include/linux/netfilter_defs.h
@@ -4,7 +4,17 @@
 
 #include <uapi/linux/netfilter.h>
 
+/* in/out/forward only */
+#define NF_ARP_NUMHOOKS 3
+
+/* max hook is NF_DN_ROUTE (6), also see uapi/linux/netfilter_decnet.h */
+#define NF_DN_NUMHOOKS 7
+
+#if IS_ENABLED(CONFIG_DECNET)
 /* Largest hook number + 1, see uapi/linux/netfilter_decnet.h */
-#define NF_MAX_HOOKS 8
+#define NF_MAX_HOOKS    NF_DN_NUMHOOKS
+#else
+#define NF_MAX_HOOKS    NF_INET_NUMHOOKS
+#endif
 
 #endif
diff --git a/include/linux/netfilter_ipv4.h b/include/linux/netfilter_ipv4.h
index 98c03b2462b5..b31dabfdb453 100644
--- a/include/linux/netfilter_ipv4.h
+++ b/include/linux/netfilter_ipv4.h
@@ -6,7 +6,53 @@
 
 #include <uapi/linux/netfilter_ipv4.h>
 
+/* Extra routing may needed on local out, as the QUEUE target never returns
+ * control to the table.
+ */
+struct ip_rt_info {
+        __be32 daddr;
+        __be32 saddr;
+        u_int8_t tos;
+        u_int32_t mark;
+};
+
 int ip_route_me_harder(struct net *net, struct sk_buff *skb, unsigned addr_type);
+
+struct nf_queue_entry;
+
+#ifdef CONFIG_INET
 __sum16 nf_ip_checksum(struct sk_buff *skb, unsigned int hook,
                        unsigned int dataoff, u_int8_t protocol);
+__sum16 nf_ip_checksum_partial(struct sk_buff *skb, unsigned int hook,
+                               unsigned int dataoff, unsigned int len,
+                               u_int8_t protocol);
+int nf_ip_route(struct net *net, struct dst_entry **dst, struct flowi *fl,
+                bool strict);
+int nf_ip_reroute(struct sk_buff *skb, const struct nf_queue_entry *entry);
+#else
+static inline __sum16 nf_ip_checksum(struct sk_buff *skb, unsigned int hook,
+                                     unsigned int dataoff, u_int8_t protocol)
+{
+        return 0;
+}
+static inline __sum16 nf_ip_checksum_partial(struct sk_buff *skb,
+                                             unsigned int hook,
+                                             unsigned int dataoff,
+                                             unsigned int len,
+                                             u_int8_t protocol)
+{
+        return 0;
+}
+static inline int nf_ip_route(struct net *net, struct dst_entry **dst,
+                              struct flowi *fl, bool strict)
+{
+        return -EOPNOTSUPP;
+}
+static inline int nf_ip_reroute(struct sk_buff *skb,
+                                const struct nf_queue_entry *entry)
+{
+        return -EOPNOTSUPP;
+}
+#endif /* CONFIG_INET */
+
 #endif /*__LINUX_IP_NETFILTER_H*/
diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h
index 47c6b04c28c0..288c597e75b3 100644
--- a/include/linux/netfilter_ipv6.h
+++ b/include/linux/netfilter_ipv6.h
@@ -9,6 +9,17 @@
 
 #include <uapi/linux/netfilter_ipv6.h>
 
+/* Extra routing may needed on local out, as the QUEUE target never returns
+ * control to the table.
+ */
+struct ip6_rt_info {
+        struct in6_addr daddr;
+        struct in6_addr saddr;
+        u_int32_t mark;
+};
+
+struct nf_queue_entry;
+
 /*
  * Hook functions for ipv6 to allow xt_* modules to be built-in even
  * if IPv6 is a module.
@@ -19,6 +30,14 @@ struct nf_ipv6_ops {
         void (*route_input)(struct sk_buff *skb);
         int (*fragment)(struct net *net, struct sock *sk, struct sk_buff *skb,
                         int (*output)(struct net *, struct sock *, struct sk_buff *));
+        __sum16 (*checksum)(struct sk_buff *skb, unsigned int hook,
+                            unsigned int dataoff, u_int8_t protocol);
+        __sum16 (*checksum_partial)(struct sk_buff *skb, unsigned int hook,
+                                    unsigned int dataoff, unsigned int len,
+                                    u_int8_t protocol);
+        int (*route)(struct net *net, struct dst_entry **dst, struct flowi *fl,
+                     bool strict);
+        int (*reroute)(struct sk_buff *skb, const struct nf_queue_entry *entry);
 };
 
 #ifdef CONFIG_NETFILTER
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 47adac640191..57ffaa20d564 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -457,7 +457,12 @@ enum lock_type4 {
 
 #define NFS4_DEBUG 1
 
-/* Index of predefined Linux client operations */
+/*
+ * Index of predefined Linux client operations
+ *
+ * To ensure that /proc/net/rpc/nfs remains correctly ordered, please
+ * append only to this enum when adding new client operations.
+ */
 
 enum {
         NFSPROC4_CLNT_NULL = 0,         /* Unused */
@@ -480,7 +485,6 @@ enum {
         NFSPROC4_CLNT_ACCESS,
         NFSPROC4_CLNT_GETATTR,
         NFSPROC4_CLNT_LOOKUP,
-        NFSPROC4_CLNT_LOOKUPP,
         NFSPROC4_CLNT_LOOKUP_ROOT,
         NFSPROC4_CLNT_REMOVE,
         NFSPROC4_CLNT_RENAME,
@@ -500,7 +504,6 @@ enum {
         NFSPROC4_CLNT_SECINFO,
         NFSPROC4_CLNT_FSID_PRESENT,
 
-        /* nfs41 */
         NFSPROC4_CLNT_EXCHANGE_ID,
         NFSPROC4_CLNT_CREATE_SESSION,
         NFSPROC4_CLNT_DESTROY_SESSION,
@@ -518,13 +521,14 @@ enum {
         NFSPROC4_CLNT_BIND_CONN_TO_SESSION,
         NFSPROC4_CLNT_DESTROY_CLIENTID,
 
-        /* nfs42 */
         NFSPROC4_CLNT_SEEK,
         NFSPROC4_CLNT_ALLOCATE,
         NFSPROC4_CLNT_DEALLOCATE,
         NFSPROC4_CLNT_LAYOUTSTATS,
         NFSPROC4_CLNT_CLONE,
         NFSPROC4_CLNT_COPY,
+
+        NFSPROC4_CLNT_LOOKUPP,
 };
 
 /* nfs41 types */
diff --git a/include/linux/nospec.h b/include/linux/nospec.h
new file mode 100644
index 000000000000..b99bced39ac2
--- /dev/null
+++ b/include/linux/nospec.h
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright(c) 2018 Linus Torvalds. All rights reserved.
+// Copyright(c) 2018 Alexei Starovoitov. All rights reserved.
+// Copyright(c) 2018 Intel Corporation. All rights reserved.
+
+#ifndef _LINUX_NOSPEC_H
+#define _LINUX_NOSPEC_H
+
+/**
+ * array_index_mask_nospec() - generate a ~0 mask when index < size, 0 otherwise
+ * @index: array element index
+ * @size: number of elements in array
+ *
+ * When @index is out of bounds (@index >= @size), the sign bit will be
+ * set.  Extend the sign bit to all bits and invert, giving a result of
+ * zero for an out of bounds index, or ~0 if within bounds [0, @size).
+ */
+#ifndef array_index_mask_nospec
+static inline unsigned long array_index_mask_nospec(unsigned long index,
+                                                    unsigned long size)
+{
+        /*
+         * Warn developers about inappropriate array_index_nospec() usage.
+         *
+         * Even if the CPU speculates past the WARN_ONCE branch, the
+         * sign bit of @index is taken into account when generating the
+         * mask.
+         *
+         * This warning is compiled out when the compiler can infer that
+         * @index and @size are less than LONG_MAX.
+         */
+        if (WARN_ONCE(index > LONG_MAX || size > LONG_MAX,
+                        "array_index_nospec() limited to range of [0, LONG_MAX]\n"))
+                return 0;
+
+        /*
+         * Always calculate and emit the mask even if the compiler
+         * thinks the mask is not needed. The compiler does not take
+         * into account the value of @index under speculation.
+         */
+        OPTIMIZER_HIDE_VAR(index);
+        return ~(long)(index | (size - 1UL - index)) >> (BITS_PER_LONG - 1);
+}
+#endif
+
+/*
+ * array_index_nospec - sanitize an array index after a bounds check
+ *
+ * For a code sequence like:
+ *
+ *     if (index < size) {
+ *         index = array_index_nospec(index, size);
+ *         val = array[index];
+ *     }
+ *
+ * ...if the CPU speculates past the bounds check then
+ * array_index_nospec() will clamp the index within the range of [0,
+ * size).
+ */
+#define array_index_nospec(index, size)                                 \
+({                                                                      \
+        typeof(index) _i = (index);                                     \
+        typeof(size) _s = (size);                                       \
+        unsigned long _mask = array_index_mask_nospec(_i, _s);          \
+                                                                        \
+        BUILD_BUG_ON(sizeof(_i) > sizeof(long));                        \
+        BUILD_BUG_ON(sizeof(_s) > sizeof(long));                        \
+                                                                        \
+        _i &= _mask;                                                    \
+        _i;                                                             \
+})
+#endif /* _LINUX_NOSPEC_H */
diff --git a/include/linux/ntb.h b/include/linux/ntb.h
index c308964777eb..181d16601dd9 100644
--- a/include/linux/ntb.h
+++ b/include/linux/ntb.h
@@ -71,6 +71,7 @@ struct pci_dev;
  * @NTB_TOPO_B2B_USD:   On primary side of local ntb upstream of remote ntb.
  * @NTB_TOPO_B2B_DSD:   On primary side of local ntb downstream of remote ntb.
  * @NTB_TOPO_SWITCH:    Connected via a switch which supports ntb.
+ * @NTB_TOPO_CROSSLINK: Connected via two symmetric switchecs
  */
 enum ntb_topo {
         NTB_TOPO_NONE = -1,
@@ -79,6 +80,7 @@ enum ntb_topo {
         NTB_TOPO_B2B_USD,
         NTB_TOPO_B2B_DSD,
         NTB_TOPO_SWITCH,
+        NTB_TOPO_CROSSLINK,
 };
 
 static inline int ntb_topo_is_b2b(enum ntb_topo topo)
@@ -94,12 +96,13 @@ static inline int ntb_topo_is_b2b(enum ntb_topo topo)
 static inline char *ntb_topo_string(enum ntb_topo topo)
 {
         switch (topo) {
-        case NTB_TOPO_NONE:     return "NTB_TOPO_NONE";
-        case NTB_TOPO_PRI:      return "NTB_TOPO_PRI";
-        case NTB_TOPO_SEC:      return "NTB_TOPO_SEC";
-        case NTB_TOPO_B2B_USD:  return "NTB_TOPO_B2B_USD";
-        case NTB_TOPO_B2B_DSD:  return "NTB_TOPO_B2B_DSD";
-        case NTB_TOPO_SWITCH:   return "NTB_TOPO_SWITCH";
+        case NTB_TOPO_NONE:             return "NTB_TOPO_NONE";
+        case NTB_TOPO_PRI:              return "NTB_TOPO_PRI";
+        case NTB_TOPO_SEC:              return "NTB_TOPO_SEC";
+        case NTB_TOPO_B2B_USD:          return "NTB_TOPO_B2B_USD";
+        case NTB_TOPO_B2B_DSD:          return "NTB_TOPO_B2B_DSD";
+        case NTB_TOPO_SWITCH:           return "NTB_TOPO_SWITCH";
+        case NTB_TOPO_CROSSLINK:        return "NTB_TOPO_CROSSLINK";
         }
         return "NTB_TOPO_INVALID";
 }
@@ -250,7 +253,7 @@ static inline int ntb_ctx_ops_is_valid(const struct ntb_ctx_ops *ops)
  * @msg_set_mask:       See ntb_msg_set_mask().
  * @msg_clear_mask:     See ntb_msg_clear_mask().
  * @msg_read:           See ntb_msg_read().
- * @msg_write:          See ntb_msg_write().
+ * @peer_msg_write:     See ntb_peer_msg_write().
  */
 struct ntb_dev_ops {
         int (*port_number)(struct ntb_dev *ntb);
@@ -321,8 +324,8 @@ struct ntb_dev_ops {
         int (*msg_clear_sts)(struct ntb_dev *ntb, u64 sts_bits);
         int (*msg_set_mask)(struct ntb_dev *ntb, u64 mask_bits);
         int (*msg_clear_mask)(struct ntb_dev *ntb, u64 mask_bits);
-        int (*msg_read)(struct ntb_dev *ntb, int midx, int *pidx, u32 *msg);
-        int (*msg_write)(struct ntb_dev *ntb, int midx, int pidx, u32 msg);
+        u32 (*msg_read)(struct ntb_dev *ntb, int *pidx, int midx);
+        int (*peer_msg_write)(struct ntb_dev *ntb, int pidx, int midx, u32 msg);
 };
 
 static inline int ntb_dev_ops_is_valid(const struct ntb_dev_ops *ops)
@@ -384,7 +387,7 @@ static inline int ntb_dev_ops_is_valid(const struct ntb_dev_ops *ops)
                 /* !ops->msg_set_mask == !ops->msg_count        && */
                 /* !ops->msg_clear_mask == !ops->msg_count      && */
                 !ops->msg_read == !ops->msg_count               &&
-                !ops->msg_write == !ops->msg_count              &&
+                !ops->peer_msg_write == !ops->msg_count         &&
                 1;
 }
 
@@ -764,7 +767,7 @@ static inline int ntb_mw_get_align(struct ntb_dev *ntb, int pidx, int widx,
                                    resource_size_t *size_align,
                                    resource_size_t *size_max)
 {
-        if (!(ntb_link_is_up(ntb, NULL, NULL) & (1 << pidx)))
+        if (!(ntb_link_is_up(ntb, NULL, NULL) & BIT_ULL(pidx)))
                 return -ENOTCONN;
 
         return ntb->ops->mw_get_align(ntb, pidx, widx, addr_align, size_align,
@@ -1459,31 +1462,29 @@ static inline int ntb_msg_clear_mask(struct ntb_dev *ntb, u64 mask_bits)
 }
 
 /**
- * ntb_msg_read() - read message register with specified index
+ * ntb_msg_read() - read inbound message register with specified index
  * @ntb:        NTB device context.
- * @midx:       Message register index
  * @pidx:       OUT - Port index of peer device a message retrieved from
- * @msg:        OUT - Data
+ * @midx:       Message register index
  *
  * Read data from the specified message register. Source port index of a
  * message is retrieved as well.
  *
- * Return: Zero on success, otherwise a negative error number.
+ * Return: The value of the inbound message register.
  */
-static inline int ntb_msg_read(struct ntb_dev *ntb, int midx, int *pidx,
-                               u32 *msg)
+static inline u32 ntb_msg_read(struct ntb_dev *ntb, int *pidx, int midx)
 {
         if (!ntb->ops->msg_read)
-                return -EINVAL;
+                return ~(u32)0;
 
-        return ntb->ops->msg_read(ntb, midx, pidx, msg);
+        return ntb->ops->msg_read(ntb, pidx, midx);
 }
 
 /**
- * ntb_msg_write() - write data to the specified message register
+ * ntb_peer_msg_write() - write data to the specified peer message register
  * @ntb:        NTB device context.
- * @midx:       Message register index
  * @pidx:       Port index of peer device a message being sent to
+ * @midx:       Message register index
  * @msg:        Data to send
  *
  * Send data to a specified peer device using the defined message register.
@@ -1492,13 +1493,13 @@ static inline int ntb_msg_read(struct ntb_dev *ntb, int midx, int *pidx,
  *
  * Return: Zero on success, otherwise a negative error number.
  */
-static inline int ntb_msg_write(struct ntb_dev *ntb, int midx, int pidx,
-                                u32 msg)
+static inline int ntb_peer_msg_write(struct ntb_dev *ntb, int pidx, int midx,
+                                     u32 msg)
 {
-        if (!ntb->ops->msg_write)
+        if (!ntb->ops->peer_msg_write)
                 return -EINVAL;
 
-        return ntb->ops->msg_write(ntb, midx, pidx, msg);
+        return ntb->ops->peer_msg_write(ntb, pidx, midx, msg);
 }
 
 #endif
diff --git a/include/linux/nubus.h b/include/linux/nubus.h
index 11ce6b1117a8..6e8200215321 100644
--- a/include/linux/nubus.h
+++ b/include/linux/nubus.h
@@ -5,20 +5,36 @@
   Originally written by Alan Cox.
 
   Hacked to death by C. Scott Ananian and David Huggins-Daines.
-  
-  Some of the constants in here are from the corresponding
-  NetBSD/OpenBSD header file, by Allen Briggs.  We figured out the
-  rest of them on our own. */
+*/
+
 #ifndef LINUX_NUBUS_H
 #define LINUX_NUBUS_H
 
+#include <linux/device.h>
 #include <asm/nubus.h>
 #include <uapi/linux/nubus.h>
 
+struct proc_dir_entry;
+struct seq_file;
+
+struct nubus_dir {
+        unsigned char *base;
+        unsigned char *ptr;
+        int done;
+        int mask;
+        struct proc_dir_entry *procdir;
+};
+
+struct nubus_dirent {
+        unsigned char *base;
+        unsigned char type;
+        __u32 data;     /* Actually 24 bits used */
+        int mask;
+};
+
 struct nubus_board {
-        struct nubus_board* next;
-        struct nubus_dev* first_dev;
-        
+        struct device dev;
+
         /* Only 9-E actually exist, though 0-8 are also theoretically
            possible, and 0 is a special case which represents the
            motherboard and onboard peripherals (Ethernet, video) */
@@ -27,10 +43,10 @@ struct nubus_board {
         char name[64];
 
         /* Format block */
-        unsigned char* fblock;
+        unsigned char *fblock;
         /* Root directory (does *not* always equal fblock + doffset!) */
-        unsigned char* directory;
-        
+        unsigned char *directory;
+
         unsigned long slot_addr;
         /* Offset to root directory (sometimes) */
         unsigned long doffset;
@@ -41,15 +57,15 @@ struct nubus_board {
         unsigned char rev;
         unsigned char format;
         unsigned char lanes;
-};
 
-struct nubus_dev {
-        /* Next link in device list */
-        struct nubus_dev* next;
         /* Directory entry in /proc/bus/nubus */
-        struct proc_dir_entry* procdir;
+        struct proc_dir_entry *procdir;
+};
+
+struct nubus_rsrc {
+        struct list_head list;
 
-        /* The functional resource ID of this device */
+        /* The functional resource ID */
         unsigned char resid;
         /* These are mostly here for convenience; we could always read
            them from the ROMs if we wanted to */
@@ -57,79 +73,116 @@ struct nubus_dev {
         unsigned short type;
         unsigned short dr_sw;
         unsigned short dr_hw;
-        /* This is the device's name rather than the board's.
-           Sometimes they are different.  Usually the board name is
-           more correct. */
-        char name[64];
-        /* MacOS driver (I kid you not) */
-        unsigned char* driver;
-        /* Actually this is an offset */
-        unsigned long iobase;
-        unsigned long iosize;
-        unsigned char flags, hwdevid;
-        
+
         /* Functional directory */
-        unsigned char* directory;
+        unsigned char *directory;
         /* Much of our info comes from here */
-        struct nubus_board* board;
+        struct nubus_board *board;
+};
+
+/* This is all NuBus functional resources (used to find devices later on) */
+extern struct list_head nubus_func_rsrcs;
+
+struct nubus_driver {
+        struct device_driver driver;
+        int (*probe)(struct nubus_board *board);
+        int (*remove)(struct nubus_board *board);
 };
 
-/* This is all NuBus devices (used to find devices later on) */
-extern struct nubus_dev* nubus_devices;
-/* This is all NuBus cards */
-extern struct nubus_board* nubus_boards;
+extern struct bus_type nubus_bus_type;
 
 /* Generic NuBus interface functions, modelled after the PCI interface */
-void nubus_scan_bus(void);
 #ifdef CONFIG_PROC_FS
-extern void nubus_proc_init(void);
+void nubus_proc_init(void);
+struct proc_dir_entry *nubus_proc_add_board(struct nubus_board *board);
+struct proc_dir_entry *nubus_proc_add_rsrc_dir(struct proc_dir_entry *procdir,
+                                               const struct nubus_dirent *ent,
+                                               struct nubus_board *board);
+void nubus_proc_add_rsrc_mem(struct proc_dir_entry *procdir,
+                             const struct nubus_dirent *ent,
+                             unsigned int size);
+void nubus_proc_add_rsrc(struct proc_dir_entry *procdir,
+                         const struct nubus_dirent *ent);
 #else
 static inline void nubus_proc_init(void) {}
+static inline
+struct proc_dir_entry *nubus_proc_add_board(struct nubus_board *board)
+{ return NULL; }
+static inline
+struct proc_dir_entry *nubus_proc_add_rsrc_dir(struct proc_dir_entry *procdir,
+                                               const struct nubus_dirent *ent,
+                                               struct nubus_board *board)
+{ return NULL; }
+static inline void nubus_proc_add_rsrc_mem(struct proc_dir_entry *procdir,
+                                           const struct nubus_dirent *ent,
+                                           unsigned int size) {}
+static inline void nubus_proc_add_rsrc(struct proc_dir_entry *procdir,
+                                       const struct nubus_dirent *ent) {}
 #endif
-int get_nubus_list(char *buf);
-int nubus_proc_attach_device(struct nubus_dev *dev);
-/* If we need more precision we can add some more of these */
-struct nubus_dev* nubus_find_device(unsigned short category,
-                                    unsigned short type,
-                                    unsigned short dr_hw,
-                                    unsigned short dr_sw,
-                                    const struct nubus_dev* from);
-struct nubus_dev* nubus_find_type(unsigned short category,
-                                  unsigned short type,
-                                  const struct nubus_dev* from);
-/* Might have more than one device in a slot, you know... */
-struct nubus_dev* nubus_find_slot(unsigned int slot,
-                                  const struct nubus_dev* from);
+
+struct nubus_rsrc *nubus_first_rsrc_or_null(void);
+struct nubus_rsrc *nubus_next_rsrc_or_null(struct nubus_rsrc *from);
+
+#define for_each_func_rsrc(f) \
+        for (f = nubus_first_rsrc_or_null(); f; f = nubus_next_rsrc_or_null(f))
+
+#define for_each_board_func_rsrc(b, f) \
+        for_each_func_rsrc(f) if (f->board != b) {} else
 
 /* These are somewhat more NuBus-specific.  They all return 0 for
    success and -1 for failure, as you'd expect. */
 
 /* The root directory which contains the board and functional
    directories */
-int nubus_get_root_dir(const struct nubus_board* board,
-                       struct nubus_dir* dir);
+int nubus_get_root_dir(const struct nubus_board *board,
+                       struct nubus_dir *dir);
 /* The board directory */
-int nubus_get_board_dir(const struct nubus_board* board,
-                        struct nubus_dir* dir);
+int nubus_get_board_dir(const struct nubus_board *board,
+                        struct nubus_dir *dir);
 /* The functional directory */
-int nubus_get_func_dir(const struct nubus_dev* dev,
-                       struct nubus_dir* dir);
+int nubus_get_func_dir(const struct nubus_rsrc *fres, struct nubus_dir *dir);
 
 /* These work on any directory gotten via the above */
-int nubus_readdir(struct nubus_dir* dir,
-                  struct nubus_dirent* ent);
-int nubus_find_rsrc(struct nubus_dir* dir,
+int nubus_readdir(struct nubus_dir *dir,
+                  struct nubus_dirent *ent);
+int nubus_find_rsrc(struct nubus_dir *dir,
                     unsigned char rsrc_type,
-                    struct nubus_dirent* ent);
-int nubus_rewinddir(struct nubus_dir* dir);
+                    struct nubus_dirent *ent);
+int nubus_rewinddir(struct nubus_dir *dir);
 
 /* Things to do with directory entries */
-int nubus_get_subdir(const struct nubus_dirent* ent,
-                     struct nubus_dir* dir);
-void nubus_get_rsrc_mem(void* dest,
-                        const struct nubus_dirent *dirent,
-                        int len);
-void nubus_get_rsrc_str(void* dest,
-                        const struct nubus_dirent *dirent,
-                        int maxlen);
+int nubus_get_subdir(const struct nubus_dirent *ent,
+                     struct nubus_dir *dir);
+void nubus_get_rsrc_mem(void *dest, const struct nubus_dirent *dirent,
+                        unsigned int len);
+unsigned int nubus_get_rsrc_str(char *dest, const struct nubus_dirent *dirent,
+                                unsigned int len);
+void nubus_seq_write_rsrc_mem(struct seq_file *m,
+                              const struct nubus_dirent *dirent,
+                              unsigned int len);
+unsigned char *nubus_dirptr(const struct nubus_dirent *nd);
+
+/* Declarations relating to driver model objects */
+int nubus_bus_register(void);
+int nubus_device_register(struct nubus_board *board);
+int nubus_driver_register(struct nubus_driver *ndrv);
+void nubus_driver_unregister(struct nubus_driver *ndrv);
+int nubus_proc_show(struct seq_file *m, void *data);
+
+static inline void nubus_set_drvdata(struct nubus_board *board, void *data)
+{
+        dev_set_drvdata(&board->dev, data);
+}
+
+static inline void *nubus_get_drvdata(struct nubus_board *board)
+{
+        return dev_get_drvdata(&board->dev);
+}
+
+/* Returns a pointer to the "standard" slot space. */
+static inline void *nubus_slot_addr(int slot)
+{
+        return (void *)(0xF0000000 | (slot << 24));
+}
+
 #endif /* LINUX_NUBUS_H */
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index aea87f0d917b..4112e2bd747f 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -124,14 +124,20 @@ enum {
 
 #define NVME_CMB_BIR(cmbloc)    ((cmbloc) & 0x7)
 #define NVME_CMB_OFST(cmbloc)   (((cmbloc) >> 12) & 0xfffff)
-#define NVME_CMB_SZ(cmbsz)      (((cmbsz) >> 12) & 0xfffff)
-#define NVME_CMB_SZU(cmbsz)     (((cmbsz) >> 8) & 0xf)
-
-#define NVME_CMB_WDS(cmbsz)     ((cmbsz) & 0x10)
-#define NVME_CMB_RDS(cmbsz)     ((cmbsz) & 0x8)
-#define NVME_CMB_LISTS(cmbsz)   ((cmbsz) & 0x4)
-#define NVME_CMB_CQS(cmbsz)     ((cmbsz) & 0x2)
-#define NVME_CMB_SQS(cmbsz)     ((cmbsz) & 0x1)
+
+enum {
+        NVME_CMBSZ_SQS          = 1 << 0,
+        NVME_CMBSZ_CQS          = 1 << 1,
+        NVME_CMBSZ_LISTS        = 1 << 2,
+        NVME_CMBSZ_RDS          = 1 << 3,
+        NVME_CMBSZ_WDS          = 1 << 4,
+
+        NVME_CMBSZ_SZ_SHIFT     = 12,
+        NVME_CMBSZ_SZ_MASK      = 0xfffff,
+
+        NVME_CMBSZ_SZU_SHIFT    = 8,
+        NVME_CMBSZ_SZU_MASK     = 0xf,
+};
 
 /*
  * Submission and Completion Queue Entry Sizes for the NVM command set.
diff --git a/include/linux/of.h b/include/linux/of.h
index d3dea1d1e3a9..da1ee95241c1 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 #ifndef _LINUX_OF_H
 #define _LINUX_OF_H
 /*
@@ -9,11 +10,6 @@
  * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
  * Updates for SPARC64 by David S. Miller
  * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
  */
 #include <linux/types.h>
 #include <linux/bitops.h>
@@ -544,6 +540,8 @@ const char *of_prop_next_string(struct property *prop, const char *cur);
 
 bool of_console_check(struct device_node *dn, char *name, int index);
 
+extern int of_cpu_node_to_id(struct device_node *np);
+
 #else /* CONFIG_OF */
 
 static inline void of_core_init(void)
@@ -916,6 +914,11 @@ static inline void of_property_clear_flag(struct property *p, unsigned long flag
 {
 }
 
+static inline int of_cpu_node_to_id(struct device_node *np)
+{
+        return -ENODEV;
+}
+
 #define of_match_ptr(_ptr)      NULL
 #define of_match_node(_matches, _node)  NULL
 #endif /* CONFIG_OF */
diff --git a/include/linux/of_dma.h b/include/linux/of_dma.h
index b90d8ec57c1f..fd706cdf255c 100644
--- a/include/linux/of_dma.h
+++ b/include/linux/of_dma.h
@@ -1,13 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * OF helpers for DMA request / controller
  *
  * Based on of_gpio.h
  *
  * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  */
 
 #ifndef __LINUX_OF_DMA_H
diff --git a/include/linux/of_fdt.h b/include/linux/of_fdt.h
index 013c5418aeec..b9cd9ebdf9b9 100644
--- a/include/linux/of_fdt.h
+++ b/include/linux/of_fdt.h
@@ -1,12 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Definitions for working with the Flattened Device Tree data format
  *
  * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
  * benh@kernel.crashing.org
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
  */
 
 #ifndef _LINUX_OF_FDT_H
@@ -47,6 +44,12 @@ extern void *initial_boot_params;
 extern char __dtb_start[];
 extern char __dtb_end[];
 
+/* Other Prototypes */
+extern u64 of_flat_dt_translate_address(unsigned long node);
+extern void of_fdt_limit_memory(int limit);
+#endif /* CONFIG_OF_FLATTREE */
+
+#ifdef CONFIG_OF_EARLY_FLATTREE
 /* For scanning the flat device-tree at boot time */
 extern int of_scan_flat_dt(int (*it)(unsigned long node, const char *uname,
                                      int depth, void *data),
@@ -77,7 +80,6 @@ extern void early_init_dt_add_memory_arch(u64 base, u64 size);
 extern int early_init_dt_mark_hotplug_memory_arch(u64 base, u64 size);
 extern int early_init_dt_reserve_memory_arch(phys_addr_t base, phys_addr_t size,
                                              bool no_map);
-extern void * early_init_dt_alloc_memory_arch(u64 size, u64 align);
 extern u64 dt_mem_next_cell(int s, const __be32 **cellp);
 
 /* Early flat tree scan hooks */
@@ -97,16 +99,14 @@ extern void unflatten_device_tree(void);
 extern void unflatten_and_copy_device_tree(void);
 extern void early_init_devtree(void *);
 extern void early_get_first_memblock_info(void *, phys_addr_t *);
-extern u64 of_flat_dt_translate_address(unsigned long node);
-extern void of_fdt_limit_memory(int limit);
-#else /* CONFIG_OF_FLATTREE */
+#else /* CONFIG_OF_EARLY_FLATTREE */
 static inline int early_init_dt_scan_chosen_stdout(void) { return -ENODEV; }
 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) {}
-#endif /* CONFIG_OF_FLATTREE */
+#endif /* CONFIG_OF_EARLY_FLATTREE */
 
 #endif /* __ASSEMBLY__ */
 #endif /* _LINUX_OF_FDT_H */
diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h
index 1fe205582111..163b79ecd01a 100644
--- a/include/linux/of_gpio.h
+++ b/include/linux/of_gpio.h
@@ -1,14 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * OF helpers for the GPIO API
  *
  * Copyright (c) 2007-2008  MontaVista Software, Inc.
  *
  * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
  */
 
 #ifndef __LINUX_OF_GPIO_H
@@ -31,7 +27,7 @@ enum of_gpio_flags {
         OF_GPIO_ACTIVE_LOW = 0x1,
         OF_GPIO_SINGLE_ENDED = 0x2,
         OF_GPIO_OPEN_DRAIN = 0x4,
-        OF_GPIO_SLEEP_MAY_LOSE_VALUE = 0x8,
+        OF_GPIO_TRANSITORY = 0x8,
 };
 
 #ifdef CONFIG_OF_GPIO
diff --git a/include/linux/of_graph.h b/include/linux/of_graph.h
index 3e058f05ab04..01038a6aade0 100644
--- a/include/linux/of_graph.h
+++ b/include/linux/of_graph.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * OF graph binding parsing helpers
  *
@@ -6,10 +7,6 @@
  *
  * Copyright (C) 2012 Renesas Electronics Corp.
  * Author: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
  */
 #ifndef __LINUX_OF_GRAPH_H
 #define __LINUX_OF_GRAPH_H
diff --git a/include/linux/of_iommu.h b/include/linux/of_iommu.h
index cddfaff4d0b7..4fa654e4b5a9 100644
--- a/include/linux/of_iommu.h
+++ b/include/linux/of_iommu.h
@@ -34,9 +34,6 @@ static inline const struct iommu_ops *of_iommu_configure(struct device *dev,
 
 extern struct of_device_id __iommu_of_table;
 
-typedef int (*of_iommu_init_fn)(struct device_node *);
-
-#define IOMMU_OF_DECLARE(name, compat, fn) \
-        _OF_DECLARE(iommu, name, compat, fn, of_iommu_init_fn)
+#define IOMMU_OF_DECLARE(name, compat)  OF_DECLARE_1(iommu, name, compat, NULL)
 
 #endif /* __OF_IOMMU_H */
diff --git a/include/linux/of_pci.h b/include/linux/of_pci.h
index bf588a05d0d0..88865e0ebf4d 100644
--- a/include/linux/of_pci.h
+++ b/include/linux/of_pci.h
@@ -9,8 +9,7 @@ struct pci_dev;
 struct of_phandle_args;
 struct device_node;
 
-#ifdef CONFIG_OF_PCI
-int of_irq_parse_pci(const struct pci_dev *pdev, struct of_phandle_args *out_irq);
+#if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_PCI)
 struct device_node *of_pci_find_child_device(struct device_node *parent,
                                              unsigned int devfn);
 int of_pci_get_devfn(struct device_node *np);
@@ -23,11 +22,6 @@ int of_pci_map_rid(struct device_node *np, u32 rid,
                    const char *map_name, const char *map_mask_name,
                    struct device_node **target, u32 *id_out);
 #else
-static inline int of_irq_parse_pci(const struct pci_dev *pdev, struct of_phandle_args *out_irq)
-{
-        return 0;
-}
-
 static inline struct device_node *of_pci_find_child_device(struct device_node *parent,
                                              unsigned int devfn)
 {
diff --git a/include/linux/of_pdt.h b/include/linux/of_pdt.h
index 7e09244bb679..d0b183ab65c6 100644
--- a/include/linux/of_pdt.h
+++ b/include/linux/of_pdt.h
@@ -1,13 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Definitions for building a device tree by calling into the
  * Open Firmware PROM.
  *
  * Copyright (C) 2010  Andres Salomon <dilinger@queued.net>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
  */
 
 #ifndef _LINUX_OF_PDT_H
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index fb908e598348..84a966623e78 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -1,14 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 #ifndef _LINUX_OF_PLATFORM_H
 #define _LINUX_OF_PLATFORM_H
 /*
  *    Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
  *                       <benh@kernel.crashing.org>
- *
- *  This program is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU General Public License
- *  as published by the Free Software Foundation; either version
- *  2 of the License, or (at your option) any later version.
- *
  */
 
 #include <linux/device.h>
diff --git a/include/linux/omap-gpmc.h b/include/linux/omap-gpmc.h
index edfa280c3d56..053feb41510a 100644
--- a/include/linux/omap-gpmc.h
+++ b/include/linux/omap-gpmc.h
@@ -25,15 +25,43 @@ struct gpmc_nand_ops {
 
 struct gpmc_nand_regs;
 
+struct gpmc_onenand_info {
+        bool sync_read;
+        bool sync_write;
+        int burst_len;
+};
+
 #if IS_ENABLED(CONFIG_OMAP_GPMC)
 struct gpmc_nand_ops *gpmc_omap_get_nand_ops(struct gpmc_nand_regs *regs,
                                              int cs);
+/**
+ * gpmc_omap_onenand_set_timings - set optimized sync timings.
+ * @cs:      Chip Select Region
+ * @freq:    Chip frequency
+ * @latency: Burst latency cycle count
+ * @info:    Structure describing parameters used
+ *
+ * Sets optimized timings for the @cs region based on @freq and @latency.
+ * Updates the @info structure based on the GPMC settings.
+ */
+int gpmc_omap_onenand_set_timings(struct device *dev, int cs, int freq,
+                                  int latency,
+                                  struct gpmc_onenand_info *info);
+
 #else
 static inline struct gpmc_nand_ops *gpmc_omap_get_nand_ops(struct gpmc_nand_regs *regs,
                                                            int cs)
 {
         return NULL;
 }
+
+static inline
+int gpmc_omap_onenand_set_timings(struct device *dev, int cs, int freq,
+                                  int latency,
+                                  struct gpmc_onenand_info *info)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_OMAP_GPMC */
 
 extern int gpmc_calc_timings(struct gpmc_timings *gpmc_t,
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 3ec44e27aa9d..50c2b8786831 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -46,11 +46,6 @@
  * guarantees that this bit is cleared for a page when it first is entered into
  * the page cache.
  *
- * PG_highmem pages are not permanently mapped into the kernel virtual address
- * space, they need to be kmapped separately for doing IO on the pages.  The
- * struct page (these bits with information) are always mapped into kernel
- * address space...
- *
  * PG_hwpoison indicates that a page got corrupted in hardware and contains
  * data with incorrect ECC bits that triggered a machine check. Accessing is
  * not safe since it may cause another machine check. Don't touch!
diff --git a/include/linux/pagevec.h b/include/linux/pagevec.h
index 5fb6580f7f23..6dc456ac6136 100644
--- a/include/linux/pagevec.h
+++ b/include/linux/pagevec.h
@@ -9,14 +9,14 @@
 #ifndef _LINUX_PAGEVEC_H
 #define _LINUX_PAGEVEC_H
 
-/* 14 pointers + two long's align the pagevec structure to a power of two */
-#define PAGEVEC_SIZE    14
+/* 15 pointers + header align the pagevec structure to a power of two */
+#define PAGEVEC_SIZE    15
 
 struct page;
 struct address_space;
 
 struct pagevec {
-        unsigned long nr;
+        unsigned char nr;
         bool percpu_pvec_drained;
         struct page *pages[PAGEVEC_SIZE];
 };
diff --git a/include/linux/pci-aspm.h b/include/linux/pci-aspm.h
index 3cc06b059017..df28af5cef21 100644
--- a/include/linux/pci-aspm.h
+++ b/include/linux/pci-aspm.h
@@ -24,43 +24,12 @@
 #define PCIE_LINK_STATE_CLKPM   4
 
 #ifdef CONFIG_PCIEASPM
-void pcie_aspm_init_link_state(struct pci_dev *pdev);
-void pcie_aspm_exit_link_state(struct pci_dev *pdev);
-void pcie_aspm_pm_state_change(struct pci_dev *pdev);
-void pcie_aspm_powersave_config_link(struct pci_dev *pdev);
 void pci_disable_link_state(struct pci_dev *pdev, int state);
 void pci_disable_link_state_locked(struct pci_dev *pdev, int state);
 void pcie_no_aspm(void);
 #else
-static inline void pcie_aspm_init_link_state(struct pci_dev *pdev)
-{
-}
-static inline void pcie_aspm_exit_link_state(struct pci_dev *pdev)
-{
-}
-static inline void pcie_aspm_pm_state_change(struct pci_dev *pdev)
-{
-}
-static inline void pcie_aspm_powersave_config_link(struct pci_dev *pdev)
-{
-}
-static inline void pci_disable_link_state(struct pci_dev *pdev, int state)
-{
-}
-static inline void pcie_no_aspm(void)
-{
-}
+static inline void pci_disable_link_state(struct pci_dev *pdev, int state) { }
+static inline void pcie_no_aspm(void) { }
 #endif
 
-#ifdef CONFIG_PCIEASPM_DEBUG /* this depends on CONFIG_PCIEASPM */
-void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev);
-void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev);
-#else
-static inline void pcie_aspm_create_sysfs_dev_files(struct pci_dev *pdev)
-{
-}
-static inline void pcie_aspm_remove_sysfs_dev_files(struct pci_dev *pdev)
-{
-}
-#endif
 #endif /* LINUX_ASPM_H */
diff --git a/include/linux/pci-dma-compat.h b/include/linux/pci-dma-compat.h
index d1f9fdade1e0..0dd1a3f7b309 100644
--- a/include/linux/pci-dma-compat.h
+++ b/include/linux/pci-dma-compat.h
@@ -17,91 +17,90 @@ static inline void *
 pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
                      dma_addr_t *dma_handle)
 {
-        return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC);
+        return dma_alloc_coherent(&hwdev->dev, size, dma_handle, GFP_ATOMIC);
 }
 
 static inline void *
 pci_zalloc_consistent(struct pci_dev *hwdev, size_t size,
                       dma_addr_t *dma_handle)
 {
-        return dma_zalloc_coherent(hwdev == NULL ? NULL : &hwdev->dev,
-                                   size, dma_handle, GFP_ATOMIC);
+        return dma_zalloc_coherent(&hwdev->dev, size, dma_handle, GFP_ATOMIC);
 }
 
 static inline void
 pci_free_consistent(struct pci_dev *hwdev, size_t size,
                     void *vaddr, dma_addr_t dma_handle)
 {
-        dma_free_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, vaddr, dma_handle);
+        dma_free_coherent(&hwdev->dev, size, vaddr, dma_handle);
 }
 
 static inline dma_addr_t
 pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction)
 {
-        return dma_map_single(hwdev == NULL ? NULL : &hwdev->dev, ptr, size, (enum dma_data_direction)direction);
+        return dma_map_single(&hwdev->dev, ptr, size, (enum dma_data_direction)direction);
 }
 
 static inline void
 pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
                  size_t size, int direction)
 {
-        dma_unmap_single(hwdev == NULL ? NULL : &hwdev->dev, dma_addr, size, (enum dma_data_direction)direction);
+        dma_unmap_single(&hwdev->dev, dma_addr, size, (enum dma_data_direction)direction);
 }
 
 static inline dma_addr_t
 pci_map_page(struct pci_dev *hwdev, struct page *page,
              unsigned long offset, size_t size, int direction)
 {
-        return dma_map_page(hwdev == NULL ? NULL : &hwdev->dev, page, offset, size, (enum dma_data_direction)direction);
+        return dma_map_page(&hwdev->dev, page, offset, size, (enum dma_data_direction)direction);
 }
 
 static inline void
 pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address,
                size_t size, int direction)
 {
-        dma_unmap_page(hwdev == NULL ? NULL : &hwdev->dev, dma_address, size, (enum dma_data_direction)direction);
+        dma_unmap_page(&hwdev->dev, dma_address, size, (enum dma_data_direction)direction);
 }
 
 static inline int
 pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
            int nents, int direction)
 {
-        return dma_map_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
+        return dma_map_sg(&hwdev->dev, sg, nents, (enum dma_data_direction)direction);
 }
 
 static inline void
 pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg,
              int nents, int direction)
 {
-        dma_unmap_sg(hwdev == NULL ? NULL : &hwdev->dev, sg, nents, (enum dma_data_direction)direction);
+        dma_unmap_sg(&hwdev->dev, sg, nents, (enum dma_data_direction)direction);
 }
 
 static inline void
 pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
                     size_t size, int direction)
 {
-        dma_sync_single_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
+        dma_sync_single_for_cpu(&hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
 }
 
 static inline void
 pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
                     size_t size, int direction)
 {
-        dma_sync_single_for_device(hwdev == NULL ? NULL : &hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
+        dma_sync_single_for_device(&hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
 }
 
 static inline void
 pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg,
                 int nelems, int direction)
 {
-        dma_sync_sg_for_cpu(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
+        dma_sync_sg_for_cpu(&hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
 }
 
 static inline void
 pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
                 int nelems, int direction)
 {
-        dma_sync_sg_for_device(hwdev == NULL ? NULL : &hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
+        dma_sync_sg_for_device(&hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
 }
 
 static inline int
diff --git a/include/linux/pci-ecam.h b/include/linux/pci-ecam.h
index 809c2f1873ac..baadad1aabbc 100644
--- a/include/linux/pci-ecam.h
+++ b/include/linux/pci-ecam.h
@@ -1,17 +1,6 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Copyright 2016 Broadcom
- *
- * 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 (the "GPL").
- *
- * 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 version 2 (GPLv2) for more details.
- *
- * You should have received a copy of the GNU General Public License
- * version 2 (GPLv2) along with this source code.
  */
 #ifndef DRIVERS_PCI_ECAM_H
 #define DRIVERS_PCI_ECAM_H
diff --git a/include/linux/pci-ep-cfs.h b/include/linux/pci-ep-cfs.h
index 263b89ea5705..f42b0fd4b4bc 100644
--- a/include/linux/pci-ep-cfs.h
+++ b/include/linux/pci-ep-cfs.h
@@ -1,12 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /**
  * PCI Endpoint ConfigFS header file
  *
  * Copyright (C) 2017 Texas Instruments
  * Author: Kishon Vijay Abraham I <kishon@ti.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 of
- * the License as published by the Free Software Foundation.
  */
 
 #ifndef __LINUX_PCI_EP_CFS_H
diff --git a/include/linux/pci-epc.h b/include/linux/pci-epc.h
index f7a04e1af112..a1a5e5df0f66 100644
--- a/include/linux/pci-epc.h
+++ b/include/linux/pci-epc.h
@@ -1,12 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /**
  * PCI Endpoint *Controller* (EPC) header file
  *
  * Copyright (C) 2017 Texas Instruments
  * Author: Kishon Vijay Abraham I <kishon@ti.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 of
- * the License as published by the Free Software Foundation.
  */
 
 #ifndef __LINUX_PCI_EPC_H
@@ -39,17 +36,20 @@ enum pci_epc_irq_type {
  * @owner: the module owner containing the ops
  */
 struct pci_epc_ops {
-        int     (*write_header)(struct pci_epc *pci_epc,
+        int     (*write_header)(struct pci_epc *epc, u8 func_no,
                                 struct pci_epf_header *hdr);
-        int     (*set_bar)(struct pci_epc *epc, enum pci_barno bar,
+        int     (*set_bar)(struct pci_epc *epc, u8 func_no,
+                           enum pci_barno bar,
                            dma_addr_t bar_phys, size_t size, int flags);
-        void    (*clear_bar)(struct pci_epc *epc, enum pci_barno bar);
-        int     (*map_addr)(struct pci_epc *epc, phys_addr_t addr,
-                            u64 pci_addr, size_t size);
-        void    (*unmap_addr)(struct pci_epc *epc, phys_addr_t addr);
-        int     (*set_msi)(struct pci_epc *epc, u8 interrupts);
-        int     (*get_msi)(struct pci_epc *epc);
-        int     (*raise_irq)(struct pci_epc *pci_epc,
+        void    (*clear_bar)(struct pci_epc *epc, u8 func_no,
+                             enum pci_barno bar);
+        int     (*map_addr)(struct pci_epc *epc, u8 func_no,
+                            phys_addr_t addr, u64 pci_addr, size_t size);
+        void    (*unmap_addr)(struct pci_epc *epc, u8 func_no,
+                              phys_addr_t addr);
+        int     (*set_msi)(struct pci_epc *epc, u8 func_no, u8 interrupts);
+        int     (*get_msi)(struct pci_epc *epc, u8 func_no);
+        int     (*raise_irq)(struct pci_epc *epc, u8 func_no,
                              enum pci_epc_irq_type type, u8 interrupt_num);
         int     (*start)(struct pci_epc *epc);
         void    (*stop)(struct pci_epc *epc);
@@ -124,17 +124,21 @@ void pci_epc_destroy(struct pci_epc *epc);
 int pci_epc_add_epf(struct pci_epc *epc, struct pci_epf *epf);
 void pci_epc_linkup(struct pci_epc *epc);
 void pci_epc_remove_epf(struct pci_epc *epc, struct pci_epf *epf);
-int pci_epc_write_header(struct pci_epc *epc, struct pci_epf_header *hdr);
-int pci_epc_set_bar(struct pci_epc *epc, enum pci_barno bar,
+int pci_epc_write_header(struct pci_epc *epc, u8 func_no,
+                         struct pci_epf_header *hdr);
+int pci_epc_set_bar(struct pci_epc *epc, u8 func_no,
+                    enum pci_barno bar,
                     dma_addr_t bar_phys, size_t size, int flags);
-void pci_epc_clear_bar(struct pci_epc *epc, int bar);
-int pci_epc_map_addr(struct pci_epc *epc, phys_addr_t phys_addr,
+void pci_epc_clear_bar(struct pci_epc *epc, u8 func_no, int bar);
+int pci_epc_map_addr(struct pci_epc *epc, u8 func_no,
+                     phys_addr_t phys_addr,
                      u64 pci_addr, size_t size);
-void pci_epc_unmap_addr(struct pci_epc *epc, phys_addr_t phys_addr);
-int pci_epc_set_msi(struct pci_epc *epc, u8 interrupts);
-int pci_epc_get_msi(struct pci_epc *epc);
-int pci_epc_raise_irq(struct pci_epc *epc, enum pci_epc_irq_type type,
-                      u8 interrupt_num);
+void pci_epc_unmap_addr(struct pci_epc *epc, u8 func_no,
+                        phys_addr_t phys_addr);
+int pci_epc_set_msi(struct pci_epc *epc, u8 func_no, u8 interrupts);
+int pci_epc_get_msi(struct pci_epc *epc, u8 func_no);
+int pci_epc_raise_irq(struct pci_epc *epc, u8 func_no,
+                      enum pci_epc_irq_type type, u8 interrupt_num);
 int pci_epc_start(struct pci_epc *epc);
 void pci_epc_stop(struct pci_epc *epc);
 struct pci_epc *pci_epc_get(const char *epc_name);
diff --git a/include/linux/pci-epf.h b/include/linux/pci-epf.h
index 60d551a9a1ba..e897bf076701 100644
--- a/include/linux/pci-epf.h
+++ b/include/linux/pci-epf.h
@@ -1,12 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /**
  * PCI Endpoint *Function* (EPF) header file
  *
  * Copyright (C) 2017 Texas Instruments
  * Author: Kishon Vijay Abraham I <kishon@ti.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 of
- * the License as published by the Free Software Foundation.
  */
 
 #ifndef __LINUX_PCI_EPF_H
diff --git a/include/linux/pci.h b/include/linux/pci.h
index c170c9250c8b..024a1beda008 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -48,17 +48,17 @@
  * In the interest of not exposing interfaces to user-space unnecessarily,
  * the following kernel-only defines are being added here.
  */
-#define PCI_DEVID(bus, devfn)  ((((u16)(bus)) << 8) | (devfn))
+#define PCI_DEVID(bus, devfn)   ((((u16)(bus)) << 8) | (devfn))
 /* return bus from PCI devid = ((u16)bus_number) << 8) | devfn */
 #define PCI_BUS_NUM(x) (((x) >> 8) & 0xff)
 
 /* pci_slot represents a physical slot */
 struct pci_slot {
-        struct pci_bus *bus;            /* The bus this slot is on */
-        struct list_head list;          /* node in list of slots on this bus */
-        struct hotplug_slot *hotplug;   /* Hotplug info (migrate over time) */
-        unsigned char number;           /* PCI_SLOT(pci_dev->devfn) */
-        struct kobject kobj;
+        struct pci_bus          *bus;           /* Bus this slot is on */
+        struct list_head        list;           /* Node in list of slots */
+        struct hotplug_slot     *hotplug;       /* Hotplug info (move here) */
+        unsigned char           number;         /* PCI_SLOT(pci_dev->devfn) */
+        struct kobject          kobj;
 };
 
 static inline const char *pci_slot_name(const struct pci_slot *slot)
@@ -72,9 +72,7 @@ enum pci_mmap_state {
         pci_mmap_mem
 };
 
-/*
- *  For PCI devices, the region numbers are assigned this way:
- */
+/* For PCI devices, the region numbers are assigned this way: */
 enum {
         /* #0-5: standard PCI resources */
         PCI_STD_RESOURCES,
@@ -83,23 +81,23 @@ enum {
         /* #6: expansion ROM resource */
         PCI_ROM_RESOURCE,
 
-        /* device specific resources */
+        /* Device-specific resources */
 #ifdef CONFIG_PCI_IOV
         PCI_IOV_RESOURCES,
         PCI_IOV_RESOURCE_END = PCI_IOV_RESOURCES + PCI_SRIOV_NUM_BARS - 1,
 #endif
 
-        /* resources assigned to buses behind the bridge */
+        /* Resources assigned to buses behind the bridge */
 #define PCI_BRIDGE_RESOURCE_NUM 4
 
         PCI_BRIDGE_RESOURCES,
         PCI_BRIDGE_RESOURCE_END = PCI_BRIDGE_RESOURCES +
                                   PCI_BRIDGE_RESOURCE_NUM - 1,
 
-        /* total resources associated with a PCI device */
+        /* Total resources associated with a PCI device */
         PCI_NUM_RESOURCES,
 
-        /* preserve this for compatibility */
+        /* Preserve this for compatibility */
         DEVICE_COUNT_RESOURCE = PCI_NUM_RESOURCES,
 };
 
@@ -152,9 +150,10 @@ static inline const char *pci_power_name(pci_power_t state)
 #define PCI_PM_D3COLD_WAIT      100
 #define PCI_PM_BUS_WAIT         50
 
-/** The pci_channel state describes connectivity between the CPU and
- *  the pci device.  If some PCI bus between here and the pci device
- *  has crashed or locked up, this info is reflected here.
+/**
+ * The pci_channel state describes connectivity between the CPU and
+ * the PCI device.  If some PCI bus between here and the PCI device
+ * has crashed or locked up, this info is reflected here.
  */
 typedef unsigned int __bitwise pci_channel_state_t;
 
@@ -184,9 +183,7 @@ enum pcie_reset_state {
 
 typedef unsigned short __bitwise pci_dev_flags_t;
 enum pci_dev_flags {
-        /* INTX_DISABLE in PCI_COMMAND register disables MSI
-         * generation too.
-         */
+        /* INTX_DISABLE in PCI_COMMAND register disables MSI too */
         PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = (__force pci_dev_flags_t) (1 << 0),
         /* Device configuration is irrevocably lost if disabled into D3 */
         PCI_DEV_FLAGS_NO_D3 = (__force pci_dev_flags_t) (1 << 1),
@@ -202,7 +199,7 @@ enum pci_dev_flags {
         PCI_DEV_FLAGS_NO_PM_RESET = (__force pci_dev_flags_t) (1 << 7),
         /* Get VPD from function 0 VPD */
         PCI_DEV_FLAGS_VPD_REF_F0 = (__force pci_dev_flags_t) (1 << 8),
-        /* a non-root bridge where translation occurs, stop alias search here */
+        /* A non-root bridge where translation occurs, stop alias search here */
         PCI_DEV_FLAGS_BRIDGE_XLATE_ROOT = (__force pci_dev_flags_t) (1 << 9),
         /* Do not use FLR even if device advertises PCI_AF_CAP */
         PCI_DEV_FLAGS_NO_FLR_RESET = (__force pci_dev_flags_t) (1 << 10),
@@ -222,17 +219,17 @@ enum pci_bus_flags {
         PCI_BUS_FLAGS_NO_AERSID = (__force pci_bus_flags_t) 4,
 };
 
-/* These values come from the PCI Express Spec */
+/* Values from Link Status register, PCIe r3.1, sec 7.8.8 */
 enum pcie_link_width {
         PCIE_LNK_WIDTH_RESRV    = 0x00,
         PCIE_LNK_X1             = 0x01,
         PCIE_LNK_X2             = 0x02,
         PCIE_LNK_X4             = 0x04,
         PCIE_LNK_X8             = 0x08,
-        PCIE_LNK_X12            = 0x0C,
+        PCIE_LNK_X12            = 0x0c,
         PCIE_LNK_X16            = 0x10,
         PCIE_LNK_X32            = 0x20,
-        PCIE_LNK_WIDTH_UNKNOWN  = 0xFF,
+        PCIE_LNK_WIDTH_UNKNOWN  = 0xff,
 };
 
 /* Based on the PCI Hotplug Spec, but some values are made up by us */
@@ -263,15 +260,15 @@ enum pci_bus_speed {
 };
 
 struct pci_cap_saved_data {
-        u16 cap_nr;
-        bool cap_extended;
-        unsigned int size;
-        u32 data[0];
+        u16             cap_nr;
+        bool            cap_extended;
+        unsigned int    size;
+        u32             data[0];
 };
 
 struct pci_cap_saved_state {
-        struct hlist_node next;
-        struct pci_cap_saved_data cap;
+        struct hlist_node               next;
+        struct pci_cap_saved_data       cap;
 };
 
 struct irq_affinity;
@@ -280,19 +277,17 @@ struct pci_vpd;
 struct pci_sriov;
 struct pci_ats;
 
-/*
- * The pci_dev structure is used to describe PCI devices.
- */
+/* The pci_dev structure describes PCI devices */
 struct pci_dev {
-        struct list_head bus_list;      /* node in per-bus list */
-        struct pci_bus  *bus;           /* bus this device is on */
-        struct pci_bus  *subordinate;   /* bus this device bridges to */
+        struct list_head bus_list;      /* Node in per-bus list */
+        struct pci_bus  *bus;           /* Bus this device is on */
+        struct pci_bus  *subordinate;   /* Bus this device bridges to */
 
-        void            *sysdata;       /* hook for sys-specific extension */
-        struct proc_dir_entry *procent; /* device entry in /proc/bus/pci */
+        void            *sysdata;       /* Hook for sys-specific extension */
+        struct proc_dir_entry *procent; /* Device entry in /proc/bus/pci */
         struct pci_slot *slot;          /* Physical slot this device is in */
 
-        unsigned int    devfn;          /* encoded device & function index */
+        unsigned int    devfn;          /* Encoded device & function index */
         unsigned short  vendor;
         unsigned short  device;
         unsigned short  subsystem_vendor;
@@ -307,12 +302,12 @@ struct pci_dev {
         u8              msi_cap;        /* MSI capability offset */
         u8              msix_cap;       /* MSI-X capability offset */
         u8              pcie_mpss:3;    /* PCIe Max Payload Size Supported */
-        u8              rom_base_reg;   /* which config register controls the ROM */
-        u8              pin;            /* which interrupt pin this device uses */
-        u16             pcie_flags_reg; /* cached PCIe Capabilities Register */
-        unsigned long   *dma_alias_mask;/* mask of enabled devfn aliases */
+        u8              rom_base_reg;   /* Config register controlling ROM */
+        u8              pin;            /* Interrupt pin this device uses */
+        u16             pcie_flags_reg; /* Cached PCIe Capabilities Register */
+        unsigned long   *dma_alias_mask;/* Mask of enabled devfn aliases */
 
-        struct pci_driver *driver;      /* which driver has allocated this device */
+        struct pci_driver *driver;      /* Driver bound to this device */
         u64             dma_mask;       /* Mask of the bits of bus address this
                                            device implements.  Normally this is
                                            0xffffffff.  You only need to change
@@ -321,9 +316,9 @@ struct pci_dev {
 
         struct device_dma_parameters dma_parms;
 
-        pci_power_t     current_state;  /* Current operating state. In ACPI-speak,
-                                           this is D0-D3, D0 being fully functional,
-                                           and D3 being off. */
+        pci_power_t     current_state;  /* Current operating state. In ACPI,
+                                           this is D0-D3, D0 being fully
+                                           functional, and D3 being off. */
         u8              pm_cap;         /* PM capability offset */
         unsigned int    pme_support:5;  /* Bitmask of states from which PME#
                                            can be generated */
@@ -334,10 +329,10 @@ struct pci_dev {
         unsigned int    no_d3cold:1;    /* D3cold is forbidden */
         unsigned int    bridge_d3:1;    /* Allow D3 for bridge */
         unsigned int    d3cold_allowed:1;       /* D3cold is allowed by user */
-        unsigned int    mmio_always_on:1;       /* disallow turning off io/mem
-                                                   decoding during bar sizing */
+        unsigned int    mmio_always_on:1;       /* Disallow turning off io/mem
+                                                   decoding during BAR sizing */
         unsigned int    wakeup_prepared:1;
-        unsigned int    runtime_d3cold:1;       /* whether go through runtime
+        unsigned int    runtime_d3cold:1;       /* Whether go through runtime
                                                    D3cold, not set for devices
                                                    powered on/off by the
                                                    corresponding bridge */
@@ -350,12 +345,14 @@ struct pci_dev {
 
 #ifdef CONFIG_PCIEASPM
         struct pcie_link_state  *link_state;    /* ASPM link state */
+        unsigned int    ltr_path:1;     /* Latency Tolerance Reporting
+                                           supported from root to here */
 #endif
 
-        pci_channel_state_t error_state;        /* current connectivity state */
-        struct  device  dev;            /* Generic device interface */
+        pci_channel_state_t error_state;        /* Current connectivity state */
+        struct device   dev;                    /* Generic device interface */
 
-        int             cfg_size;       /* Size of configuration space */
+        int             cfg_size;               /* Size of config space */
 
         /*
          * Instead of touching interrupt line and base address registers
@@ -364,47 +361,47 @@ struct pci_dev {
         unsigned int    irq;
         struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
 
-        bool match_driver;              /* Skip attaching driver */
-        /* These fields are used by common fixups */
-        unsigned int    transparent:1;  /* Subtractive decode PCI bridge */
-        unsigned int    multifunction:1;/* Part of multi-function device */
-        /* keep track of device state */
+        bool            match_driver;           /* Skip attaching driver */
+
+        unsigned int    transparent:1;          /* Subtractive decode bridge */
+        unsigned int    multifunction:1;        /* Multi-function device */
+
         unsigned int    is_added:1;
-        unsigned int    is_busmaster:1; /* device is busmaster */
-        unsigned int    no_msi:1;       /* device may not use msi */
-        unsigned int    no_64bit_msi:1; /* device may only use 32-bit MSIs */
-        unsigned int    block_cfg_access:1;     /* config space access is blocked */
-        unsigned int    broken_parity_status:1; /* Device generates false positive parity */
-        unsigned int    irq_reroute_variant:2;  /* device needs IRQ rerouting variant */
+        unsigned int    is_busmaster:1;         /* Is busmaster */
+        unsigned int    no_msi:1;               /* May not use MSI */
+        unsigned int    no_64bit_msi:1;         /* May only use 32-bit MSIs */
+        unsigned int    block_cfg_access:1;     /* Config space access blocked */
+        unsigned int    broken_parity_status:1; /* Generates false positive parity */
+        unsigned int    irq_reroute_variant:2;  /* Needs IRQ rerouting variant */
         unsigned int    msi_enabled:1;
         unsigned int    msix_enabled:1;
-        unsigned int    ari_enabled:1;  /* ARI forwarding */
-        unsigned int    ats_enabled:1;  /* Address Translation Service */
+        unsigned int    ari_enabled:1;          /* ARI forwarding */
+        unsigned int    ats_enabled:1;          /* Address Translation Svc */
         unsigned int    pasid_enabled:1;        /* Process Address Space ID */
         unsigned int    pri_enabled:1;          /* Page Request Interface */
         unsigned int    is_managed:1;
-        unsigned int    needs_freset:1; /* Dev requires fundamental reset */
+        unsigned int    needs_freset:1;         /* Requires fundamental reset */
         unsigned int    state_saved:1;
         unsigned int    is_physfn:1;
         unsigned int    is_virtfn:1;
         unsigned int    reset_fn:1;
-        unsigned int    is_hotplug_bridge:1;
-        unsigned int    is_thunderbolt:1; /* Thunderbolt controller */
-        unsigned int    __aer_firmware_first_valid:1;
+        unsigned int    is_hotplug_bridge:1;
+        unsigned int    is_thunderbolt:1;       /* Thunderbolt controller */
+        unsigned int    __aer_firmware_first_valid:1;
         unsigned int    __aer_firmware_first:1;
-        unsigned int    broken_intx_masking:1; /* INTx masking can't be used */
-        unsigned int    io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
+        unsigned int    broken_intx_masking:1;  /* INTx masking can't be used */
+        unsigned int    io_window_1k:1;         /* Intel bridge 1K I/O windows */
         unsigned int    irq_managed:1;
         unsigned int    has_secondary_link:1;
-        unsigned int    non_compliant_bars:1;   /* broken BARs; ignore them */
-        unsigned int    is_probed:1;            /* device probing in progress */
+        unsigned int    non_compliant_bars:1;   /* Broken BARs; ignore them */
+        unsigned int    is_probed:1;            /* Device probing in progress */
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
-        u32             saved_config_space[16]; /* config space saved at suspend time */
+        u32             saved_config_space[16]; /* Config space saved at suspend time */
         struct hlist_head saved_cap_space;
-        struct bin_attribute *rom_attr; /* attribute descriptor for sysfs ROM entry */
-        int rom_attr_enabled;           /* has display of the rom attribute been enabled? */
+        struct bin_attribute *rom_attr;         /* Attribute descriptor for sysfs ROM entry */
+        int             rom_attr_enabled;       /* Display of ROM attribute enabled? */
         struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE]; /* sysfs file for resources */
         struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE]; /* sysfs file for WC mapping of resources */
 
@@ -419,12 +416,12 @@ struct pci_dev {
         struct pci_vpd *vpd;
 #ifdef CONFIG_PCI_ATS
         union {
-                struct pci_sriov *sriov;        /* SR-IOV capability related */
-                struct pci_dev *physfn; /* the PF this VF is associated with */
+                struct pci_sriov        *sriov;         /* PF: SR-IOV info */
+                struct pci_dev          *physfn;        /* VF: related PF */
         };
         u16             ats_cap;        /* ATS Capability offset */
         u8              ats_stu;        /* ATS Smallest Translation Unit */
-        atomic_t        ats_ref_cnt;    /* number of VFs with ATS enabled */
+        atomic_t        ats_ref_cnt;    /* Number of VFs with ATS enabled */
 #endif
 #ifdef CONFIG_PCI_PRI
         u32             pri_reqs_alloc; /* Number of PRI requests allocated */
@@ -432,11 +429,11 @@ struct pci_dev {
 #ifdef CONFIG_PCI_PASID
         u16             pasid_features;
 #endif
-        phys_addr_t rom; /* Physical address of ROM if it's not from the BAR */
-        size_t romlen; /* Length of ROM if it's not from the BAR */
-        char *driver_override; /* Driver name to force a match */
+        phys_addr_t     rom;            /* Physical address if not from BAR */
+        size_t          romlen;         /* Length if not from BAR */
+        char            *driver_override; /* Driver name to force a match */
 
-        unsigned long priv_flags; /* Private flags for the pci driver */
+        unsigned long   priv_flags;     /* Private flags for the PCI driver */
 };
 
 static inline struct pci_dev *pci_physfn(struct pci_dev *dev)
@@ -459,26 +456,26 @@ static inline int pci_channel_offline(struct pci_dev *pdev)
 }
 
 struct pci_host_bridge {
-        struct device dev;
-        struct pci_bus *bus;            /* root bus */
-        struct pci_ops *ops;
-        void *sysdata;
-        int busnr;
+        struct device   dev;
+        struct pci_bus  *bus;           /* Root bus */
+        struct pci_ops  *ops;
+        void            *sysdata;
+        int             busnr;
         struct list_head windows;       /* resource_entry */
-        u8 (*swizzle_irq)(struct pci_dev *, u8 *); /* platform IRQ swizzler */
+        u8 (*swizzle_irq)(struct pci_dev *, u8 *); /* Platform IRQ swizzler */
         int (*map_irq)(const struct pci_dev *, u8, u8);
         void (*release_fn)(struct pci_host_bridge *);
-        void *release_data;
+        void            *release_data;
         struct msi_controller *msi;
-        unsigned int ignore_reset_delay:1;      /* for entire hierarchy */
-        unsigned int no_ext_tags:1;             /* no Extended Tags */
+        unsigned int    ignore_reset_delay:1;   /* For entire hierarchy */
+        unsigned int    no_ext_tags:1;          /* No Extended Tags */
         /* Resource alignment requirements */
         resource_size_t (*align_resource)(struct pci_dev *dev,
                         const struct resource *res,
                         resource_size_t start,
                         resource_size_t size,
                         resource_size_t align);
-        unsigned long private[0] ____cacheline_aligned;
+        unsigned long   private[0] ____cacheline_aligned;
 };
 
 #define to_pci_host_bridge(n) container_of(n, struct pci_host_bridge, dev)
@@ -500,8 +497,8 @@ void pci_free_host_bridge(struct pci_host_bridge *bridge);
 struct pci_host_bridge *pci_find_host_bridge(struct pci_bus *bus);
 
 void pci_set_host_bridge_release(struct pci_host_bridge *bridge,
-                     void (*release_fn)(struct pci_host_bridge *),
-                     void *release_data);
+                                 void (*release_fn)(struct pci_host_bridge *),
+                                 void *release_data);
 
 int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);
 
@@ -521,32 +518,32 @@ int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);
 #define PCI_SUBTRACTIVE_DECODE  0x1
 
 struct pci_bus_resource {
-        struct list_head list;
-        struct resource *res;
-        unsigned int flags;
+        struct list_head        list;
+        struct resource         *res;
+        unsigned int            flags;
 };
 
 #define PCI_REGION_FLAG_MASK    0x0fU   /* These bits of resource flags tell us the PCI region flags */
 
 struct pci_bus {
-        struct list_head node;          /* node in list of buses */
-        struct pci_bus  *parent;        /* parent bus this bridge is on */
-        struct list_head children;      /* list of child buses */
-        struct list_head devices;       /* list of devices on this bus */
-        struct pci_dev  *self;          /* bridge device as seen by parent */
-        struct list_head slots;         /* list of slots on this bus;
+        struct list_head node;          /* Node in list of buses */
+        struct pci_bus  *parent;        /* Parent bus this bridge is on */
+        struct list_head children;      /* List of child buses */
+        struct list_head devices;       /* List of devices on this bus */
+        struct pci_dev  *self;          /* Bridge device as seen by parent */
+        struct list_head slots;         /* List of slots on this bus;
                                            protected by pci_slot_mutex */
         struct resource *resource[PCI_BRIDGE_RESOURCE_NUM];
-        struct list_head resources;     /* address space routed to this bus */
-        struct resource busn_res;       /* bus numbers routed to this bus */
+        struct list_head resources;     /* Address space routed to this bus */
+        struct resource busn_res;       /* Bus numbers routed to this bus */
 
-        struct pci_ops  *ops;           /* configuration access functions */
+        struct pci_ops  *ops;           /* Configuration access functions */
         struct msi_controller *msi;     /* MSI controller */
-        void            *sysdata;       /* hook for sys-specific extension */
-        struct proc_dir_entry *procdir; /* directory entry in /proc/bus/pci */
+        void            *sysdata;       /* Hook for sys-specific extension */
+        struct proc_dir_entry *procdir; /* Directory entry in /proc/bus/pci */
 
-        unsigned char   number;         /* bus number */
-        unsigned char   primary;        /* number of primary bridge */
+        unsigned char   number;         /* Bus number */
+        unsigned char   primary;        /* Number of primary bridge */
         unsigned char   max_bus_speed;  /* enum pci_bus_speed */
         unsigned char   cur_bus_speed;  /* enum pci_bus_speed */
 #ifdef CONFIG_PCI_DOMAINS_GENERIC
@@ -555,12 +552,12 @@ struct pci_bus {
 
         char            name[48];
 
-        unsigned short  bridge_ctl;     /* manage NO_ISA/FBB/et al behaviors */
-        pci_bus_flags_t bus_flags;      /* inherited by child buses */
+        unsigned short  bridge_ctl;     /* Manage NO_ISA/FBB/et al behaviors */
+        pci_bus_flags_t bus_flags;      /* Inherited by child buses */
         struct device           *bridge;
         struct device           dev;
-        struct bin_attribute    *legacy_io; /* legacy I/O for this bus */
-        struct bin_attribute    *legacy_mem; /* legacy mem */
+        struct bin_attribute    *legacy_io;     /* Legacy I/O for this bus */
+        struct bin_attribute    *legacy_mem;    /* Legacy mem */
         unsigned int            is_added:1;
 };
 
@@ -617,9 +614,7 @@ static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
 static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev) { return false; }
 #endif
 
-/*
- * Error values that may be returned by PCI functions.
- */
+/* Error values that may be returned by PCI functions */
 #define PCIBIOS_SUCCESSFUL              0x00
 #define PCIBIOS_FUNC_NOT_SUPPORTED      0x81
 #define PCIBIOS_BAD_VENDOR_ID           0x83
@@ -628,9 +623,7 @@ static inline bool pci_dev_msi_enabled(struct pci_dev *pci_dev) { return false;
 #define PCIBIOS_SET_FAILED              0x88
 #define PCIBIOS_BUFFER_TOO_SMALL        0x89
 
-/*
- * Translate above to generic errno for passing back through non-PCI code.
- */
+/* Translate above to generic errno for passing back through non-PCI code */
 static inline int pcibios_err_to_errno(int err)
 {
         if (err <= PCIBIOS_SUCCESSFUL)
@@ -680,13 +673,13 @@ typedef u32 pci_bus_addr_t;
 #endif
 
 struct pci_bus_region {
-        pci_bus_addr_t start;
-        pci_bus_addr_t end;
+        pci_bus_addr_t  start;
+        pci_bus_addr_t  end;
 };
 
 struct pci_dynids {
-        spinlock_t lock;            /* protects list, index */
-        struct list_head list;      /* for IDs added at runtime */
+        spinlock_t              lock;   /* Protects list, index */
+        struct list_head        list;   /* For IDs added at runtime */
 };
 
 
@@ -700,13 +693,13 @@ struct pci_dynids {
 typedef unsigned int __bitwise pci_ers_result_t;
 
 enum pci_ers_result {
-        /* no result/none/not supported in device driver */
+        /* No result/none/not supported in device driver */
         PCI_ERS_RESULT_NONE = (__force pci_ers_result_t) 1,
 
         /* Device driver can recover without slot reset */
         PCI_ERS_RESULT_CAN_RECOVER = (__force pci_ers_result_t) 2,
 
-        /* Device driver wants slot to be reset. */
+        /* Device driver wants slot to be reset */
         PCI_ERS_RESULT_NEED_RESET = (__force pci_ers_result_t) 3,
 
         /* Device has completely failed, is unrecoverable */
@@ -742,27 +735,27 @@ struct pci_error_handlers {
 
 struct module;
 struct pci_driver {
-        struct list_head node;
-        const char *name;
-        const struct pci_device_id *id_table;   /* must be non-NULL for probe to be called */
-        int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);   /* New device inserted */
-        void (*remove) (struct pci_dev *dev);   /* Device removed (NULL if not a hot-plug capable driver) */
-        int  (*suspend) (struct pci_dev *dev, pm_message_t state);      /* Device suspended */
-        int  (*suspend_late) (struct pci_dev *dev, pm_message_t state);
-        int  (*resume_early) (struct pci_dev *dev);
-        int  (*resume) (struct pci_dev *dev);                   /* Device woken up */
+        struct list_head        node;
+        const char              *name;
+        const struct pci_device_id *id_table;   /* Must be non-NULL for probe to be called */
+        int  (*probe)(struct pci_dev *dev, const struct pci_device_id *id);     /* New device inserted */
+        void (*remove)(struct pci_dev *dev);    /* Device removed (NULL if not a hot-plug capable driver) */
+        int  (*suspend)(struct pci_dev *dev, pm_message_t state);       /* Device suspended */
+        int  (*suspend_late)(struct pci_dev *dev, pm_message_t state);
+        int  (*resume_early)(struct pci_dev *dev);
+        int  (*resume) (struct pci_dev *dev);   /* Device woken up */
         void (*shutdown) (struct pci_dev *dev);
-        int (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* PF pdev */
+        int  (*sriov_configure) (struct pci_dev *dev, int num_vfs); /* On PF */
         const struct pci_error_handlers *err_handler;
         const struct attribute_group **groups;
         struct device_driver    driver;
-        struct pci_dynids dynids;
+        struct pci_dynids       dynids;
 };
 
 #define to_pci_driver(drv) container_of(drv, struct pci_driver, driver)
 
 /**
- * PCI_DEVICE - macro used to describe a specific pci device
+ * PCI_DEVICE - macro used to describe a specific PCI device
  * @vend: the 16 bit PCI Vendor ID
  * @dev: the 16 bit PCI Device ID
  *
@@ -775,7 +768,7 @@ struct pci_driver {
         .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 
 /**
- * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
+ * PCI_DEVICE_SUB - macro used to describe a specific PCI device with subsystem
  * @vend: the 16 bit PCI Vendor ID
  * @dev: the 16 bit PCI Device ID
  * @subvend: the 16 bit PCI Subvendor ID
@@ -789,7 +782,7 @@ struct pci_driver {
         .subvendor = (subvend), .subdevice = (subdev)
 
 /**
- * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
+ * PCI_DEVICE_CLASS - macro used to describe a specific PCI device class
  * @dev_class: the class, subclass, prog-if triple for this device
  * @dev_class_mask: the class mask for this device
  *
@@ -803,7 +796,7 @@ struct pci_driver {
         .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 
 /**
- * PCI_VDEVICE - macro used to describe a specific pci device in short form
+ * PCI_VDEVICE - macro used to describe a specific PCI device in short form
  * @vend: the vendor name
  * @dev: the 16 bit PCI Device ID
  *
@@ -812,22 +805,21 @@ struct pci_driver {
  * to PCI_ANY_ID. The macro allows the next field to follow as the device
  * private data.
  */
-
 #define PCI_VDEVICE(vend, dev) \
         .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
         .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
 
 enum {
-        PCI_REASSIGN_ALL_RSRC   = 0x00000001,   /* ignore firmware setup */
-        PCI_REASSIGN_ALL_BUS    = 0x00000002,   /* reassign all bus numbers */
-        PCI_PROBE_ONLY          = 0x00000004,   /* use existing setup */
-        PCI_CAN_SKIP_ISA_ALIGN  = 0x00000008,   /* don't do ISA alignment */
-        PCI_ENABLE_PROC_DOMAINS = 0x00000010,   /* enable domains in /proc */
+        PCI_REASSIGN_ALL_RSRC   = 0x00000001,   /* Ignore firmware setup */
+        PCI_REASSIGN_ALL_BUS    = 0x00000002,   /* Reassign all bus numbers */
+        PCI_PROBE_ONLY          = 0x00000004,   /* Use existing setup */
+        PCI_CAN_SKIP_ISA_ALIGN  = 0x00000008,   /* Don't do ISA alignment */
+        PCI_ENABLE_PROC_DOMAINS = 0x00000010,   /* Enable domains in /proc */
         PCI_COMPAT_DOMAIN_0     = 0x00000020,   /* ... except domain 0 */
-        PCI_SCAN_ALL_PCIE_DEVS  = 0x00000040,   /* scan all, not just dev 0 */
+        PCI_SCAN_ALL_PCIE_DEVS  = 0x00000040,   /* Scan all, not just dev 0 */
 };
 
-/* these external functions are only available when PCI support is enabled */
+/* These external functions are only available when PCI support is enabled */
 #ifdef CONFIG_PCI
 
 extern unsigned int pci_flags;
@@ -840,11 +832,11 @@ static inline int pci_has_flag(int flag) { return pci_flags & flag; }
 void pcie_bus_configure_settings(struct pci_bus *bus);
 
 enum pcie_bus_config_types {
-        PCIE_BUS_TUNE_OFF,      /* don't touch MPS at all */
-        PCIE_BUS_DEFAULT,       /* ensure MPS matches upstream bridge */
-        PCIE_BUS_SAFE,          /* use largest MPS boot-time devices support */
-        PCIE_BUS_PERFORMANCE,   /* use MPS and MRRS for best performance */
-        PCIE_BUS_PEER2PEER,     /* set MPS = 128 for all devices */
+        PCIE_BUS_TUNE_OFF,      /* Don't touch MPS at all */
+        PCIE_BUS_DEFAULT,       /* Ensure MPS matches upstream bridge */
+        PCIE_BUS_SAFE,          /* Use largest MPS boot-time devices support */
+        PCIE_BUS_PERFORMANCE,   /* Use MPS and MRRS for best performance */
+        PCIE_BUS_PEER2PEER,     /* Set MPS = 128 for all devices */
 };
 
 extern enum pcie_bus_config_types pcie_bus_config;
@@ -853,7 +845,7 @@ extern struct bus_type pci_bus_type;
 
 /* Do NOT directly access these two variables, unless you are arch-specific PCI
  * code, or PCI core code. */
-extern struct list_head pci_root_buses; /* list of all known PCI buses */
+extern struct list_head pci_root_buses; /* List of all known PCI buses */
 /* Some device drivers need know if PCI is initiated */
 int no_pci_devices(void);
 
@@ -887,12 +879,13 @@ 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,
                                     struct list_head *resources);
+int pci_host_probe(struct pci_host_bridge *bridge);
 int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int busmax);
 int pci_bus_update_busn_res_end(struct pci_bus *b, int busmax);
 void pci_bus_release_busn_res(struct pci_bus *b);
 struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
-                                             struct pci_ops *ops, void *sysdata,
-                                             struct list_head *resources);
+                                  struct pci_ops *ops, void *sysdata,
+                                  struct list_head *resources);
 int pci_scan_root_bus_bridge(struct pci_host_bridge *bridge);
 struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
                                 int busnr);
@@ -949,10 +942,10 @@ int pci_find_next_ht_capability(struct pci_dev *dev, int pos, int ht_cap);
 struct pci_bus *pci_find_next_bus(const struct pci_bus *from);
 
 struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device,
-                                struct pci_dev *from);
+                               struct pci_dev *from);
 struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
-                                unsigned int ss_vendor, unsigned int ss_device,
-                                struct pci_dev *from);
+                               unsigned int ss_vendor, unsigned int ss_device,
+                               struct pci_dev *from);
 struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
 struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
                                             unsigned int devfn);
@@ -1028,7 +1021,7 @@ static inline int pcie_capability_clear_dword(struct pci_dev *dev, int pos,
         return pcie_capability_clear_and_set_dword(dev, pos, clear, 0);
 }
 
-/* user-space driven config access */
+/* User-space driven config access */
 int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
 int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
 int pci_user_read_config_dword(struct pci_dev *dev, int where, u32 *val);
@@ -1072,6 +1065,7 @@ int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
 int pci_set_cacheline_size(struct pci_dev *dev);
 #define HAVE_PCI_SET_MWI
 int __must_check pci_set_mwi(struct pci_dev *dev);
+int __must_check pcim_set_mwi(struct pci_dev *dev);
 int pci_try_set_mwi(struct pci_dev *dev);
 void pci_clear_mwi(struct pci_dev *dev);
 void pci_intx(struct pci_dev *dev, int enable);
@@ -1170,7 +1164,7 @@ unsigned int pci_rescan_bus(struct pci_bus *bus);
 void pci_lock_rescan_remove(void);
 void pci_unlock_rescan_remove(void);
 
-/* Vital product data routines */
+/* Vital Product Data routines */
 ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
 ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
 int pci_set_vpd_size(struct pci_dev *dev, size_t len);
@@ -1255,9 +1249,7 @@ static inline pci_bus_addr_t pci_bus_address(struct pci_dev *pdev, int bar)
 int __must_check __pci_register_driver(struct pci_driver *, struct module *,
                                        const char *mod_name);
 
-/*
- * pci_register_driver must be a macro so that KBUILD_MODNAME can be expanded
- */
+/* pci_register_driver() must be a macro so KBUILD_MODNAME can be expanded */
 #define pci_register_driver(driver)             \
         __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 
@@ -1272,8 +1264,7 @@ void pci_unregister_driver(struct pci_driver *dev);
  * use this macro once, and calling it replaces module_init() and module_exit()
  */
 #define module_pci_driver(__pci_driver) \
-        module_driver(__pci_driver, pci_register_driver, \
-                       pci_unregister_driver)
+        module_driver(__pci_driver, pci_register_driver, pci_unregister_driver)
 
 /**
  * builtin_pci_driver() - Helper macro for registering a PCI driver
@@ -1312,10 +1303,10 @@ resource_size_t pcibios_iov_resource_alignment(struct pci_dev *dev, int resno);
 int pci_set_vga_state(struct pci_dev *pdev, bool decode,
                       unsigned int command_bits, u32 flags);
 
-#define PCI_IRQ_LEGACY          (1 << 0) /* allow legacy interrupts */
-#define PCI_IRQ_MSI             (1 << 1) /* allow MSI interrupts */
-#define PCI_IRQ_MSIX            (1 << 2) /* allow MSI-X interrupts */
-#define PCI_IRQ_AFFINITY        (1 << 3) /* auto-assign affinity */
+#define PCI_IRQ_LEGACY          (1 << 0) /* Allow legacy interrupts */
+#define PCI_IRQ_MSI             (1 << 1) /* Allow MSI interrupts */
+#define PCI_IRQ_MSIX            (1 << 2) /* Allow MSI-X interrupts */
+#define PCI_IRQ_AFFINITY        (1 << 3) /* Auto-assign affinity */
 #define PCI_IRQ_ALL_TYPES \
         (PCI_IRQ_LEGACY | PCI_IRQ_MSI | PCI_IRQ_MSIX)
 
@@ -1334,8 +1325,8 @@ int pci_set_vga_state(struct pci_dev *pdev, bool decode,
 #define pci_pool_free(pool, vaddr, addr) dma_pool_free(pool, vaddr, addr)
 
 struct msix_entry {
-        u32     vector; /* kernel uses to write allocated vector */
-        u16     entry;  /* driver uses to specify entry, OS writes */
+        u32     vector; /* Kernel uses to write allocated vector */
+        u16     entry;  /* Driver uses to specify entry, OS writes */
 };
 
 #ifdef CONFIG_PCI_MSI
@@ -1375,10 +1366,10 @@ static inline int pci_msi_enabled(void) { return 0; }
 static inline int pci_enable_msi(struct pci_dev *dev)
 { return -ENOSYS; }
 static inline int pci_enable_msix_range(struct pci_dev *dev,
-                      struct msix_entry *entries, int minvec, int maxvec)
+                        struct msix_entry *entries, int minvec, int maxvec)
 { return -ENOSYS; }
 static inline int pci_enable_msix_exact(struct pci_dev *dev,
-                      struct msix_entry *entries, int nvec)
+                        struct msix_entry *entries, int nvec)
 { return -ENOSYS; }
 
 static inline int
@@ -1543,9 +1534,9 @@ static inline int acpi_pci_bus_find_domain_nr(struct pci_bus *bus)
 int pci_bus_find_domain_nr(struct pci_bus *bus, struct device *parent);
 #endif
 
-/* some architectures require additional setup to direct VGA traffic */
+/* Some architectures require additional setup to direct VGA traffic */
 typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
-                      unsigned int command_bits, u32 flags);
+                                    unsigned int command_bits, u32 flags);
 void pci_register_set_vga_state(arch_set_vga_state_t func);
 
 static inline int
@@ -1584,10 +1575,9 @@ static inline void pci_clear_flags(int flags) { }
 static inline int pci_has_flag(int flag) { return 0; }
 
 /*
- *  If the system does not have PCI, clearly these return errors.  Define
- *  these as simple inline functions to avoid hair in drivers.
+ * If the system does not have PCI, clearly these return errors.  Define
+ * these as simple inline functions to avoid hair in drivers.
  */
-
 #define _PCI_NOP(o, s, t) \
         static inline int pci_##o##_config_##s(struct pci_dev *dev, \
                                                 int where, t val) \
@@ -1686,6 +1676,13 @@ static inline int pci_get_new_domain_nr(void) { return -ENOSYS; }
 #define dev_is_pf(d) (false)
 static inline bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags)
 { return false; }
+static inline int pci_irqd_intx_xlate(struct irq_domain *d,
+                                      struct device_node *node,
+                                      const u32 *intspec,
+                                      unsigned int intsize,
+                                      unsigned long *out_hwirq,
+                                      unsigned int *out_type)
+{ return -EINVAL; }
 #endif /* CONFIG_PCI */
 
 /* Include architecture-dependent settings and functions */
@@ -1726,8 +1723,10 @@ int pci_iobar_pfn(struct pci_dev *pdev, int bar, struct vm_area_struct *vma);
 #define pci_root_bus_fwnode(bus)        NULL
 #endif
 
-/* these helpers provide future and backwards compatibility
- * for accessing popular PCI BAR info */
+/*
+ * These helpers provide future and backwards compatibility
+ * for accessing popular PCI BAR info
+ */
 #define pci_resource_start(dev, bar)    ((dev)->resource[(bar)].start)
 #define pci_resource_end(dev, bar)      ((dev)->resource[(bar)].end)
 #define pci_resource_flags(dev, bar)    ((dev)->resource[(bar)].flags)
@@ -1739,7 +1738,8 @@ int pci_iobar_pfn(struct pci_dev *pdev, int bar, struct vm_area_struct *vma);
          (pci_resource_end((dev), (bar)) -              \
           pci_resource_start((dev), (bar)) + 1))
 
-/* Similar to the helpers above, these manipulate per-pci_dev
+/*
+ * Similar to the helpers above, these manipulate per-pci_dev
  * driver-specific data.  They are really just a wrapper around
  * the generic device structure functions of these calls.
  */
@@ -1753,16 +1753,14 @@ static inline void pci_set_drvdata(struct pci_dev *pdev, void *data)
         dev_set_drvdata(&pdev->dev, data);
 }
 
-/* If you want to know what to call your pci_dev, ask this function.
- * Again, it's a wrapper around the generic device.
- */
 static inline const char *pci_name(const struct pci_dev *pdev)
 {
         return dev_name(&pdev->dev);
 }
 
 
-/* Some archs don't want to expose struct resource to userland as-is
+/*
+ * Some archs don't want to expose struct resource to userland as-is
  * in sysfs and /proc
  */
 #ifdef HAVE_ARCH_PCI_RESOURCE_TO_USER
@@ -1781,16 +1779,16 @@ static inline void pci_resource_to_user(const struct pci_dev *dev, int bar,
 
 
 /*
- *  The world is not perfect and supplies us with broken PCI devices.
- *  For at least a part of these bugs we need a work-around, so both
- *  generic (drivers/pci/quirks.c) and per-architecture code can define
- *  fixup hooks to be called for particular buggy devices.
+ * The world is not perfect and supplies us with broken PCI devices.
+ * For at least a part of these bugs we need a work-around, so both
+ * generic (drivers/pci/quirks.c) and per-architecture code can define
+ * fixup hooks to be called for particular buggy devices.
  */
 
 struct pci_fixup {
-        u16 vendor;             /* You can use PCI_ANY_ID here of course */
-        u16 device;             /* You can use PCI_ANY_ID here of course */
-        u32 class;              /* You can use PCI_ANY_ID here too */
+        u16 vendor;                     /* Or PCI_ANY_ID */
+        u16 device;                     /* Or PCI_ANY_ID */
+        u32 class;                      /* Or PCI_ANY_ID */
         unsigned int class_shift;       /* should be 0, 8, 16 */
         void (*hook)(struct pci_dev *dev);
 };
@@ -1832,23 +1830,19 @@ enum pci_fixup_pass {
 #define DECLARE_PCI_FIXUP_CLASS_RESUME(vendor, device, class,           \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,                    \
-                resume##hook, vendor, device, class,    \
-                class_shift, hook)
+                resume##hook, vendor, device, class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_RESUME_EARLY(vendor, device, class,     \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,              \
-                resume_early##hook, vendor, device,     \
-                class, class_shift, hook)
+                resume_early##hook, vendor, device, class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_SUSPEND(vendor, device, class,          \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,                   \
-                suspend##hook, vendor, device, class,   \
-                class_shift, hook)
+                suspend##hook, vendor, device, class, class_shift, hook)
 #define DECLARE_PCI_FIXUP_CLASS_SUSPEND_LATE(vendor, device, class,     \
                                          class_shift, hook)             \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend_late,              \
-                suspend_late##hook, vendor, device,     \
-                class, class_shift, hook)
+                suspend_late##hook, vendor, device, class, class_shift, hook)
 
 #define DECLARE_PCI_FIXUP_EARLY(vendor, device, hook)                   \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_early,                     \
@@ -1864,20 +1858,16 @@ enum pci_fixup_pass {
                 hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_RESUME(vendor, device, hook)                  \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume,                    \
-                resume##hook, vendor, device,           \
-                PCI_ANY_ID, 0, hook)
+                resume##hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_RESUME_EARLY(vendor, device, hook)            \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_resume_early,              \
-                resume_early##hook, vendor, device,     \
-                PCI_ANY_ID, 0, hook)
+                resume_early##hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_SUSPEND(vendor, device, hook)                 \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend,                   \
-                suspend##hook, vendor, device,          \
-                PCI_ANY_ID, 0, hook)
+                suspend##hook, vendor, device, PCI_ANY_ID, 0, hook)
 #define DECLARE_PCI_FIXUP_SUSPEND_LATE(vendor, device, hook)            \
         DECLARE_PCI_FIXUP_SECTION(.pci_fixup_suspend_late,              \
-                suspend_late##hook, vendor, device,     \
-                PCI_ANY_ID, 0, hook)
+                suspend_late##hook, vendor, device, PCI_ANY_ID, 0, hook)
 
 #ifdef CONFIG_PCI_QUIRKS
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
@@ -1964,6 +1954,7 @@ int pci_vfs_assigned(struct pci_dev *dev);
 int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs);
 int pci_sriov_get_totalvfs(struct pci_dev *dev);
 resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno);
+void pci_vf_drivers_autoprobe(struct pci_dev *dev, bool probe);
 #else
 static inline int pci_iov_virtfn_bus(struct pci_dev *dev, int id)
 {
@@ -1991,6 +1982,7 @@ static inline int pci_sriov_get_totalvfs(struct pci_dev *dev)
 { return 0; }
 static inline resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno)
 { return 0; }
+static inline void pci_vf_drivers_autoprobe(struct pci_dev *dev, bool probe) { }
 #endif
 
 #if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE)
@@ -2061,6 +2053,7 @@ void pci_request_acs(void);
 bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags);
 bool pci_acs_path_enabled(struct pci_dev *start,
                           struct pci_dev *end, u16 acs_flags);
+int pci_enable_atomic_ops_to_root(struct pci_dev *dev, u32 cap_mask);
 
 #define PCI_VPD_LRDT                    0x80    /* Large Resource Data Type */
 #define PCI_VPD_LRDT_ID(x)              ((x) | PCI_VPD_LRDT)
@@ -2112,7 +2105,7 @@ static inline u16 pci_vpd_lrdt_size(const u8 *lrdt)
  */
 static inline u16 pci_vpd_lrdt_tag(const u8 *lrdt)
 {
-    return (u16)(lrdt[0] & PCI_VPD_LRDT_TIN_MASK);
+        return (u16)(lrdt[0] & PCI_VPD_LRDT_TIN_MASK);
 }
 
 /**
@@ -2182,6 +2175,9 @@ void pci_release_of_node(struct pci_dev *dev);
 void pci_set_bus_of_node(struct pci_bus *bus);
 void pci_release_bus_of_node(struct pci_bus *bus);
 struct irq_domain *pci_host_bridge_of_msi_domain(struct pci_bus *bus);
+int pci_parse_request_of_pci_ranges(struct device *dev,
+                                    struct list_head *resources,
+                                    struct resource **bus_range);
 
 /* Arch may override this (weak) */
 struct device_node *pcibios_get_phb_of_node(struct pci_bus *bus);
@@ -2197,7 +2193,7 @@ static inline struct device_node *pci_bus_to_OF_node(struct pci_bus *bus)
         return bus ? bus->dev.of_node : NULL;
 }
 
-#else /* CONFIG_OF */
+#else   /* CONFIG_OF */
 static inline void pci_set_of_node(struct pci_dev *dev) { }
 static inline void pci_release_of_node(struct pci_dev *dev) { }
 static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
@@ -2206,6 +2202,12 @@ static inline struct device_node *
 pci_device_to_OF_node(const struct pci_dev *pdev) { return NULL; }
 static inline struct irq_domain *
 pci_host_bridge_of_msi_domain(struct pci_bus *bus) { return NULL; }
+static inline int pci_parse_request_of_pci_ranges(struct device *dev,
+                                                  struct list_head *resources,
+                                                  struct resource **bus_range)
+{
+        return -EINVAL;
+}
 #endif  /* CONFIG_OF */
 
 #ifdef CONFIG_ACPI
@@ -2231,7 +2233,7 @@ int pci_for_each_dma_alias(struct pci_dev *pdev,
                            int (*fn)(struct pci_dev *pdev,
                                      u16 alias, void *data), void *data);
 
-/* helper functions for operation of device flag */
+/* Helper functions for operation of device flag */
 static inline void pci_set_dev_assigned(struct pci_dev *pdev)
 {
         pdev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED;
@@ -2278,7 +2280,55 @@ static inline bool pci_is_thunderbolt_attached(struct pci_dev *pdev)
         return false;
 }
 
-/* provide the legacy pci_dma_* API */
+/**
+ * pci_uevent_ers - emit a uevent during recovery path of pci device
+ * @pdev: pci device to check
+ * @err_type: type of error event
+ *
+ */
+static inline void pci_uevent_ers(struct pci_dev *pdev,
+                                  enum  pci_ers_result err_type)
+{
+        int idx = 0;
+        char *envp[3];
+
+        switch (err_type) {
+        case PCI_ERS_RESULT_NONE:
+        case PCI_ERS_RESULT_CAN_RECOVER:
+                envp[idx++] = "ERROR_EVENT=BEGIN_RECOVERY";
+                envp[idx++] = "DEVICE_ONLINE=0";
+                break;
+        case PCI_ERS_RESULT_RECOVERED:
+                envp[idx++] = "ERROR_EVENT=SUCCESSFUL_RECOVERY";
+                envp[idx++] = "DEVICE_ONLINE=1";
+                break;
+        case PCI_ERS_RESULT_DISCONNECT:
+                envp[idx++] = "ERROR_EVENT=FAILED_RECOVERY";
+                envp[idx++] = "DEVICE_ONLINE=0";
+                break;
+        default:
+                break;
+        }
+
+        if (idx > 0) {
+                envp[idx++] = NULL;
+                kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp);
+        }
+}
+
+/* Provide the legacy pci_dma_* API */
 #include <linux/pci-dma-compat.h>
 
+#define pci_printk(level, pdev, fmt, arg...) \
+        dev_printk(level, &(pdev)->dev, fmt, ##arg)
+
+#define pci_emerg(pdev, fmt, arg...)    dev_emerg(&(pdev)->dev, fmt, ##arg)
+#define pci_alert(pdev, fmt, arg...)    dev_alert(&(pdev)->dev, fmt, ##arg)
+#define pci_crit(pdev, fmt, arg...)     dev_crit(&(pdev)->dev, fmt, ##arg)
+#define pci_err(pdev, fmt, arg...)      dev_err(&(pdev)->dev, fmt, ##arg)
+#define pci_warn(pdev, fmt, arg...)     dev_warn(&(pdev)->dev, fmt, ##arg)
+#define pci_notice(pdev, fmt, arg...)   dev_notice(&(pdev)->dev, fmt, ##arg)
+#define pci_info(pdev, fmt, arg...)     dev_info(&(pdev)->dev, fmt, ##arg)
+#define pci_dbg(pdev, fmt, arg...)      dev_dbg(&(pdev)->dev, fmt, ##arg)
+
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index 2e855afa0212..26213024e81b 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * PCI HotPlug Core Functions
  *
@@ -7,21 +8,6 @@
  *
  * All rights reserved.
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  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., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
  * Send feedback to <kristen.c.accardi@intel.com>
  *
  */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index ab20dc5db423..eb13e84e1fef 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2381,6 +2381,8 @@
 
 #define PCI_VENDOR_ID_LENOVO            0x17aa
 
+#define PCI_VENDOR_ID_CDNS              0x17cd
+
 #define PCI_VENDOR_ID_ARECA             0x17d3
 #define PCI_DEVICE_ID_ARECA_1110        0x1110
 #define PCI_DEVICE_ID_ARECA_1120        0x1120
diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
index 6658d9ee5257..864d167a1073 100644
--- a/include/linux/percpu-refcount.h
+++ b/include/linux/percpu-refcount.h
@@ -139,12 +139,12 @@ static inline bool __ref_is_percpu(struct percpu_ref *ref,
          * when using it as a pointer, __PERCPU_REF_ATOMIC may be set in
          * between contaminating the pointer value, meaning that
          * READ_ONCE() is required when fetching it.
+         *
+         * The smp_read_barrier_depends() implied by READ_ONCE() pairs
+         * with smp_store_release() in __percpu_ref_switch_to_percpu().
          */
         percpu_ptr = READ_ONCE(ref->percpu_count_ptr);
 
-        /* paired with smp_store_release() in __percpu_ref_switch_to_percpu() */
-        smp_read_barrier_depends();
-
         /*
          * Theoretically, the following could test just ATOMIC; however,
          * then we'd have to mask off DEAD separately as DEAD may be
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index 73a7bf30fe9a..4f052496cdfd 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -86,7 +86,7 @@ static inline s64 percpu_counter_read_positive(struct percpu_counter *fbc)
         return 0;
 }
 
-static inline int percpu_counter_initialized(struct percpu_counter *fbc)
+static inline bool percpu_counter_initialized(struct percpu_counter *fbc)
 {
         return (fbc->counters != NULL);
 }
@@ -167,9 +167,9 @@ static inline s64 percpu_counter_sum(struct percpu_counter *fbc)
         return percpu_counter_read(fbc);
 }
 
-static inline int percpu_counter_initialized(struct percpu_counter *fbc)
+static inline bool percpu_counter_initialized(struct percpu_counter *fbc)
 {
-        return 1;
+        return true;
 }
 
 #endif  /* CONFIG_SMP */
diff --git a/include/linux/pfn_t.h b/include/linux/pfn_t.h
index 43b1d7648e82..a03c2642a87c 100644
--- a/include/linux/pfn_t.h
+++ b/include/linux/pfn_t.h
@@ -15,8 +15,10 @@
 #define PFN_SG_LAST (1ULL << (BITS_PER_LONG_LONG - 2))
 #define PFN_DEV (1ULL << (BITS_PER_LONG_LONG - 3))
 #define PFN_MAP (1ULL << (BITS_PER_LONG_LONG - 4))
+#define PFN_SPECIAL (1ULL << (BITS_PER_LONG_LONG - 5))
 
 #define PFN_FLAGS_TRACE \
+        { PFN_SPECIAL,  "SPECIAL" }, \
         { PFN_SG_CHAIN, "SG_CHAIN" }, \
         { PFN_SG_LAST,  "SG_LAST" }, \
         { PFN_DEV,      "DEV" }, \
@@ -120,4 +122,15 @@ pud_t pud_mkdevmap(pud_t pud);
 #endif
 #endif /* __HAVE_ARCH_PTE_DEVMAP */
 
+#ifdef __HAVE_ARCH_PTE_SPECIAL
+static inline bool pfn_t_special(pfn_t pfn)
+{
+        return (pfn.val & PFN_SPECIAL) == PFN_SPECIAL;
+}
+#else
+static inline bool pfn_t_special(pfn_t pfn)
+{
+        return false;
+}
+#endif /* __HAVE_ARCH_PTE_SPECIAL */
 #endif /* _LINUX_PFN_T_H_ */
diff --git a/include/linux/phy.h b/include/linux/phy.h
index dc82a07cb4fd..5a0c3e53e7c2 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -59,6 +59,7 @@
 
 #define PHY_HAS_INTERRUPT       0x00000001
 #define PHY_IS_INTERNAL         0x00000002
+#define PHY_RST_AFTER_CLK_EN    0x00000004
 #define MDIO_DEVICE_IS_PHY      0x80000000
 
 /* Interface Mode definitions */
@@ -468,7 +469,6 @@ struct phy_device {
         /* Interrupt and Polling infrastructure */
         struct work_struct phy_queue;
         struct delayed_work state_queue;
-        atomic_t irq_disable;
 
         struct mutex lock;
 
@@ -497,19 +497,19 @@ struct phy_device {
  * flags: A bitfield defining certain other features this PHY
  *   supports (like interrupts)
  *
- * The drivers must implement config_aneg and read_status.  All
- * other functions are optional. Note that none of these
- * functions should be called from interrupt time.  The goal is
- * for the bus read/write functions to be able to block when the
- * bus transaction is happening, and be freed up by an interrupt
- * (The MPC85xx has this ability, though it is not currently
- * supported in the driver).
+ * All functions are optional. If config_aneg or read_status
+ * are not implemented, the phy core uses the genphy versions.
+ * Note that none of these functions should be called from
+ * interrupt time. The goal is for the bus read/write functions
+ * to be able to block when the bus transaction is happening,
+ * and be freed up by an interrupt (The MPC85xx has this ability,
+ * though it is not currently supported in the driver).
  */
 struct phy_driver {
         struct mdio_driver_common mdiodrv;
         u32 phy_id;
         char *name;
-        unsigned int phy_id_mask;
+        u32 phy_id_mask;
         u32 features;
         u32 flags;
         const void *driver_data;
@@ -634,6 +634,9 @@ struct phy_driver {
         int (*write_mmd)(struct phy_device *dev, int devnum, u16 regnum,
                          u16 val);
 
+        int (*read_page)(struct phy_device *dev);
+        int (*write_page)(struct phy_device *dev, int page);
+
         /* Get the size and type of the eeprom contained within a plug-in
          * module */
         int (*module_info)(struct phy_device *dev,
@@ -690,6 +693,8 @@ phy_lookup_setting(int speed, int duplex, const unsigned long *mask,
 size_t phy_speeds(unsigned int *speeds, size_t size,
                   unsigned long *mask, size_t maxbit);
 
+void phy_resolve_aneg_linkmode(struct phy_device *phydev);
+
 /**
  * phy_read_mmd - Convenience function for reading a register
  * from an MMD on a given PHY.
@@ -716,6 +721,18 @@ static inline int phy_read(struct phy_device *phydev, u32 regnum)
 }
 
 /**
+ * __phy_read - convenience function for reading a given PHY register
+ * @phydev: the phy_device struct
+ * @regnum: register number to read
+ *
+ * The caller must have taken the MDIO bus lock.
+ */
+static inline int __phy_read(struct phy_device *phydev, u32 regnum)
+{
+        return __mdiobus_read(phydev->mdio.bus, phydev->mdio.addr, regnum);
+}
+
+/**
  * phy_write - Convenience function for writing a given PHY register
  * @phydev: the phy_device struct
  * @regnum: register number to write
@@ -731,6 +748,72 @@ static inline int phy_write(struct phy_device *phydev, u32 regnum, u16 val)
 }
 
 /**
+ * __phy_write - Convenience function for writing a given PHY register
+ * @phydev: the phy_device struct
+ * @regnum: register number to write
+ * @val: value to write to @regnum
+ *
+ * The caller must have taken the MDIO bus lock.
+ */
+static inline int __phy_write(struct phy_device *phydev, u32 regnum, u16 val)
+{
+        return __mdiobus_write(phydev->mdio.bus, phydev->mdio.addr, regnum,
+                               val);
+}
+
+int __phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set);
+int phy_modify(struct phy_device *phydev, u32 regnum, u16 mask, u16 set);
+
+/**
+ * __phy_set_bits - Convenience function for setting bits in a PHY register
+ * @phydev: the phy_device struct
+ * @regnum: register number to write
+ * @val: bits to set
+ *
+ * The caller must have taken the MDIO bus lock.
+ */
+static inline int __phy_set_bits(struct phy_device *phydev, u32 regnum, u16 val)
+{
+        return __phy_modify(phydev, regnum, 0, val);
+}
+
+/**
+ * __phy_clear_bits - Convenience function for clearing bits in a PHY register
+ * @phydev: the phy_device struct
+ * @regnum: register number to write
+ * @val: bits to clear
+ *
+ * The caller must have taken the MDIO bus lock.
+ */
+static inline int __phy_clear_bits(struct phy_device *phydev, u32 regnum,
+                                   u16 val)
+{
+        return __phy_modify(phydev, regnum, val, 0);
+}
+
+/**
+ * phy_set_bits - Convenience function for setting bits in a PHY register
+ * @phydev: the phy_device struct
+ * @regnum: register number to write
+ * @val: bits to set
+ */
+static inline int phy_set_bits(struct phy_device *phydev, u32 regnum, u16 val)
+{
+        return phy_modify(phydev, regnum, 0, val);
+}
+
+/**
+ * phy_clear_bits - Convenience function for clearing bits in a PHY register
+ * @phydev: the phy_device struct
+ * @regnum: register number to write
+ * @val: bits to clear
+ */
+static inline int phy_clear_bits(struct phy_device *phydev, u32 regnum, u16 val)
+{
+        return phy_modify(phydev, regnum, val, 0);
+}
+
+/**
  * phy_interrupt_is_valid - Convenience function for testing a given PHY irq
  * @phydev: the phy_device struct
  *
@@ -763,6 +846,20 @@ static inline bool phy_interface_mode_is_rgmii(phy_interface_t mode)
 };
 
 /**
+ * phy_interface_mode_is_8023z() - does the phy interface mode use 802.3z
+ *   negotiation
+ * @mode: one of &enum phy_interface_t
+ *
+ * Returns true if the phy interface mode uses the 16-bit negotiation
+ * word as defined in 802.3z. (See 802.3-2015 37.2.1 Config_Reg encoding)
+ */
+static inline bool phy_interface_mode_is_8023z(phy_interface_t mode)
+{
+        return mode == PHY_INTERFACE_MODE_1000BASEX ||
+               mode == PHY_INTERFACE_MODE_2500BASEX;
+}
+
+/**
  * phy_interface_is_rgmii - Convenience function for testing if a PHY interface
  * is RGMII (all variants)
  * @phydev: the phy_device struct
@@ -794,6 +891,14 @@ static inline bool phy_is_pseudo_fixed_link(struct phy_device *phydev)
  */
 int phy_write_mmd(struct phy_device *phydev, int devad, u32 regnum, u16 val);
 
+int phy_save_page(struct phy_device *phydev);
+int phy_select_page(struct phy_device *phydev, int page);
+int phy_restore_page(struct phy_device *phydev, int oldpage, int ret);
+int phy_read_paged(struct phy_device *phydev, int page, u32 regnum);
+int phy_write_paged(struct phy_device *phydev, int page, u32 regnum, u16 val);
+int phy_modify_paged(struct phy_device *phydev, int page, u32 regnum,
+                     u16 mask, u16 set);
+
 struct phy_device *phy_device_create(struct mii_bus *bus, int addr, int phy_id,
                                      bool is_c45,
                                      struct phy_c45_device_ids *c45_ids);
@@ -840,13 +945,11 @@ int phy_aneg_done(struct phy_device *phydev);
 
 int phy_stop_interrupts(struct phy_device *phydev);
 int phy_restart_aneg(struct phy_device *phydev);
+int phy_reset_after_clk_enable(struct phy_device *phydev);
 
-static inline int phy_read_status(struct phy_device *phydev)
+static inline void phy_device_reset(struct phy_device *phydev, int value)
 {
-        if (!phydev->drv)
-                return -EIO;
-
-        return phydev->drv->read_status(phydev);
+        mdio_device_reset(&phydev->mdio, value);
 }
 
 #define phydev_err(_phydev, format, args...)    \
@@ -889,6 +992,18 @@ int genphy_c45_read_lpa(struct phy_device *phydev);
 int genphy_c45_read_pma(struct phy_device *phydev);
 int genphy_c45_pma_setup_forced(struct phy_device *phydev);
 int genphy_c45_an_disable_aneg(struct phy_device *phydev);
+int genphy_c45_read_mdix(struct phy_device *phydev);
+
+static inline int phy_read_status(struct phy_device *phydev)
+{
+        if (!phydev->drv)
+                return -EIO;
+
+        if (phydev->drv->read_status)
+                return phydev->drv->read_status(phydev);
+        else
+                return genphy_read_status(phydev);
+}
 
 void phy_driver_unregister(struct phy_driver *drv);
 void phy_drivers_unregister(struct phy_driver *drv, int n);
@@ -898,7 +1013,7 @@ int phy_drivers_register(struct phy_driver *new_driver, int n,
 void phy_state_machine(struct work_struct *work);
 void phy_change(struct phy_device *phydev);
 void phy_change_work(struct work_struct *work);
-void phy_mac_interrupt(struct phy_device *phydev, int new_link);
+void phy_mac_interrupt(struct phy_device *phydev);
 void phy_start_machine(struct phy_device *phydev);
 void phy_stop_machine(struct phy_device *phydev);
 void phy_trigger_machine(struct phy_device *phydev, bool sync);
diff --git a/include/linux/phy_fixed.h b/include/linux/phy_fixed.h
index cf6392de6eb0..ee54453a40a0 100644
--- a/include/linux/phy_fixed.h
+++ b/include/linux/phy_fixed.h
@@ -24,9 +24,6 @@ extern void fixed_phy_unregister(struct phy_device *phydev);
 extern int fixed_phy_set_link_update(struct phy_device *phydev,
                         int (*link_update)(struct net_device *,
                                            struct fixed_phy_status *));
-extern int fixed_phy_update_state(struct phy_device *phydev,
-                           const struct fixed_phy_status *status,
-                           const struct fixed_phy_status *changed);
 #else
 static inline int fixed_phy_add(unsigned int irq, int phy_id,
                                 struct fixed_phy_status *status,
@@ -50,12 +47,6 @@ static inline int fixed_phy_set_link_update(struct phy_device *phydev,
 {
         return -ENODEV;
 }
-static inline int fixed_phy_update_state(struct phy_device *phydev,
-                           const struct fixed_phy_status *status,
-                           const struct fixed_phy_status *changed)
-{
-        return -ENODEV;
-}
 #endif /* CONFIG_FIXED_PHY */
 
 #endif /* __PHY_FIXED_H */
diff --git a/include/linux/phylink.h b/include/linux/phylink.h
index af67edd4ae38..bd137c273d38 100644
--- a/include/linux/phylink.h
+++ b/include/linux/phylink.h
@@ -7,6 +7,7 @@
 
 struct device_node;
 struct ethtool_cmd;
+struct fwnode_handle;
 struct net_device;
 
 enum {
@@ -20,19 +21,31 @@ enum {
 
         MLO_AN_PHY = 0, /* Conventional PHY */
         MLO_AN_FIXED,   /* Fixed-link mode */
-        MLO_AN_SGMII,   /* Cisco SGMII protocol */
-        MLO_AN_8023Z,   /* 1000base-X protocol */
+        MLO_AN_INBAND,  /* In-band protocol */
 };
 
 static inline bool phylink_autoneg_inband(unsigned int mode)
 {
-        return mode == MLO_AN_SGMII || mode == MLO_AN_8023Z;
+        return mode == MLO_AN_INBAND;
 }
 
+/**
+ * struct phylink_link_state - link state structure
+ * @advertising: ethtool bitmask containing advertised link modes
+ * @lp_advertising: ethtool bitmask containing link partner advertised link
+ *   modes
+ * @interface: link &typedef phy_interface_t mode
+ * @speed: link speed, one of the SPEED_* constants.
+ * @duplex: link duplex mode, one of DUPLEX_* constants.
+ * @pause: link pause state, described by MLO_PAUSE_* constants.
+ * @link: true if the link is up.
+ * @an_enabled: true if autonegotiation is enabled/desired.
+ * @an_complete: true if autonegotiation has completed.
+ */
 struct phylink_link_state {
         __ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
         __ETHTOOL_DECLARE_LINK_MODE_MASK(lp_advertising);
-        phy_interface_t interface;      /* PHY_INTERFACE_xxx */
+        phy_interface_t interface;
         int speed;
         int duplex;
         int pause;
@@ -41,72 +54,145 @@ struct phylink_link_state {
         unsigned int an_complete:1;
 };
 
+/**
+ * struct phylink_mac_ops - MAC operations structure.
+ * @validate: Validate and update the link configuration.
+ * @mac_link_state: Read the current link state from the hardware.
+ * @mac_config: configure the MAC for the selected mode and state.
+ * @mac_an_restart: restart 802.3z BaseX autonegotiation.
+ * @mac_link_down: take the link down.
+ * @mac_link_up: allow the link to come up.
+ *
+ * The individual methods are described more fully below.
+ */
 struct phylink_mac_ops {
-        /**
-         * validate: validate and update the link configuration
-         * @ndev: net_device structure associated with MAC
-         * @config: configuration to validate
-         *
-         * Update the %config->supported and %config->advertised masks
-         * clearing bits that can not be supported.
-         *
-         * Note: the PHY may be able to transform from one connection
-         * technology to another, so, eg, don't clear 1000BaseX just
-         * because the MAC is unable to support it.  This is more about
-         * clearing unsupported speeds and duplex settings.
-         *
-         * If the %config->interface mode is %PHY_INTERFACE_MODE_1000BASEX
-         * or %PHY_INTERFACE_MODE_2500BASEX, select the appropriate mode
-         * based on %config->advertised and/or %config->speed.
-         */
         void (*validate)(struct net_device *ndev, unsigned long *supported,
                          struct phylink_link_state *state);
-
-        /* Read the current link state from the hardware */
-        int (*mac_link_state)(struct net_device *, struct phylink_link_state *);
-
-        /* Configure the MAC */
-        /**
-         * mac_config: configure the MAC for the selected mode and state
-         * @ndev: net_device structure for the MAC
-         * @mode: one of MLO_AN_FIXED, MLO_AN_PHY, MLO_AN_8023Z, MLO_AN_SGMII
-         * @state: state structure
-         *
-         * The action performed depends on the currently selected mode:
-         *
-         * %MLO_AN_FIXED, %MLO_AN_PHY:
-         *   set the specified speed, duplex, pause mode, and phy interface
-         *   mode in the provided @state.
-         * %MLO_AN_8023Z:
-         *   place the link in 1000base-X mode, advertising the parameters
-         *   given in advertising in @state.
-         * %MLO_AN_SGMII:
-         *   place the link in Cisco SGMII mode - there is no advertisment
-         *   to make as the PHY communicates the speed and duplex to the
-         *   MAC over the in-band control word.  Configuration of the pause
-         *   mode is as per MLO_AN_PHY since this is not included.
-         */
+        int (*mac_link_state)(struct net_device *ndev,
+                              struct phylink_link_state *state);
         void (*mac_config)(struct net_device *ndev, unsigned int mode,
                            const struct phylink_link_state *state);
-
-        /**
-         * mac_an_restart: restart 802.3z BaseX autonegotiation
-         * @ndev: net_device structure for the MAC
-         */
         void (*mac_an_restart)(struct net_device *ndev);
-
-        void (*mac_link_down)(struct net_device *, unsigned int mode);
-        void (*mac_link_up)(struct net_device *, unsigned int mode,
-                            struct phy_device *);
+        void (*mac_link_down)(struct net_device *ndev, unsigned int mode);
+        void (*mac_link_up)(struct net_device *ndev, unsigned int mode,
+                            struct phy_device *phy);
 };
 
-struct phylink *phylink_create(struct net_device *, struct device_node *,
+#if 0 /* For kernel-doc purposes only. */
+/**
+ * validate - Validate and update the link configuration
+ * @ndev: a pointer to a &struct net_device for the MAC.
+ * @supported: ethtool bitmask for supported link modes.
+ * @state: a pointer to a &struct phylink_link_state.
+ *
+ * Clear bits in the @supported and @state->advertising masks that
+ * are not supportable by the MAC.
+ *
+ * Note that the PHY may be able to transform from one connection
+ * technology to another, so, eg, don't clear 1000BaseX just
+ * because the MAC is unable to BaseX mode. This is more about
+ * clearing unsupported speeds and duplex settings.
+ *
+ * If the @state->interface mode is %PHY_INTERFACE_MODE_1000BASEX
+ * or %PHY_INTERFACE_MODE_2500BASEX, select the appropriate mode
+ * based on @state->advertising and/or @state->speed and update
+ * @state->interface accordingly.
+ */
+void validate(struct net_device *ndev, unsigned long *supported,
+              struct phylink_link_state *state);
+
+/**
+ * mac_link_state() - Read the current link state from the hardware
+ * @ndev: a pointer to a &struct net_device for the MAC.
+ * @state: a pointer to a &struct phylink_link_state.
+ *
+ * Read the current link state from the MAC, reporting the current
+ * speed in @state->speed, duplex mode in @state->duplex, pause mode
+ * in @state->pause using the %MLO_PAUSE_RX and %MLO_PAUSE_TX bits,
+ * negotiation completion state in @state->an_complete, and link
+ * up state in @state->link.
+ */
+int mac_link_state(struct net_device *ndev,
+                   struct phylink_link_state *state);
+
+/**
+ * mac_config() - configure the MAC for the selected mode and state
+ * @ndev: a pointer to a &struct net_device for the MAC.
+ * @mode: one of %MLO_AN_FIXED, %MLO_AN_PHY, %MLO_AN_INBAND.
+ * @state: a pointer to a &struct phylink_link_state.
+ *
+ * The action performed depends on the currently selected mode:
+ *
+ * %MLO_AN_FIXED, %MLO_AN_PHY:
+ *   Configure the specified @state->speed, @state->duplex and
+ *   @state->pause (%MLO_PAUSE_TX / %MLO_PAUSE_RX) mode.
+ *
+ * %MLO_AN_INBAND:
+ *   place the link in an inband negotiation mode (such as 802.3z
+ *   1000base-X or Cisco SGMII mode depending on the @state->interface
+ *   mode). In both cases, link state management (whether the link
+ *   is up or not) is performed by the MAC, and reported via the
+ *   mac_link_state() callback. Changes in link state must be made
+ *   by calling phylink_mac_change().
+ *
+ *   If in 802.3z mode, the link speed is fixed, dependent on the
+ *   @state->interface. Duplex is negotiated, and pause is advertised
+ *   according to @state->an_enabled, @state->pause and
+ *   @state->advertising flags. Beware of MACs which only support full
+ *   duplex at gigabit and higher speeds.
+ *
+ *   If in Cisco SGMII mode, the link speed and duplex mode are passed
+ *   in the serial bitstream 16-bit configuration word, and the MAC
+ *   should be configured to read these bits and acknowledge the
+ *   configuration word. Nothing is advertised by the MAC. The MAC is
+ *   responsible for reading the configuration word and configuring
+ *   itself accordingly.
+ */
+void mac_config(struct net_device *ndev, unsigned int mode,
+                const struct phylink_link_state *state);
+
+/**
+ * mac_an_restart() - restart 802.3z BaseX autonegotiation
+ * @ndev: a pointer to a &struct net_device for the MAC.
+ */
+void mac_an_restart(struct net_device *ndev);
+
+/**
+ * mac_link_down() - take the link down
+ * @ndev: a pointer to a &struct net_device for the MAC.
+ * @mode: link autonegotiation mode
+ *
+ * If @mode is not an in-band negotiation mode (as defined by
+ * phylink_autoneg_inband()), force the link down and disable any
+ * Energy Efficient Ethernet MAC configuration.
+ */
+void mac_link_down(struct net_device *ndev, unsigned int mode);
+
+/**
+ * mac_link_up() - allow the link to come up
+ * @ndev: a pointer to a &struct net_device for the MAC.
+ * @mode: link autonegotiation mode
+ * @phy: any attached phy
+ *
+ * If @mode is not an in-band negotiation mode (as defined by
+ * phylink_autoneg_inband()), allow the link to come up. If @phy
+ * is non-%NULL, configure Energy Efficient Ethernet by calling
+ * phy_init_eee() and perform appropriate MAC configuration for EEE.
+ */
+void mac_link_up(struct net_device *ndev, unsigned int mode,
+                 struct phy_device *phy);
+#endif
+
+struct phylink *phylink_create(struct net_device *, struct fwnode_handle *,
         phy_interface_t iface, const struct phylink_mac_ops *ops);
 void phylink_destroy(struct phylink *);
 
 int phylink_connect_phy(struct phylink *, struct phy_device *);
-int phylink_of_phy_connect(struct phylink *, struct device_node *);
+int phylink_of_phy_connect(struct phylink *, struct device_node *, u32 flags);
 void phylink_disconnect_phy(struct phylink *);
+int phylink_fixed_state_cb(struct phylink *,
+                           void (*cb)(struct net_device *dev,
+                                      struct phylink_link_state *));
 
 void phylink_mac_change(struct phylink *, bool up);
 
@@ -128,7 +214,6 @@ int phylink_ethtool_set_pauseparam(struct phylink *,
 int phylink_ethtool_get_module_info(struct phylink *, struct ethtool_modinfo *);
 int phylink_ethtool_get_module_eeprom(struct phylink *,
                                       struct ethtool_eeprom *, u8 *);
-int phylink_init_eee(struct phylink *, bool);
 int phylink_get_eee_err(struct phylink *);
 int phylink_ethtool_get_eee(struct phylink *, struct ethtool_eee *);
 int phylink_ethtool_set_eee(struct phylink *, struct ethtool_eee *);
diff --git a/include/linux/pinctrl/devinfo.h b/include/linux/pinctrl/devinfo.h
index 05082e407c4a..d01a8638bb45 100644
--- a/include/linux/pinctrl/devinfo.h
+++ b/include/linux/pinctrl/devinfo.h
@@ -43,6 +43,8 @@ extern int pinctrl_init_done(struct device *dev);
 
 #else
 
+struct device;
+
 /* Stubs if we're not using pinctrl */
 
 static inline int pinctrl_bind_pins(struct device *dev)
diff --git a/include/linux/pinctrl/pinconf-generic.h b/include/linux/pinctrl/pinconf-generic.h
index ec6dadcc1fde..6c0680641108 100644
--- a/include/linux/pinctrl/pinconf-generic.h
+++ b/include/linux/pinctrl/pinconf-generic.h
@@ -94,6 +94,7 @@
  *      or latch delay (on outputs) this parameter (in a custom format)
  *      specifies the clock skew or latch delay. It typically controls how
  *      many double inverters are put in front of the line.
+ * @PIN_CONFIG_PERSIST_STATE: retain pin state across sleep or controller reset
  * @PIN_CONFIG_END: this is the last enumerator for pin configurations, if
  *      you need to pass in custom configurations to the pin controller, use
  *      PIN_CONFIG_END+1 as the base offset.
@@ -122,6 +123,7 @@ enum pin_config_param {
         PIN_CONFIG_SLEEP_HARDWARE_STATE,
         PIN_CONFIG_SLEW_RATE,
         PIN_CONFIG_SKEW_DELAY,
+        PIN_CONFIG_PERSIST_STATE,
         PIN_CONFIG_END = 0x7F,
         PIN_CONFIG_MAX = 0xFF,
 };
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index 5e45385c5bdc..8f5dbb84547a 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -18,6 +18,7 @@
 #include <linux/list.h>
 #include <linux/seq_file.h>
 #include <linux/pinctrl/pinctrl-state.h>
+#include <linux/pinctrl/devinfo.h>
 
 struct device;
 struct pinctrl_dev;
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index 2dc5e9870fcd..5a3bb3b7c9ad 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -167,10 +167,9 @@ void pipe_lock(struct pipe_inode_info *);
 void pipe_unlock(struct pipe_inode_info *);
 void pipe_double_lock(struct pipe_inode_info *, struct pipe_inode_info *);
 
-extern unsigned int pipe_max_size, pipe_min_size;
+extern unsigned int pipe_max_size;
 extern unsigned long pipe_user_pages_hard;
 extern unsigned long pipe_user_pages_soft;
-int pipe_proc_fn(struct ctl_table *, int, void __user *, size_t *, loff_t *);
 
 /* Drop the inode semaphore and wait for a pipe event, atomically */
 void pipe_wait(struct pipe_inode_info *pipe);
@@ -191,6 +190,6 @@ long pipe_fcntl(struct file *, unsigned int, unsigned long arg);
 struct pipe_inode_info *get_pipe_info(struct file *file);
 
 int create_pipe_files(struct file **, int);
-unsigned int round_pipe_size(unsigned int size);
+unsigned int round_pipe_size(unsigned long size);
 
 #endif
diff --git a/include/linux/platform_data/at24.h b/include/linux/platform_data/at24.h
index 271a4e25af67..63507ff464ee 100644
--- a/include/linux/platform_data/at24.h
+++ b/include/linux/platform_data/at24.h
@@ -50,6 +50,8 @@ struct at24_platform_data {
 #define AT24_FLAG_TAKE8ADDR     BIT(4)  /* take always 8 addresses (24c00) */
 #define AT24_FLAG_SERIAL        BIT(3)  /* factory-programmed serial number */
 #define AT24_FLAG_MAC           BIT(2)  /* factory-programmed mac address */
+#define AT24_FLAG_NO_RDROL      BIT(1)  /* does not auto-rollover reads to */
+                                        /* the next slave address */
 
         void            (*setup)(struct nvmem_device *nvmem, void *context);
         void            *context;
diff --git a/include/linux/platform_data/i2c-davinci.h b/include/linux/platform_data/i2c-davinci.h
index 89fd34727a24..98967df07468 100644
--- a/include/linux/platform_data/i2c-davinci.h
+++ b/include/linux/platform_data/i2c-davinci.h
@@ -16,9 +16,8 @@
 struct davinci_i2c_platform_data {
         unsigned int    bus_freq;       /* standard bus frequency (kHz) */
         unsigned int    bus_delay;      /* post-transaction delay (usec) */
-        unsigned int    sda_pin;        /* GPIO pin ID to use for SDA */
-        unsigned int    scl_pin;        /* GPIO pin ID to use for SCL */
-        bool            has_pfunc;      /*chip has a ICPFUNC register */
+        bool            gpio_recovery;  /* Use GPIO recovery method */
+        bool            has_pfunc;      /* Chip has a ICPFUNC register */
 };
 
 /* for board setup code */
diff --git a/include/linux/i2c/pxa-i2c.h b/include/linux/platform_data/i2c-pxa.h
index 53aab243cbd8..5236f216dfae 100644
--- a/include/linux/i2c/pxa-i2c.h
+++ b/include/linux/platform_data/i2c-pxa.h
@@ -71,15 +71,4 @@ struct i2c_pxa_platform_data {
         unsigned char           master_code;
         unsigned long           rate;
 };
-
-extern void pxa_set_i2c_info(struct i2c_pxa_platform_data *info);
-
-#ifdef CONFIG_PXA27x
-extern void pxa27x_set_i2c_power_info(struct i2c_pxa_platform_data *info);
-#endif
-
-#ifdef CONFIG_PXA3xx
-extern void pxa3xx_set_i2c_power_info(struct i2c_pxa_platform_data *info);
-#endif
-
 #endif
diff --git a/include/linux/platform_data/mlxcpld-hotplug.h b/include/linux/platform_data/mlxcpld-hotplug.h
deleted file mode 100644
index e4cfcffaa6f4..000000000000
--- a/include/linux/platform_data/mlxcpld-hotplug.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * include/linux/platform_data/mlxcpld-hotplug.h
- * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
- * Copyright (c) 2016 Vadim Pasternak <vadimp@mellanox.com>
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the names of the copyright holders nor the names of its
- *    contributors may be used to endorse or promote products derived from
- *    this software without specific prior written permission.
- *
- * Alternatively, this software may be distributed under the terms of the
- * GNU General Public License ("GPL") version 2 as published by the Free
- * Software Foundation.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __LINUX_PLATFORM_DATA_MLXCPLD_HOTPLUG_H
-#define __LINUX_PLATFORM_DATA_MLXCPLD_HOTPLUG_H
-
-/**
- * struct mlxcpld_hotplug_device - I2C device data:
- * @adapter: I2C device adapter;
- * @client: I2C device client;
- * @brdinfo: device board information;
- * @bus: I2C bus, where device is attached;
- *
- * Structure represents I2C hotplug device static data (board topology) and
- * dynamic data (related kernel objects handles).
- */
-struct mlxcpld_hotplug_device {
-        struct i2c_adapter *adapter;
-        struct i2c_client *client;
-        struct i2c_board_info brdinfo;
-        u16 bus;
-};
-
-/**
- * struct mlxcpld_hotplug_platform_data - device platform data:
- * @top_aggr_offset: offset of top aggregation interrupt register;
- * @top_aggr_mask: top aggregation interrupt common mask;
- * @top_aggr_psu_mask: top aggregation interrupt PSU mask;
- * @psu_reg_offset: offset of PSU interrupt register;
- * @psu_mask: PSU interrupt mask;
- * @psu_count: number of equipped replaceable PSUs;
- * @psu: pointer to PSU devices data array;
- * @top_aggr_pwr_mask: top aggregation interrupt power mask;
- * @pwr_reg_offset: offset of power interrupt register
- * @pwr_mask: power interrupt mask;
- * @pwr_count: number of power sources;
- * @pwr: pointer to power devices data array;
- * @top_aggr_fan_mask: top aggregation interrupt FAN mask;
- * @fan_reg_offset: offset of FAN interrupt register;
- * @fan_mask: FAN interrupt mask;
- * @fan_count: number of equipped replaceable FANs;
- * @fan: pointer to FAN devices data array;
- *
- * Structure represents board platform data, related to system hotplug events,
- * like FAN, PSU, power cable insertion and removing. This data provides the
- * number of hot-pluggable devices and hardware description for event handling.
- */
-struct mlxcpld_hotplug_platform_data {
-        u16 top_aggr_offset;
-        u8 top_aggr_mask;
-        u8 top_aggr_psu_mask;
-        u16 psu_reg_offset;
-        u8 psu_mask;
-        u8 psu_count;
-        struct mlxcpld_hotplug_device *psu;
-        u8 top_aggr_pwr_mask;
-        u16 pwr_reg_offset;
-        u8 pwr_mask;
-        u8 pwr_count;
-        struct mlxcpld_hotplug_device *pwr;
-        u8 top_aggr_fan_mask;
-        u16 fan_reg_offset;
-        u8 fan_mask;
-        u8 fan_count;
-        struct mlxcpld_hotplug_device *fan;
-};
-
-#endif /* __LINUX_PLATFORM_DATA_MLXCPLD_HOTPLUG_H */
diff --git a/include/linux/platform_data/mlxreg.h b/include/linux/platform_data/mlxreg.h
new file mode 100644
index 000000000000..fcdc707eab99
--- /dev/null
+++ b/include/linux/platform_data/mlxreg.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
+ * Copyright (c) 2017 Vadim Pasternak <vadimp@mellanox.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the names of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __LINUX_PLATFORM_DATA_MLXREG_H
+#define __LINUX_PLATFORM_DATA_MLXREG_H
+
+#define MLXREG_CORE_LABEL_MAX_SIZE      32
+
+/**
+ * struct mlxreg_hotplug_device - I2C device data:
+ *
+ * @adapter: I2C device adapter;
+ * @client: I2C device client;
+ * @brdinfo: device board information;
+ * @nr: I2C device adapter number, to which device is to be attached;
+ *
+ * Structure represents I2C hotplug device static data (board topology) and
+ * dynamic data (related kernel objects handles).
+ */
+struct mlxreg_hotplug_device {
+        struct i2c_adapter *adapter;
+        struct i2c_client *client;
+        struct i2c_board_info *brdinfo;
+        int nr;
+};
+
+/**
+ * struct mlxreg_core_data - attributes control data:
+ *
+ * @label: attribute label;
+ * @label: attribute register offset;
+ * @reg: attribute register;
+ * @mask: attribute access mask;
+ * @mode: access mode;
+ * @bit: attribute effective bit;
+ * @np - pointer to node platform associated with attribute;
+ * @hpdev - hotplug device data;
+ * @health_cntr: dynamic device health indication counter;
+ * @attached: true if device has been attached after good health indication;
+ */
+struct mlxreg_core_data {
+        char label[MLXREG_CORE_LABEL_MAX_SIZE];
+        u32 reg;
+        u32 mask;
+        u32 bit;
+        umode_t mode;
+        struct device_node *np;
+        struct mlxreg_hotplug_device hpdev;
+        u8 health_cntr;
+        bool attached;
+};
+
+/**
+ * struct mlxreg_core_item - same type components controlled by the driver:
+ *
+ * @data: component data;
+ * @aggr_mask: group aggregation mask;
+ * @reg: group interrupt status register;
+ * @mask: group interrupt mask;
+ * @cache: last status value for elements fro the same group;
+ * @count: number of available elements in the group;
+ * @ind: element's index inside the group;
+ * @inversed: if 0: 0 for signal status is OK, if 1 - 1 is OK;
+ * @health: true if device has health indication, false in other case;
+ */
+struct mlxreg_core_item {
+        struct mlxreg_core_data *data;
+        u32 aggr_mask;
+        u32 reg;
+        u32 mask;
+        u32 cache;
+        u8 count;
+        u8 ind;
+        u8 inversed;
+        u8 health;
+};
+
+/**
+ * struct mlxreg_core_platform_data - platform data:
+ *
+ * @led_data: led private data;
+ * @regmap: register map of parent device;
+ * @counter: number of led instances;
+ */
+struct mlxreg_core_platform_data {
+        struct mlxreg_core_data *data;
+        void *regmap;
+        int counter;
+};
+
+/**
+ * struct mlxreg_core_hotplug_platform_data - hotplug platform data:
+ *
+ * @items: same type components with the hotplug capability;
+ * @irq: platform interrupt number;
+ * @regmap: register map of parent device;
+ * @counter: number of the components with the hotplug capability;
+ * @cell: location of top aggregation interrupt register;
+ * @mask: top aggregation interrupt common mask;
+ * @cell_low: location of low aggregation interrupt register;
+ * @mask_low: low aggregation interrupt common mask;
+ */
+struct mlxreg_core_hotplug_platform_data {
+        struct mlxreg_core_item *items;
+        int irq;
+        void *regmap;
+        int counter;
+        u32 cell;
+        u32 mask;
+        u32 cell_low;
+        u32 mask_low;
+};
+
+#endif /* __LINUX_PLATFORM_DATA_MLXREG_H */
diff --git a/include/linux/platform_data/mms114.h b/include/linux/platform_data/mms114.h
deleted file mode 100644
index 5722ebfb2738..000000000000
--- a/include/linux/platform_data/mms114.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2012 Samsung Electronics Co.Ltd
- * Author: Joonyoung Shim <jy0922.shim@samsung.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 Foundationr
- */
-
-#ifndef __LINUX_MMS114_H
-#define __LINUX_MMS114_H
-
-struct mms114_platform_data {
-        unsigned int x_size;
-        unsigned int y_size;
-        unsigned int contact_threshold;
-        unsigned int moving_threshold;
-        bool x_invert;
-        bool y_invert;
-
-        void (*cfg_pin)(bool);
-};
-
-#endif  /* __LINUX_MMS114_H */
diff --git a/include/linux/platform_data/mtd-onenand-omap2.h b/include/linux/platform_data/mtd-onenand-omap2.h
deleted file mode 100644
index 56ff0e6f5ad1..000000000000
--- a/include/linux/platform_data/mtd-onenand-omap2.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2006 Nokia Corporation
- * Author: Juha Yrjola
- *
- * 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 __MTD_ONENAND_OMAP2_H
-#define __MTD_ONENAND_OMAP2_H
-
-#include <linux/mtd/mtd.h>
-#include <linux/mtd/partitions.h>
-
-#define ONENAND_SYNC_READ       (1 << 0)
-#define ONENAND_SYNC_READWRITE  (1 << 1)
-#define ONENAND_IN_OMAP34XX     (1 << 2)
-
-struct omap_onenand_platform_data {
-        int                     cs;
-        int                     gpio_irq;
-        struct mtd_partition    *parts;
-        int                     nr_parts;
-        int                     (*onenand_setup)(void __iomem *, int *freq_ptr);
-        int                     dma_channel;
-        u8                      flags;
-        u8                      regulator_can_sleep;
-        u8                      skip_initial_unlocking;
-
-        /* for passing the partitions */
-        struct device_node      *of_node;
-};
-#endif
diff --git a/include/linux/platform_data/si5351.h b/include/linux/platform_data/si5351.h
index 818c5c6e203f..c71a2dd66143 100644
--- a/include/linux/platform_data/si5351.h
+++ b/include/linux/platform_data/si5351.h
@@ -86,6 +86,7 @@ enum si5351_disable_state {
  * @multisynth_src: multisynth source clock
  * @clkout_src: clkout source clock
  * @pll_master: if true, clkout can also change pll rate
+ * @pll_reset: if true, clkout can reset its pll
  * @drive: output drive strength
  * @rate: initial clkout rate, or default if 0
  */
@@ -95,6 +96,7 @@ struct si5351_clkout_config {
         enum si5351_drive_strength drive;
         enum si5351_disable_state disable_state;
         bool pll_master;
+        bool pll_reset;
         unsigned long rate;
 };
 
diff --git a/include/linux/platform_data/spi-s3c64xx.h b/include/linux/platform_data/spi-s3c64xx.h
index da79774078a7..773daf7915a3 100644
--- a/include/linux/platform_data/spi-s3c64xx.h
+++ b/include/linux/platform_data/spi-s3c64xx.h
@@ -1,10 +1,8 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
 /*
  * Copyright (C) 2009 Samsung Electronics Ltd.
  *      Jaswinder Singh <jassi.brar@samsung.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 __SPI_S3C64XX_H
diff --git a/include/linux/platform_data/ti-sysc.h b/include/linux/platform_data/ti-sysc.h
new file mode 100644
index 000000000000..1be356330b96
--- /dev/null
+++ b/include/linux/platform_data/ti-sysc.h
@@ -0,0 +1,86 @@
+#ifndef __TI_SYSC_DATA_H__
+#define __TI_SYSC_DATA_H__
+
+enum ti_sysc_module_type {
+        TI_SYSC_OMAP2,
+        TI_SYSC_OMAP2_TIMER,
+        TI_SYSC_OMAP3_SHAM,
+        TI_SYSC_OMAP3_AES,
+        TI_SYSC_OMAP4,
+        TI_SYSC_OMAP4_TIMER,
+        TI_SYSC_OMAP4_SIMPLE,
+        TI_SYSC_OMAP34XX_SR,
+        TI_SYSC_OMAP36XX_SR,
+        TI_SYSC_OMAP4_SR,
+        TI_SYSC_OMAP4_MCASP,
+        TI_SYSC_OMAP4_USB_HOST_FS,
+};
+
+/**
+ * struct sysc_regbits - TI OCP_SYSCONFIG register field offsets
+ * @midle_shift: Offset of the midle bit
+ * @clkact_shift: Offset of the clockactivity bit
+ * @sidle_shift: Offset of the sidle bit
+ * @enwkup_shift: Offset of the enawakeup bit
+ * @srst_shift: Offset of the softreset bit
+ * @autoidle_shift: Offset of the autoidle bit
+ * @dmadisable_shift: Offset of the dmadisable bit
+ * @emufree_shift; Offset of the emufree bit
+ *
+ * Note that 0 is a valid shift, and for ti-sysc.c -ENODEV can be used if a
+ * feature is not available.
+ */
+struct sysc_regbits {
+        s8 midle_shift;
+        s8 clkact_shift;
+        s8 sidle_shift;
+        s8 enwkup_shift;
+        s8 srst_shift;
+        s8 autoidle_shift;
+        s8 dmadisable_shift;
+        s8 emufree_shift;
+};
+
+#define SYSC_QUIRK_RESET_STATUS         BIT(7)
+#define SYSC_QUIRK_NO_IDLE_ON_INIT      BIT(6)
+#define SYSC_QUIRK_NO_RESET_ON_INIT     BIT(5)
+#define SYSC_QUIRK_OPT_CLKS_NEEDED      BIT(4)
+#define SYSC_QUIRK_OPT_CLKS_IN_RESET    BIT(3)
+#define SYSC_QUIRK_16BIT                BIT(2)
+#define SYSC_QUIRK_UNCACHED             BIT(1)
+#define SYSC_QUIRK_USE_CLOCKACT         BIT(0)
+
+#define SYSC_NR_IDLEMODES               4
+
+/**
+ * struct sysc_capabilities - capabilities for an interconnect target module
+ *
+ * @sysc_mask: bitmask of supported SYSCONFIG register bits
+ * @regbits: bitmask of SYSCONFIG register bits
+ * @mod_quirks: bitmask of module specific quirks
+ */
+struct sysc_capabilities {
+        const enum ti_sysc_module_type type;
+        const u32 sysc_mask;
+        const struct sysc_regbits *regbits;
+        const u32 mod_quirks;
+};
+
+/**
+ * struct sysc_config - configuration for an interconnect target module
+ * @sysc_val: configured value for sysc register
+ * @midlemodes: bitmask of supported master idle modes
+ * @sidlemodes: bitmask of supported master idle modes
+ * @srst_udelay: optional delay needed after OCP soft reset
+ * @quirks: bitmask of enabled quirks
+ */
+struct sysc_config {
+        u32 sysc_val;
+        u32 syss_mask;
+        u8 midlemodes;
+        u8 sidlemodes;
+        u8 srst_udelay;
+        u32 quirks;
+};
+
+#endif  /* __TI_SYSC_DATA_H__ */
diff --git a/include/linux/poll.h b/include/linux/poll.h
index d384f12abdd5..04781a753326 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -37,7 +37,7 @@ typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_
  */
 typedef struct poll_table_struct {
         poll_queue_proc _qproc;
-        unsigned long _key;
+        __poll_t _key;
 } poll_table;
 
 static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
@@ -62,20 +62,20 @@ static inline bool poll_does_not_wait(const poll_table *p)
  * to be started implicitly on poll(). You typically only want to do that
  * if the application is actually polling for POLLIN and/or POLLOUT.
  */
-static inline unsigned long poll_requested_events(const poll_table *p)
+static inline __poll_t poll_requested_events(const poll_table *p)
 {
-        return p ? p->_key : ~0UL;
+        return p ? p->_key : ~(__poll_t)0;
 }
 
 static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
 {
         pt->_qproc = qproc;
-        pt->_key   = ~0UL; /* all events enabled */
+        pt->_key   = ~(__poll_t)0; /* all events enabled */
 }
 
 struct poll_table_entry {
         struct file *filp;
-        unsigned long key;
+        __poll_t key;
         wait_queue_entry_t wait;
         wait_queue_head_t *wait_address;
 };
diff --git a/include/linux/posix-clock.h b/include/linux/posix-clock.h
index 38d8225510f1..3a3bc71017d5 100644
--- a/include/linux/posix-clock.h
+++ b/include/linux/posix-clock.h
@@ -68,7 +68,7 @@ struct posix_clock_operations {
 
         int     (*open)    (struct posix_clock *pc, fmode_t f_mode);
 
-        uint    (*poll)    (struct posix_clock *pc,
+        __poll_t (*poll)   (struct posix_clock *pc,
                             struct file *file, poll_table *wait);
 
         int     (*release) (struct posix_clock *pc);
diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index 672c4f32311e..c85704fcdbd2 100644
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -42,13 +42,26 @@ struct cpu_timer_list {
 #define CLOCKFD                 CPUCLOCK_MAX
 #define CLOCKFD_MASK            (CPUCLOCK_PERTHREAD_MASK|CPUCLOCK_CLOCK_MASK)
 
-#define MAKE_PROCESS_CPUCLOCK(pid, clock) \
-        ((~(clockid_t) (pid) << 3) | (clockid_t) (clock))
-#define MAKE_THREAD_CPUCLOCK(tid, clock) \
-        MAKE_PROCESS_CPUCLOCK((tid), (clock) | CPUCLOCK_PERTHREAD_MASK)
+static inline clockid_t make_process_cpuclock(const unsigned int pid,
+                const clockid_t clock)
+{
+        return ((~pid) << 3) | clock;
+}
+static inline clockid_t make_thread_cpuclock(const unsigned int tid,
+                const clockid_t clock)
+{
+        return make_process_cpuclock(tid, clock | CPUCLOCK_PERTHREAD_MASK);
+}
 
-#define FD_TO_CLOCKID(fd)       ((~(clockid_t) (fd) << 3) | CLOCKFD)
-#define CLOCKID_TO_FD(clk)      ((unsigned int) ~((clk) >> 3))
+static inline clockid_t fd_to_clockid(const int fd)
+{
+        return make_process_cpuclock((unsigned int) fd, CLOCKFD);
+}
+
+static inline int clockid_to_fd(const clockid_t clk)
+{
+        return ~(clk >> 3);
+}
 
 #define REQUEUE_PENDING 1
 
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index b2b7255ec7f5..540595a321a7 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -12,6 +12,7 @@
 #include <linux/bug.h>
 #include <linux/slab.h>
 #include <linux/rcupdate.h>
+#include <linux/refcount.h>
 #include <uapi/linux/posix_acl.h>
 
 struct posix_acl_entry {
@@ -24,7 +25,7 @@ struct posix_acl_entry {
 };
 
 struct posix_acl {
-        atomic_t                a_refcount;
+        refcount_t              a_refcount;
         struct rcu_head         a_rcu;
         unsigned int            a_count;
         struct posix_acl_entry  a_entries[0];
@@ -41,7 +42,7 @@ static inline struct posix_acl *
 posix_acl_dup(struct posix_acl *acl)
 {
         if (acl)
-                atomic_inc(&acl->a_refcount);
+                refcount_inc(&acl->a_refcount);
         return acl;
 }
 
@@ -51,7 +52,7 @@ posix_acl_dup(struct posix_acl *acl)
 static inline void
 posix_acl_release(struct posix_acl *acl)
 {
-        if (acl && atomic_dec_and_test(&acl->a_refcount))
+        if (acl && refcount_dec_and_test(&acl->a_refcount))
                 kfree_rcu(acl, a_rcu);
 }
 
diff --git a/include/linux/power/bq27xxx_battery.h b/include/linux/power/bq27xxx_battery.h
index e6187f524f2c..01fbf1b16258 100644
--- a/include/linux/power/bq27xxx_battery.h
+++ b/include/linux/power/bq27xxx_battery.h
@@ -16,6 +16,7 @@ enum bq27xxx_chip {
         BQ27520G2, /* bq27520G2 */
         BQ27520G3, /* bq27520G3 */
         BQ27520G4, /* bq27520G4 */
+        BQ27521, /* bq27521 */
         BQ27530, /* bq27530, bq27531 */
         BQ27531,
         BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
diff --git a/include/linux/proc_ns.h b/include/linux/proc_ns.h
index 2ff18c9840a7..d31cb6215905 100644
--- a/include/linux/proc_ns.h
+++ b/include/linux/proc_ns.h
@@ -78,6 +78,9 @@ extern struct file *proc_ns_fget(int fd);
 #define get_proc_ns(inode) ((struct ns_common *)(inode)->i_private)
 extern void *ns_get_path(struct path *path, struct task_struct *task,
                         const struct proc_ns_operations *ns_ops);
+typedef struct ns_common *ns_get_path_helper_t(void *);
+extern void *ns_get_path_cb(struct path *path, ns_get_path_helper_t ns_get_cb,
+                            void *private_data);
 
 extern int ns_get_name(char *buf, size_t size, struct task_struct *task,
                         const struct proc_ns_operations *ns_ops);
diff --git a/include/linux/property.h b/include/linux/property.h
index f6189a3ac63c..769d372c1edf 100644
--- a/include/linux/property.h
+++ b/include/linux/property.h
@@ -83,11 +83,17 @@ struct fwnode_handle *fwnode_get_next_parent(
         struct fwnode_handle *fwnode);
 struct fwnode_handle *fwnode_get_next_child_node(
         const struct fwnode_handle *fwnode, struct fwnode_handle *child);
+struct fwnode_handle *fwnode_get_next_available_child_node(
+        const struct fwnode_handle *fwnode, struct fwnode_handle *child);
 
 #define fwnode_for_each_child_node(fwnode, child)                       \
         for (child = fwnode_get_next_child_node(fwnode, NULL); child;   \
              child = fwnode_get_next_child_node(fwnode, child))
 
+#define fwnode_for_each_available_child_node(fwnode, child)                    \
+        for (child = fwnode_get_next_available_child_node(fwnode, NULL); child;\
+             child = fwnode_get_next_available_child_node(fwnode, child))
+
 struct fwnode_handle *device_get_next_child_node(
         struct device *dev, struct fwnode_handle *child);
 
@@ -103,6 +109,8 @@ struct fwnode_handle *device_get_named_child_node(struct device *dev,
 struct fwnode_handle *fwnode_handle_get(struct fwnode_handle *fwnode);
 void fwnode_handle_put(struct fwnode_handle *fwnode);
 
+int fwnode_irq_get(struct fwnode_handle *fwnode, unsigned int index);
+
 unsigned int device_get_child_node_count(struct device *dev);
 
 static inline bool device_property_read_bool(struct device *dev,
@@ -206,7 +214,7 @@ struct property_entry {
  */
 
 #define PROPERTY_ENTRY_INTEGER_ARRAY(_name_, _type_, _val_)     \
-{                                                               \
+(struct property_entry) {                                       \
         .name = _name_,                                         \
         .length = ARRAY_SIZE(_val_) * sizeof(_type_),           \
         .is_array = true,                                       \
@@ -224,7 +232,7 @@ struct property_entry {
         PROPERTY_ENTRY_INTEGER_ARRAY(_name_, u64, _val_)
 
 #define PROPERTY_ENTRY_STRING_ARRAY(_name_, _val_)              \
-{                                                               \
+(struct property_entry) {                                       \
         .name = _name_,                                         \
         .length = ARRAY_SIZE(_val_) * sizeof(const char *),     \
         .is_array = true,                                       \
@@ -233,7 +241,7 @@ struct property_entry {
 }
 
 #define PROPERTY_ENTRY_INTEGER(_name_, _type_, _val_)   \
-{                                                       \
+(struct property_entry) {                               \
         .name = _name_,                                 \
         .length = sizeof(_type_),                       \
         .is_string = false,                             \
@@ -250,7 +258,7 @@ struct property_entry {
         PROPERTY_ENTRY_INTEGER(_name_, u64, _val_)
 
 #define PROPERTY_ENTRY_STRING(_name_, _val_)            \
-{                                                       \
+(struct property_entry) {                               \
         .name = _name_,                                 \
         .length = sizeof(_val_),                        \
         .is_string = true,                              \
@@ -258,7 +266,7 @@ struct property_entry {
 }
 
 #define PROPERTY_ENTRY_BOOL(_name_)             \
-{                                               \
+(struct property_entry) {                       \
         .name = _name_,                         \
 }
 
@@ -275,10 +283,15 @@ bool device_dma_supported(struct device *dev);
 
 enum dev_dma_attr device_get_dma_attr(struct device *dev);
 
+void *device_get_match_data(struct device *dev);
+
 int device_get_phy_mode(struct device *dev);
 
 void *device_get_mac_address(struct device *dev, char *addr, int alen);
 
+int fwnode_get_phy_mode(struct fwnode_handle *fwnode);
+void *fwnode_get_mac_address(struct fwnode_handle *fwnode,
+                             char *addr, int alen);
 struct fwnode_handle *fwnode_graph_get_next_endpoint(
         const struct fwnode_handle *fwnode, struct fwnode_handle *prev);
 struct fwnode_handle *
diff --git a/include/linux/psci.h b/include/linux/psci.h
index bdea1cb5e1db..8b1b3b5935ab 100644
--- a/include/linux/psci.h
+++ b/include/linux/psci.h
@@ -25,7 +25,19 @@ bool psci_tos_resident_on(int cpu);
 int psci_cpu_init_idle(unsigned int cpu);
 int psci_cpu_suspend_enter(unsigned long index);
 
+enum psci_conduit {
+        PSCI_CONDUIT_NONE,
+        PSCI_CONDUIT_SMC,
+        PSCI_CONDUIT_HVC,
+};
+
+enum smccc_version {
+        SMCCC_VERSION_1_0,
+        SMCCC_VERSION_1_1,
+};
+
 struct psci_operations {
+        u32 (*get_version)(void);
         int (*cpu_suspend)(u32 state, unsigned long entry_point);
         int (*cpu_off)(u32 state);
         int (*cpu_on)(unsigned long cpuid, unsigned long entry_point);
@@ -33,6 +45,8 @@ struct psci_operations {
         int (*affinity_info)(unsigned long target_affinity,
                         unsigned long lowest_affinity_level);
         int (*migrate_info_type)(void);
+        enum psci_conduit conduit;
+        enum smccc_version smccc_version;
 };
 
 extern struct psci_operations psci_ops;
@@ -46,10 +60,11 @@ static inline int psci_dt_init(void) { return 0; }
 #if defined(CONFIG_ARM_PSCI_FW) && defined(CONFIG_ACPI)
 int __init psci_acpi_init(void);
 bool __init acpi_psci_present(void);
-bool __init acpi_psci_use_hvc(void);
+bool acpi_psci_use_hvc(void);
 #else
 static inline int psci_acpi_init(void) { return 0; }
 static inline bool acpi_psci_present(void) { return false; }
+static inline bool acpi_psci_use_hvc(void) {return false; }
 #endif
 
 #endif /* __LINUX_PSCI_H */
diff --git a/include/linux/ptr_ring.h b/include/linux/ptr_ring.h
index d72b2e7dd500..1883d6137e9b 100644
--- a/include/linux/ptr_ring.h
+++ b/include/linux/ptr_ring.h
@@ -45,9 +45,10 @@ struct ptr_ring {
 };
 
 /* Note: callers invoking this in a loop must use a compiler barrier,
- * for example cpu_relax().  If ring is ever resized, callers must hold
- * producer_lock - see e.g. ptr_ring_full.  Otherwise, if callers don't hold
- * producer_lock, the next call to __ptr_ring_produce may fail.
+ * for example cpu_relax().
+ *
+ * NB: this is unlike __ptr_ring_empty in that callers must hold producer_lock:
+ * see e.g. ptr_ring_full.
  */
 static inline bool __ptr_ring_full(struct ptr_ring *r)
 {
@@ -113,7 +114,7 @@ static inline int __ptr_ring_produce(struct ptr_ring *r, void *ptr)
         /* Pairs with smp_read_barrier_depends in __ptr_ring_consume. */
         smp_wmb();
 
-        r->queue[r->producer++] = ptr;
+        WRITE_ONCE(r->queue[r->producer++], ptr);
         if (unlikely(r->producer >= r->size))
                 r->producer = 0;
         return 0;
@@ -169,32 +170,36 @@ static inline int ptr_ring_produce_bh(struct ptr_ring *r, void *ptr)
         return ret;
 }
 
-/* Note: callers invoking this in a loop must use a compiler barrier,
- * for example cpu_relax(). Callers must take consumer_lock
- * if they dereference the pointer - see e.g. PTR_RING_PEEK_CALL.
- * If ring is never resized, and if the pointer is merely
- * tested, there's no need to take the lock - see e.g.  __ptr_ring_empty.
- * However, if called outside the lock, and if some other CPU
- * consumes ring entries at the same time, the value returned
- * is not guaranteed to be correct.
- * In this case - to avoid incorrectly detecting the ring
- * as empty - the CPU consuming the ring entries is responsible
- * for either consuming all ring entries until the ring is empty,
- * or synchronizing with some other CPU and causing it to
- * execute __ptr_ring_peek and/or consume the ring enteries
- * after the synchronization point.
- */
 static inline void *__ptr_ring_peek(struct ptr_ring *r)
 {
         if (likely(r->size))
-                return r->queue[r->consumer_head];
+                return READ_ONCE(r->queue[r->consumer_head]);
         return NULL;
 }
 
-/* See __ptr_ring_peek above for locking rules. */
+/*
+ * Test ring empty status without taking any locks.
+ *
+ * NB: This is only safe to call if ring is never resized.
+ *
+ * However, if some other CPU consumes ring entries at the same time, the value
+ * returned is not guaranteed to be correct.
+ *
+ * In this case - to avoid incorrectly detecting the ring
+ * as empty - the CPU consuming the ring entries is responsible
+ * for either consuming all ring entries until the ring is empty,
+ * or synchronizing with some other CPU and causing it to
+ * re-test __ptr_ring_empty and/or consume the ring enteries
+ * after the synchronization point.
+ *
+ * Note: callers invoking this in a loop must use a compiler barrier,
+ * for example cpu_relax().
+ */
 static inline bool __ptr_ring_empty(struct ptr_ring *r)
 {
-        return !__ptr_ring_peek(r);
+        if (likely(r->size))
+                return !r->queue[READ_ONCE(r->consumer_head)];
+        return true;
 }
 
 static inline bool ptr_ring_empty(struct ptr_ring *r)
@@ -248,22 +253,28 @@ static inline void __ptr_ring_discard_one(struct ptr_ring *r)
         /* Fundamentally, what we want to do is update consumer
          * index and zero out the entry so producer can reuse it.
          * Doing it naively at each consume would be as simple as:
-         *       r->queue[r->consumer++] = NULL;
-         *       if (unlikely(r->consumer >= r->size))
-         *               r->consumer = 0;
+         *       consumer = r->consumer;
+         *       r->queue[consumer++] = NULL;
+         *       if (unlikely(consumer >= r->size))
+         *               consumer = 0;
+         *       r->consumer = consumer;
          * but that is suboptimal when the ring is full as producer is writing
          * out new entries in the same cache line.  Defer these updates until a
          * batch of entries has been consumed.
          */
-        int head = r->consumer_head++;
+        /* Note: we must keep consumer_head valid at all times for __ptr_ring_empty
+         * to work correctly.
+         */
+        int consumer_head = r->consumer_head;
+        int head = consumer_head++;
 
         /* Once we have processed enough entries invalidate them in
          * the ring all at once so producer can reuse their space in the ring.
          * We also do this when we reach end of the ring - not mandatory
          * but helps keep the implementation simple.
          */
-        if (unlikely(r->consumer_head - r->consumer_tail >= r->batch ||
-                     r->consumer_head >= r->size)) {
+        if (unlikely(consumer_head - r->consumer_tail >= r->batch ||
+                     consumer_head >= r->size)) {
                 /* Zero out entries in the reverse order: this way we touch the
                  * cache line that producer might currently be reading the last;
                  * producer won't make progress and touch other cache lines
@@ -271,12 +282,14 @@ static inline void __ptr_ring_discard_one(struct ptr_ring *r)
                  */
                 while (likely(head >= r->consumer_tail))
                         r->queue[head--] = NULL;
-                r->consumer_tail = r->consumer_head;
+                r->consumer_tail = consumer_head;
         }
-        if (unlikely(r->consumer_head >= r->size)) {
-                r->consumer_head = 0;
+        if (unlikely(consumer_head >= r->size)) {
+                consumer_head = 0;
                 r->consumer_tail = 0;
         }
+        /* matching READ_ONCE in __ptr_ring_empty for lockless tests */
+        WRITE_ONCE(r->consumer_head, consumer_head);
 }
 
 static inline void *__ptr_ring_consume(struct ptr_ring *r)
@@ -527,7 +540,9 @@ static inline void ptr_ring_unconsume(struct ptr_ring *r, void **batch, int n,
                         goto done;
                 }
                 r->queue[head] = batch[--n];
-                r->consumer_tail = r->consumer_head = head;
+                r->consumer_tail = head;
+                /* matching READ_ONCE in __ptr_ring_empty for lockless tests */
+                WRITE_ONCE(r->consumer_head, head);
         }
 
 done:
diff --git a/include/linux/qcom_scm.h b/include/linux/qcom_scm.h
index 1fd27d68926b..b401b962afff 100644
--- a/include/linux/qcom_scm.h
+++ b/include/linux/qcom_scm.h
@@ -13,6 +13,9 @@
 #ifndef __QCOM_SCM_H
 #define __QCOM_SCM_H
 
+#include <linux/types.h>
+#include <linux/cpumask.h>
+
 #define QCOM_SCM_VERSION(major, minor)  (((major) << 16) | ((minor) & 0xFF))
 #define QCOM_SCM_CPU_PWR_DOWN_L2_ON     0x0
 #define QCOM_SCM_CPU_PWR_DOWN_L2_OFF    0x1
diff --git a/include/linux/qed/common_hsi.h b/include/linux/qed/common_hsi.h
index 39e2a2ac2471..2b3b350e07b7 100644
--- a/include/linux/qed/common_hsi.h
+++ b/include/linux/qed/common_hsi.h
@@ -32,14 +32,15 @@
 
 #ifndef _COMMON_HSI_H
 #define _COMMON_HSI_H
+
 #include <linux/types.h>
 #include <asm/byteorder.h>
 #include <linux/bitops.h>
 #include <linux/slab.h>
 
 /* dma_addr_t manip */
-#define PTR_LO(x)               ((u32)(((uintptr_t)(x)) & 0xffffffff))
-#define PTR_HI(x)               ((u32)((((uintptr_t)(x)) >> 16) >> 16))
+#define PTR_LO(x)               ((u32)(((uintptr_t)(x)) & 0xffffffff))
+#define PTR_HI(x)               ((u32)((((uintptr_t)(x)) >> 16) >> 16))
 #define DMA_LO_LE(x)            cpu_to_le32(lower_32_bits(x))
 #define DMA_HI_LE(x)            cpu_to_le32(upper_32_bits(x))
 #define DMA_REGPAIR_LE(x, val)  do { \
@@ -47,39 +48,45 @@
                                         (x).lo = DMA_LO_LE((val)); \
                                 } while (0)
 
-#define HILO_GEN(hi, lo, type)  ((((type)(hi)) << 32) + (lo))
-#define HILO_64(hi, lo) HILO_GEN((le32_to_cpu(hi)), (le32_to_cpu(lo)), u64)
-#define HILO_64_REGPAIR(regpair)        (HILO_64(regpair.hi, regpair.lo))
+#define HILO_GEN(hi, lo, type)          ((((type)(hi)) << 32) + (lo))
+#define HILO_64(hi, lo) \
+        HILO_GEN(le32_to_cpu(hi), le32_to_cpu(lo), u64)
+#define HILO_64_REGPAIR(regpair) ({ \
+        typeof(regpair) __regpair = (regpair); \
+        HILO_64(__regpair.hi, __regpair.lo); })
 #define HILO_DMA_REGPAIR(regpair)       ((dma_addr_t)HILO_64_REGPAIR(regpair))
 
 #ifndef __COMMON_HSI__
 #define __COMMON_HSI__
 
+/********************************/
+/* PROTOCOL COMMON FW CONSTANTS */
+/********************************/
 
-#define X_FINAL_CLEANUP_AGG_INT 1
+#define X_FINAL_CLEANUP_AGG_INT                 1
 
-#define EVENT_RING_PAGE_SIZE_BYTES          4096
+#define EVENT_RING_PAGE_SIZE_BYTES              4096
 
-#define NUM_OF_GLOBAL_QUEUES                            128
-#define COMMON_QUEUE_ENTRY_MAX_BYTE_SIZE        64
+#define NUM_OF_GLOBAL_QUEUES                    128
+#define COMMON_QUEUE_ENTRY_MAX_BYTE_SIZE        64
 
-#define ISCSI_CDU_TASK_SEG_TYPE       0
-#define FCOE_CDU_TASK_SEG_TYPE        0
-#define RDMA_CDU_TASK_SEG_TYPE        1
+#define ISCSI_CDU_TASK_SEG_TYPE                 0
+#define FCOE_CDU_TASK_SEG_TYPE                  0
+#define RDMA_CDU_TASK_SEG_TYPE                  1
 
-#define FW_ASSERT_GENERAL_ATTN_IDX    32
+#define FW_ASSERT_GENERAL_ATTN_IDX              32
 
-#define MAX_PINNED_CCFC                 32
+#define MAX_PINNED_CCFC                         32
 
 /* Queue Zone sizes in bytes */
-#define TSTORM_QZONE_SIZE 8
-#define MSTORM_QZONE_SIZE 16
-#define USTORM_QZONE_SIZE 8
-#define XSTORM_QZONE_SIZE 8
-#define YSTORM_QZONE_SIZE 0
-#define PSTORM_QZONE_SIZE 0
-
-#define MSTORM_VF_ZONE_DEFAULT_SIZE_LOG 7
+#define TSTORM_QZONE_SIZE       8
+#define MSTORM_QZONE_SIZE       16
+#define USTORM_QZONE_SIZE       8
+#define XSTORM_QZONE_SIZE       8
+#define YSTORM_QZONE_SIZE       0
+#define PSTORM_QZONE_SIZE       0
+
+#define MSTORM_VF_ZONE_DEFAULT_SIZE_LOG         7
 #define ETH_MAX_NUM_RX_QUEUES_PER_VF_DEFAULT    16
 #define ETH_MAX_NUM_RX_QUEUES_PER_VF_DOUBLE     48
 #define ETH_MAX_NUM_RX_QUEUES_PER_VF_QUAD       112
@@ -102,8 +109,8 @@
 #define MAX_NUM_LL2_TX_STATS_COUNTERS   48
 
 #define FW_MAJOR_VERSION        8
-#define FW_MINOR_VERSION        20
-#define FW_REVISION_VERSION     0
+#define FW_MINOR_VERSION        33
+#define FW_REVISION_VERSION     1
 #define FW_ENGINEERING_VERSION  0
 
 /***********************/
@@ -115,10 +122,10 @@
 #define MAX_NUM_PORTS_BB        (2)
 #define MAX_NUM_PORTS           (MAX_NUM_PORTS_K2)
 
-#define MAX_NUM_PFS_K2  (16)
-#define MAX_NUM_PFS_BB  (8)
-#define MAX_NUM_PFS     (MAX_NUM_PFS_K2)
-#define MAX_NUM_OF_PFS_IN_CHIP (16) /* On both engines */
+#define MAX_NUM_PFS_K2          (16)
+#define MAX_NUM_PFS_BB          (8)
+#define MAX_NUM_PFS             (MAX_NUM_PFS_K2)
+#define MAX_NUM_OF_PFS_IN_CHIP  (16) /* On both engines */
 
 #define MAX_NUM_VFS_K2  (192)
 #define MAX_NUM_VFS_BB  (120)
@@ -141,29 +148,14 @@
 /* Traffic classes in network-facing blocks (PBF, BTB, NIG, BRB, PRS and QM) */
 #define NUM_PHYS_TCS_4PORT_K2   (4)
 #define NUM_OF_PHYS_TCS         (8)
-
+#define PURE_LB_TC              NUM_OF_PHYS_TCS
 #define NUM_TCS_4PORT_K2        (NUM_PHYS_TCS_4PORT_K2 + 1)
 #define NUM_OF_TCS              (NUM_OF_PHYS_TCS + 1)
 
-#define LB_TC                   (NUM_OF_PHYS_TCS)
-
-/* Num of possible traffic priority values */
-#define NUM_OF_PRIO             (8)
-
-#define MAX_NUM_VOQS_K2         (NUM_TCS_4PORT_K2 * MAX_NUM_PORTS_K2)
-#define MAX_NUM_VOQS_BB         (NUM_OF_TCS * MAX_NUM_PORTS_BB)
-#define MAX_NUM_VOQS            (MAX_NUM_VOQS_K2)
-#define MAX_PHYS_VOQS           (NUM_OF_PHYS_TCS * MAX_NUM_PORTS_BB)
-
 /* CIDs */
-#define NUM_OF_CONNECTION_TYPES (8)
-#define NUM_OF_LCIDS            (320)
-#define NUM_OF_LTIDS            (320)
-
-/* Clock values */
-#define MASTER_CLK_FREQ_E4      (375e6)
-#define STORM_CLK_FREQ_E4       (1000e6)
-#define CLK25M_CLK_FREQ_E4      (25e6)
+#define NUM_OF_CONNECTION_TYPES_E4      (8)
+#define NUM_OF_LCIDS                    (320)
+#define NUM_OF_LTIDS                    (320)
 
 /* Global PXP windows (GTT) */
 #define NUM_OF_GTT              19
@@ -172,17 +164,17 @@
 #define GTT_DWORD_SIZE          BIT(GTT_DWORD_SIZE_BITS)
 
 /* Tools Version */
-#define TOOLS_VERSION 10
+#define TOOLS_VERSION   10
 
 /*****************/
 /* CDU CONSTANTS */
 /*****************/
 
-#define CDU_SEG_TYPE_OFFSET_REG_TYPE_SHIFT              (17)
-#define CDU_SEG_TYPE_OFFSET_REG_OFFSET_MASK             (0x1ffff)
+#define CDU_SEG_TYPE_OFFSET_REG_TYPE_SHIFT                      (17)
+#define CDU_SEG_TYPE_OFFSET_REG_OFFSET_MASK                     (0x1ffff)
 
-#define CDU_VF_FL_SEG_TYPE_OFFSET_REG_TYPE_SHIFT        (12)
-#define CDU_VF_FL_SEG_TYPE_OFFSET_REG_OFFSET_MASK       (0xfff)
+#define CDU_VF_FL_SEG_TYPE_OFFSET_REG_TYPE_SHIFT                (12)
+#define CDU_VF_FL_SEG_TYPE_OFFSET_REG_OFFSET_MASK               (0xfff)
 
 #define CDU_CONTEXT_VALIDATION_CFG_ENABLE_SHIFT                 (0)
 #define CDU_CONTEXT_VALIDATION_CFG_VALIDATION_TYPE_SHIFT        (1)
@@ -201,45 +193,45 @@
 #define DQ_DEMS_TOE_LOCAL_ADV_WND       4
 #define DQ_DEMS_ROCE_CQ_CONS            7
 
-/* XCM agg val selection */
-#define DQ_XCM_AGG_VAL_SEL_WORD2  0
-#define DQ_XCM_AGG_VAL_SEL_WORD3  1
-#define DQ_XCM_AGG_VAL_SEL_WORD4  2
-#define DQ_XCM_AGG_VAL_SEL_WORD5  3
-#define DQ_XCM_AGG_VAL_SEL_REG3   4
-#define DQ_XCM_AGG_VAL_SEL_REG4   5
-#define DQ_XCM_AGG_VAL_SEL_REG5   6
-#define DQ_XCM_AGG_VAL_SEL_REG6   7
-
-/* XCM agg val selection */
-#define DQ_XCM_CORE_TX_BD_CONS_CMD      DQ_XCM_AGG_VAL_SEL_WORD3
-#define DQ_XCM_CORE_TX_BD_PROD_CMD      DQ_XCM_AGG_VAL_SEL_WORD4
-#define DQ_XCM_CORE_SPQ_PROD_CMD        DQ_XCM_AGG_VAL_SEL_WORD4
-#define DQ_XCM_ETH_EDPM_NUM_BDS_CMD     DQ_XCM_AGG_VAL_SEL_WORD2
-#define DQ_XCM_ETH_TX_BD_CONS_CMD       DQ_XCM_AGG_VAL_SEL_WORD3
-#define DQ_XCM_ETH_TX_BD_PROD_CMD       DQ_XCM_AGG_VAL_SEL_WORD4
-#define DQ_XCM_ETH_GO_TO_BD_CONS_CMD    DQ_XCM_AGG_VAL_SEL_WORD5
-#define DQ_XCM_FCOE_SQ_CONS_CMD             DQ_XCM_AGG_VAL_SEL_WORD3
-#define DQ_XCM_FCOE_SQ_PROD_CMD             DQ_XCM_AGG_VAL_SEL_WORD4
-#define DQ_XCM_FCOE_X_FERQ_PROD_CMD         DQ_XCM_AGG_VAL_SEL_WORD5
-#define DQ_XCM_ISCSI_SQ_CONS_CMD        DQ_XCM_AGG_VAL_SEL_WORD3
-#define DQ_XCM_ISCSI_SQ_PROD_CMD        DQ_XCM_AGG_VAL_SEL_WORD4
-#define DQ_XCM_ISCSI_MORE_TO_SEND_SEQ_CMD DQ_XCM_AGG_VAL_SEL_REG3
-#define DQ_XCM_ISCSI_EXP_STAT_SN_CMD    DQ_XCM_AGG_VAL_SEL_REG6
-#define DQ_XCM_ROCE_SQ_PROD_CMD DQ_XCM_AGG_VAL_SEL_WORD4
-#define DQ_XCM_TOE_TX_BD_PROD_CMD       DQ_XCM_AGG_VAL_SEL_WORD4
-#define DQ_XCM_TOE_MORE_TO_SEND_SEQ_CMD DQ_XCM_AGG_VAL_SEL_REG3
-#define DQ_XCM_TOE_LOCAL_ADV_WND_SEQ_CMD DQ_XCM_AGG_VAL_SEL_REG4
+/* XCM agg val selection (HW) */
+#define DQ_XCM_AGG_VAL_SEL_WORD2        0
+#define DQ_XCM_AGG_VAL_SEL_WORD3        1
+#define DQ_XCM_AGG_VAL_SEL_WORD4        2
+#define DQ_XCM_AGG_VAL_SEL_WORD5        3
+#define DQ_XCM_AGG_VAL_SEL_REG3         4
+#define DQ_XCM_AGG_VAL_SEL_REG4         5
+#define DQ_XCM_AGG_VAL_SEL_REG5         6
+#define DQ_XCM_AGG_VAL_SEL_REG6         7
+
+/* XCM agg val selection (FW) */
+#define DQ_XCM_CORE_TX_BD_CONS_CMD              DQ_XCM_AGG_VAL_SEL_WORD3
+#define DQ_XCM_CORE_TX_BD_PROD_CMD              DQ_XCM_AGG_VAL_SEL_WORD4
+#define DQ_XCM_CORE_SPQ_PROD_CMD                DQ_XCM_AGG_VAL_SEL_WORD4
+#define DQ_XCM_ETH_EDPM_NUM_BDS_CMD             DQ_XCM_AGG_VAL_SEL_WORD2
+#define DQ_XCM_ETH_TX_BD_CONS_CMD               DQ_XCM_AGG_VAL_SEL_WORD3
+#define DQ_XCM_ETH_TX_BD_PROD_CMD               DQ_XCM_AGG_VAL_SEL_WORD4
+#define DQ_XCM_ETH_GO_TO_BD_CONS_CMD            DQ_XCM_AGG_VAL_SEL_WORD5
+#define DQ_XCM_FCOE_SQ_CONS_CMD                 DQ_XCM_AGG_VAL_SEL_WORD3
+#define DQ_XCM_FCOE_SQ_PROD_CMD                 DQ_XCM_AGG_VAL_SEL_WORD4
+#define DQ_XCM_FCOE_X_FERQ_PROD_CMD             DQ_XCM_AGG_VAL_SEL_WORD5
+#define DQ_XCM_ISCSI_SQ_CONS_CMD                DQ_XCM_AGG_VAL_SEL_WORD3
+#define DQ_XCM_ISCSI_SQ_PROD_CMD                DQ_XCM_AGG_VAL_SEL_WORD4
+#define DQ_XCM_ISCSI_MORE_TO_SEND_SEQ_CMD       DQ_XCM_AGG_VAL_SEL_REG3
+#define DQ_XCM_ISCSI_EXP_STAT_SN_CMD            DQ_XCM_AGG_VAL_SEL_REG6
+#define DQ_XCM_ROCE_SQ_PROD_CMD                 DQ_XCM_AGG_VAL_SEL_WORD4
+#define DQ_XCM_TOE_TX_BD_PROD_CMD               DQ_XCM_AGG_VAL_SEL_WORD4
+#define DQ_XCM_TOE_MORE_TO_SEND_SEQ_CMD         DQ_XCM_AGG_VAL_SEL_REG3
+#define DQ_XCM_TOE_LOCAL_ADV_WND_SEQ_CMD        DQ_XCM_AGG_VAL_SEL_REG4
 
 /* UCM agg val selection (HW) */
 #define DQ_UCM_AGG_VAL_SEL_WORD0        0
 #define DQ_UCM_AGG_VAL_SEL_WORD1        1
 #define DQ_UCM_AGG_VAL_SEL_WORD2        2
 #define DQ_UCM_AGG_VAL_SEL_WORD3        3
-#define DQ_UCM_AGG_VAL_SEL_REG0 4
-#define DQ_UCM_AGG_VAL_SEL_REG1 5
-#define DQ_UCM_AGG_VAL_SEL_REG2 6
-#define DQ_UCM_AGG_VAL_SEL_REG3 7
+#define DQ_UCM_AGG_VAL_SEL_REG0         4
+#define DQ_UCM_AGG_VAL_SEL_REG1         5
+#define DQ_UCM_AGG_VAL_SEL_REG2         6
+#define DQ_UCM_AGG_VAL_SEL_REG3         7
 
 /* UCM agg val selection (FW) */
 #define DQ_UCM_ETH_PMD_TX_CONS_CMD      DQ_UCM_AGG_VAL_SEL_WORD2
@@ -263,7 +255,7 @@
 #define DQ_TCM_ROCE_RQ_PROD_CMD \
         DQ_TCM_AGG_VAL_SEL_WORD0
 
-/* XCM agg counter flag selection */
+/* XCM agg counter flag selection (HW) */
 #define DQ_XCM_AGG_FLG_SHIFT_BIT14      0
 #define DQ_XCM_AGG_FLG_SHIFT_BIT15      1
 #define DQ_XCM_AGG_FLG_SHIFT_CF12       2
@@ -273,20 +265,20 @@
 #define DQ_XCM_AGG_FLG_SHIFT_CF22       6
 #define DQ_XCM_AGG_FLG_SHIFT_CF23       7
 
-/* XCM agg counter flag selection */
-#define DQ_XCM_CORE_DQ_CF_CMD           BIT(DQ_XCM_AGG_FLG_SHIFT_CF18)
-#define DQ_XCM_CORE_TERMINATE_CMD       BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
-#define DQ_XCM_CORE_SLOW_PATH_CMD       BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
-#define DQ_XCM_ETH_DQ_CF_CMD            BIT(DQ_XCM_AGG_FLG_SHIFT_CF18)
-#define DQ_XCM_ETH_TERMINATE_CMD        BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
-#define DQ_XCM_ETH_SLOW_PATH_CMD        BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
-#define DQ_XCM_ETH_TPH_EN_CMD           BIT(DQ_XCM_AGG_FLG_SHIFT_CF23)
-#define DQ_XCM_FCOE_SLOW_PATH_CMD           BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
-#define DQ_XCM_ISCSI_DQ_FLUSH_CMD       BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
-#define DQ_XCM_ISCSI_SLOW_PATH_CMD      BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
-#define DQ_XCM_ISCSI_PROC_ONLY_CLEANUP_CMD BIT(DQ_XCM_AGG_FLG_SHIFT_CF23)
-#define DQ_XCM_TOE_DQ_FLUSH_CMD         BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
-#define DQ_XCM_TOE_SLOW_PATH_CMD        BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
+/* XCM agg counter flag selection (FW) */
+#define DQ_XCM_CORE_DQ_CF_CMD                   BIT(DQ_XCM_AGG_FLG_SHIFT_CF18)
+#define DQ_XCM_CORE_TERMINATE_CMD               BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
+#define DQ_XCM_CORE_SLOW_PATH_CMD               BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
+#define DQ_XCM_ETH_DQ_CF_CMD                    BIT(DQ_XCM_AGG_FLG_SHIFT_CF18)
+#define DQ_XCM_ETH_TERMINATE_CMD                BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
+#define DQ_XCM_ETH_SLOW_PATH_CMD                BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
+#define DQ_XCM_ETH_TPH_EN_CMD                   BIT(DQ_XCM_AGG_FLG_SHIFT_CF23)
+#define DQ_XCM_FCOE_SLOW_PATH_CMD               BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
+#define DQ_XCM_ISCSI_DQ_FLUSH_CMD               BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
+#define DQ_XCM_ISCSI_SLOW_PATH_CMD              BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
+#define DQ_XCM_ISCSI_PROC_ONLY_CLEANUP_CMD      BIT(DQ_XCM_AGG_FLG_SHIFT_CF23)
+#define DQ_XCM_TOE_DQ_FLUSH_CMD                 BIT(DQ_XCM_AGG_FLG_SHIFT_CF19)
+#define DQ_XCM_TOE_SLOW_PATH_CMD                BIT(DQ_XCM_AGG_FLG_SHIFT_CF22)
 
 /* UCM agg counter flag selection (HW) */
 #define DQ_UCM_AGG_FLG_SHIFT_CF0        0
@@ -317,9 +309,9 @@
 #define DQ_TCM_AGG_FLG_SHIFT_CF6        6
 #define DQ_TCM_AGG_FLG_SHIFT_CF7        7
 /* TCM agg counter flag selection (FW) */
-#define DQ_TCM_FCOE_FLUSH_Q0_CMD            BIT(DQ_TCM_AGG_FLG_SHIFT_CF1)
-#define DQ_TCM_FCOE_DUMMY_TIMER_CMD         BIT(DQ_TCM_AGG_FLG_SHIFT_CF2)
-#define DQ_TCM_FCOE_TIMER_STOP_ALL_CMD      BIT(DQ_TCM_AGG_FLG_SHIFT_CF3)
+#define DQ_TCM_FCOE_FLUSH_Q0_CMD        BIT(DQ_TCM_AGG_FLG_SHIFT_CF1)
+#define DQ_TCM_FCOE_DUMMY_TIMER_CMD     BIT(DQ_TCM_AGG_FLG_SHIFT_CF2)
+#define DQ_TCM_FCOE_TIMER_STOP_ALL_CMD  BIT(DQ_TCM_AGG_FLG_SHIFT_CF3)
 #define DQ_TCM_ISCSI_FLUSH_Q0_CMD       BIT(DQ_TCM_AGG_FLG_SHIFT_CF1)
 #define DQ_TCM_ISCSI_TIMER_STOP_ALL_CMD BIT(DQ_TCM_AGG_FLG_SHIFT_CF3)
 #define DQ_TCM_TOE_FLUSH_Q0_CMD         BIT(DQ_TCM_AGG_FLG_SHIFT_CF1)
@@ -327,18 +319,18 @@
 #define DQ_TCM_IWARP_POST_RQ_CF_CMD     BIT(DQ_TCM_AGG_FLG_SHIFT_CF1)
 
 /* PWM address mapping */
-#define DQ_PWM_OFFSET_DPM_BASE  0x0
-#define DQ_PWM_OFFSET_DPM_END   0x27
+#define DQ_PWM_OFFSET_DPM_BASE          0x0
+#define DQ_PWM_OFFSET_DPM_END           0x27
 #define DQ_PWM_OFFSET_XCM16_BASE        0x40
 #define DQ_PWM_OFFSET_XCM32_BASE        0x44
 #define DQ_PWM_OFFSET_UCM16_BASE        0x48
 #define DQ_PWM_OFFSET_UCM32_BASE        0x4C
-#define DQ_PWM_OFFSET_UCM16_4   0x50
+#define DQ_PWM_OFFSET_UCM16_4           0x50
 #define DQ_PWM_OFFSET_TCM16_BASE        0x58
 #define DQ_PWM_OFFSET_TCM32_BASE        0x5C
-#define DQ_PWM_OFFSET_XCM_FLAGS 0x68
-#define DQ_PWM_OFFSET_UCM_FLAGS 0x69
-#define DQ_PWM_OFFSET_TCM_FLAGS 0x6B
+#define DQ_PWM_OFFSET_XCM_FLAGS         0x68
+#define DQ_PWM_OFFSET_UCM_FLAGS         0x69
+#define DQ_PWM_OFFSET_TCM_FLAGS         0x6B
 
 #define DQ_PWM_OFFSET_XCM_RDMA_SQ_PROD          (DQ_PWM_OFFSET_XCM16_BASE + 2)
 #define DQ_PWM_OFFSET_UCM_RDMA_CQ_CONS_32BIT    (DQ_PWM_OFFSET_UCM32_BASE)
@@ -347,10 +339,11 @@
 #define DQ_PWM_OFFSET_UCM_RDMA_ARM_FLAGS        (DQ_PWM_OFFSET_UCM_FLAGS)
 #define DQ_PWM_OFFSET_TCM_ROCE_RQ_PROD          (DQ_PWM_OFFSET_TCM16_BASE + 1)
 #define DQ_PWM_OFFSET_TCM_IWARP_RQ_PROD         (DQ_PWM_OFFSET_TCM16_BASE + 3)
-#define DQ_REGION_SHIFT (12)
+
+#define DQ_REGION_SHIFT                 (12)
 
 /* DPM */
-#define DQ_DPM_WQE_BUFF_SIZE    (320)
+#define DQ_DPM_WQE_BUFF_SIZE            (320)
 
 /* Conn type ranges */
 #define DQ_CONN_TYPE_RANGE_SHIFT        (4)
@@ -359,29 +352,30 @@
 /* QM CONSTANTS  */
 /*****************/
 
-/* number of TX queues in the QM */
+/* Number of TX queues in the QM */
 #define MAX_QM_TX_QUEUES_K2     512
 #define MAX_QM_TX_QUEUES_BB     448
 #define MAX_QM_TX_QUEUES        MAX_QM_TX_QUEUES_K2
 
-/* number of Other queues in the QM */
+/* Number of Other queues in the QM */
 #define MAX_QM_OTHER_QUEUES_BB  64
 #define MAX_QM_OTHER_QUEUES_K2  128
 #define MAX_QM_OTHER_QUEUES     MAX_QM_OTHER_QUEUES_K2
 
-/* number of queues in a PF queue group */
+/* Number of queues in a PF queue group */
 #define QM_PF_QUEUE_GROUP_SIZE  8
 
-/* the size of a single queue element in bytes */
-#define QM_PQ_ELEMENT_SIZE                      4
+/* The size of a single queue element in bytes */
+#define QM_PQ_ELEMENT_SIZE      4
 
-/* base number of Tx PQs in the CM PQ representation.
- * should be used when storing PQ IDs in CM PQ registers and context
+/* Base number of Tx PQs in the CM PQ representation.
+ * Should be used when storing PQ IDs in CM PQ registers and context.
  */
-#define CM_TX_PQ_BASE   0x200
+#define CM_TX_PQ_BASE           0x200
 
-/* number of global Vport/QCN rate limiters */
+/* Number of global Vport/QCN rate limiters */
 #define MAX_QM_GLOBAL_RLS       256
+
 /* QM registers data */
 #define QM_LINE_CRD_REG_WIDTH           16
 #define QM_LINE_CRD_REG_SIGN_BIT        BIT((QM_LINE_CRD_REG_WIDTH - 1))
@@ -400,7 +394,7 @@
 #define CAU_FSM_ETH_TX  1
 
 /* Number of Protocol Indices per Status Block */
-#define PIS_PER_SB    12
+#define PIS_PER_SB_E4   12
 
 #define CAU_HC_STOPPED_STATE    3
 #define CAU_HC_DISABLE_STATE    4
@@ -432,8 +426,7 @@
 
 #define IGU_CMD_INT_ACK_BASE            0x0400
 #define IGU_CMD_INT_ACK_UPPER           (IGU_CMD_INT_ACK_BASE + \
-                                         MAX_TOT_SB_PER_PATH -  \
-                                         1)
+                                         MAX_TOT_SB_PER_PATH - 1)
 #define IGU_CMD_INT_ACK_RESERVED_UPPER  0x05ff
 
 #define IGU_CMD_ATTN_BIT_UPD_UPPER      0x05f0
@@ -447,8 +440,7 @@
 
 #define IGU_CMD_PROD_UPD_BASE                   0x0600
 #define IGU_CMD_PROD_UPD_UPPER                  (IGU_CMD_PROD_UPD_BASE +\
-                                                 MAX_TOT_SB_PER_PATH - \
-                                                 1)
+                                                 MAX_TOT_SB_PER_PATH - 1)
 #define IGU_CMD_PROD_UPD_RESERVED_UPPER         0x07ff
 
 /*****************/
@@ -514,129 +506,126 @@
          PXP_EXTERNAL_BAR_GLOBAL_WINDOW_LENGTH - 1)
 
 /* PF BAR */
-#define PXP_BAR0_START_GRC      0x0000
-#define PXP_BAR0_GRC_LENGTH     0x1C00000
-#define PXP_BAR0_END_GRC        (PXP_BAR0_START_GRC + \
-                                 PXP_BAR0_GRC_LENGTH - 1)
-
-#define PXP_BAR0_START_IGU      0x1C00000
-#define PXP_BAR0_IGU_LENGTH     0x10000
-#define PXP_BAR0_END_IGU        (PXP_BAR0_START_IGU + \
-                                 PXP_BAR0_IGU_LENGTH - 1)
-
-#define PXP_BAR0_START_TSDM     0x1C80000
-#define PXP_BAR0_SDM_LENGTH     0x40000
+#define PXP_BAR0_START_GRC              0x0000
+#define PXP_BAR0_GRC_LENGTH             0x1C00000
+#define PXP_BAR0_END_GRC                (PXP_BAR0_START_GRC + \
+                                         PXP_BAR0_GRC_LENGTH - 1)
+
+#define PXP_BAR0_START_IGU              0x1C00000
+#define PXP_BAR0_IGU_LENGTH             0x10000
+#define PXP_BAR0_END_IGU                (PXP_BAR0_START_IGU + \
+                                         PXP_BAR0_IGU_LENGTH - 1)
+
+#define PXP_BAR0_START_TSDM             0x1C80000
+#define PXP_BAR0_SDM_LENGTH             0x40000
 #define PXP_BAR0_SDM_RESERVED_LENGTH    0x40000
-#define PXP_BAR0_END_TSDM       (PXP_BAR0_START_TSDM + \
-                                 PXP_BAR0_SDM_LENGTH - 1)
+#define PXP_BAR0_END_TSDM               (PXP_BAR0_START_TSDM + \
+                                         PXP_BAR0_SDM_LENGTH - 1)
 
-#define PXP_BAR0_START_MSDM     0x1D00000
-#define PXP_BAR0_END_MSDM       (PXP_BAR0_START_MSDM + \
-                                 PXP_BAR0_SDM_LENGTH - 1)
+#define PXP_BAR0_START_MSDM             0x1D00000
+#define PXP_BAR0_END_MSDM               (PXP_BAR0_START_MSDM + \
+                                         PXP_BAR0_SDM_LENGTH - 1)
 
-#define PXP_BAR0_START_USDM     0x1D80000
-#define PXP_BAR0_END_USDM       (PXP_BAR0_START_USDM + \
-                                 PXP_BAR0_SDM_LENGTH - 1)
+#define PXP_BAR0_START_USDM             0x1D80000
+#define PXP_BAR0_END_USDM               (PXP_BAR0_START_USDM + \
+                                         PXP_BAR0_SDM_LENGTH - 1)
 
-#define PXP_BAR0_START_XSDM     0x1E00000
-#define PXP_BAR0_END_XSDM       (PXP_BAR0_START_XSDM + \
-                                 PXP_BAR0_SDM_LENGTH - 1)
+#define PXP_BAR0_START_XSDM             0x1E00000
+#define PXP_BAR0_END_XSDM               (PXP_BAR0_START_XSDM + \
+                                         PXP_BAR0_SDM_LENGTH - 1)
 
-#define PXP_BAR0_START_YSDM     0x1E80000
-#define PXP_BAR0_END_YSDM       (PXP_BAR0_START_YSDM + \
-                                 PXP_BAR0_SDM_LENGTH - 1)
+#define PXP_BAR0_START_YSDM             0x1E80000
+#define PXP_BAR0_END_YSDM               (PXP_BAR0_START_YSDM + \
+                                         PXP_BAR0_SDM_LENGTH - 1)
 
-#define PXP_BAR0_START_PSDM     0x1F00000
-#define PXP_BAR0_END_PSDM       (PXP_BAR0_START_PSDM + \
-                                 PXP_BAR0_SDM_LENGTH - 1)
+#define PXP_BAR0_START_PSDM             0x1F00000
+#define PXP_BAR0_END_PSDM               (PXP_BAR0_START_PSDM + \
+                                         PXP_BAR0_SDM_LENGTH - 1)
 
 #define PXP_BAR0_FIRST_INVALID_ADDRESS  (PXP_BAR0_END_PSDM + 1)
 
 /* VF BAR */
-#define PXP_VF_BAR0     0
-
-#define PXP_VF_BAR0_START_GRC   0x3E00
-#define PXP_VF_BAR0_GRC_LENGTH  0x200
-#define PXP_VF_BAR0_END_GRC     (PXP_VF_BAR0_START_GRC + \
-                                 PXP_VF_BAR0_GRC_LENGTH - 1)
-
-#define PXP_VF_BAR0_START_IGU                   0
-#define PXP_VF_BAR0_IGU_LENGTH                  0x3000
-#define PXP_VF_BAR0_END_IGU                     (PXP_VF_BAR0_START_IGU + \
-                                                 PXP_VF_BAR0_IGU_LENGTH - 1)
-
-#define PXP_VF_BAR0_START_DQ                    0x3000
-#define PXP_VF_BAR0_DQ_LENGTH                   0x200
-#define PXP_VF_BAR0_DQ_OPAQUE_OFFSET            0
-#define PXP_VF_BAR0_ME_OPAQUE_ADDRESS           (PXP_VF_BAR0_START_DQ + \
-                                                 PXP_VF_BAR0_DQ_OPAQUE_OFFSET)
-#define PXP_VF_BAR0_ME_CONCRETE_ADDRESS         (PXP_VF_BAR0_ME_OPAQUE_ADDRESS \
-                                                 + 4)
-#define PXP_VF_BAR0_END_DQ                      (PXP_VF_BAR0_START_DQ + \
-                                                 PXP_VF_BAR0_DQ_LENGTH - 1)
-
-#define PXP_VF_BAR0_START_TSDM_ZONE_B           0x3200
-#define PXP_VF_BAR0_SDM_LENGTH_ZONE_B           0x200
-#define PXP_VF_BAR0_END_TSDM_ZONE_B             (PXP_VF_BAR0_START_TSDM_ZONE_B \
-                                                 +                             \
-                                                 PXP_VF_BAR0_SDM_LENGTH_ZONE_B \
-                                                 - 1)
-
-#define PXP_VF_BAR0_START_MSDM_ZONE_B           0x3400
-#define PXP_VF_BAR0_END_MSDM_ZONE_B             (PXP_VF_BAR0_START_MSDM_ZONE_B \
-                                                 +                             \
-                                                 PXP_VF_BAR0_SDM_LENGTH_ZONE_B \
-                                                 - 1)
-
-#define PXP_VF_BAR0_START_USDM_ZONE_B           0x3600
-#define PXP_VF_BAR0_END_USDM_ZONE_B             (PXP_VF_BAR0_START_USDM_ZONE_B \
-                                                 +                             \
-                                                 PXP_VF_BAR0_SDM_LENGTH_ZONE_B \
-                                                 - 1)
-
-#define PXP_VF_BAR0_START_XSDM_ZONE_B           0x3800
-#define PXP_VF_BAR0_END_XSDM_ZONE_B             (PXP_VF_BAR0_START_XSDM_ZONE_B \
-                                                 +                             \
-                                                 PXP_VF_BAR0_SDM_LENGTH_ZONE_B \
-                                                 - 1)
-
-#define PXP_VF_BAR0_START_YSDM_ZONE_B           0x3a00
-#define PXP_VF_BAR0_END_YSDM_ZONE_B             (PXP_VF_BAR0_START_YSDM_ZONE_B \
-                                                 +                             \
-                                                 PXP_VF_BAR0_SDM_LENGTH_ZONE_B \
-                                                 - 1)
-
-#define PXP_VF_BAR0_START_PSDM_ZONE_B           0x3c00
-#define PXP_VF_BAR0_END_PSDM_ZONE_B             (PXP_VF_BAR0_START_PSDM_ZONE_B \
-                                                 +                             \
-                                                 PXP_VF_BAR0_SDM_LENGTH_ZONE_B \
-                                                 - 1)
-
-#define PXP_VF_BAR0_START_SDM_ZONE_A            0x4000
-#define PXP_VF_BAR0_END_SDM_ZONE_A              0x10000
-
-#define PXP_VF_BAR0_GRC_WINDOW_LENGTH           32
-
-#define PXP_ILT_PAGE_SIZE_NUM_BITS_MIN          12
-#define PXP_ILT_BLOCK_FACTOR_MULTIPLIER         1024
+#define PXP_VF_BAR0                     0
+
+#define PXP_VF_BAR0_START_IGU           0
+#define PXP_VF_BAR0_IGU_LENGTH          0x3000
+#define PXP_VF_BAR0_END_IGU             (PXP_VF_BAR0_START_IGU + \
+                                         PXP_VF_BAR0_IGU_LENGTH - 1)
+
+#define PXP_VF_BAR0_START_DQ            0x3000
+#define PXP_VF_BAR0_DQ_LENGTH           0x200
+#define PXP_VF_BAR0_DQ_OPAQUE_OFFSET    0
+#define PXP_VF_BAR0_ME_OPAQUE_ADDRESS   (PXP_VF_BAR0_START_DQ + \
+                                         PXP_VF_BAR0_DQ_OPAQUE_OFFSET)
+#define PXP_VF_BAR0_ME_CONCRETE_ADDRESS (PXP_VF_BAR0_ME_OPAQUE_ADDRESS \
+                                         + 4)
+#define PXP_VF_BAR0_END_DQ              (PXP_VF_BAR0_START_DQ + \
+                                         PXP_VF_BAR0_DQ_LENGTH - 1)
+
+#define PXP_VF_BAR0_START_TSDM_ZONE_B   0x3200
+#define PXP_VF_BAR0_SDM_LENGTH_ZONE_B   0x200
+#define PXP_VF_BAR0_END_TSDM_ZONE_B     (PXP_VF_BAR0_START_TSDM_ZONE_B + \
+                                         PXP_VF_BAR0_SDM_LENGTH_ZONE_B - 1)
+
+#define PXP_VF_BAR0_START_MSDM_ZONE_B   0x3400
+#define PXP_VF_BAR0_END_MSDM_ZONE_B     (PXP_VF_BAR0_START_MSDM_ZONE_B + \
+                                         PXP_VF_BAR0_SDM_LENGTH_ZONE_B - 1)
+
+#define PXP_VF_BAR0_START_USDM_ZONE_B   0x3600
+#define PXP_VF_BAR0_END_USDM_ZONE_B     (PXP_VF_BAR0_START_USDM_ZONE_B + \
+                                         PXP_VF_BAR0_SDM_LENGTH_ZONE_B - 1)
+
+#define PXP_VF_BAR0_START_XSDM_ZONE_B   0x3800
+#define PXP_VF_BAR0_END_XSDM_ZONE_B     (PXP_VF_BAR0_START_XSDM_ZONE_B + \
+                                         PXP_VF_BAR0_SDM_LENGTH_ZONE_B - 1)
+
+#define PXP_VF_BAR0_START_YSDM_ZONE_B   0x3a00
+#define PXP_VF_BAR0_END_YSDM_ZONE_B     (PXP_VF_BAR0_START_YSDM_ZONE_B + \
+                                         PXP_VF_BAR0_SDM_LENGTH_ZONE_B - 1)
+
+#define PXP_VF_BAR0_START_PSDM_ZONE_B   0x3c00
+#define PXP_VF_BAR0_END_PSDM_ZONE_B     (PXP_VF_BAR0_START_PSDM_ZONE_B + \
+                                         PXP_VF_BAR0_SDM_LENGTH_ZONE_B - 1)
+
+#define PXP_VF_BAR0_START_GRC           0x3E00
+#define PXP_VF_BAR0_GRC_LENGTH          0x200
+#define PXP_VF_BAR0_END_GRC             (PXP_VF_BAR0_START_GRC + \
+                                         PXP_VF_BAR0_GRC_LENGTH - 1)
+
+#define PXP_VF_BAR0_START_SDM_ZONE_A    0x4000
+#define PXP_VF_BAR0_END_SDM_ZONE_A      0x10000
+
+#define PXP_VF_BAR0_START_IGU2          0x10000
+#define PXP_VF_BAR0_IGU2_LENGTH         0xD000
+#define PXP_VF_BAR0_END_IGU2            (PXP_VF_BAR0_START_IGU2 + \
+                                         PXP_VF_BAR0_IGU2_LENGTH - 1)
+
+#define PXP_VF_BAR0_GRC_WINDOW_LENGTH   32
+
+#define PXP_ILT_PAGE_SIZE_NUM_BITS_MIN  12
+#define PXP_ILT_BLOCK_FACTOR_MULTIPLIER 1024
 
 /* ILT Records */
 #define PXP_NUM_ILT_RECORDS_BB 7600
 #define PXP_NUM_ILT_RECORDS_K2 11000
 #define MAX_NUM_ILT_RECORDS MAX(PXP_NUM_ILT_RECORDS_BB, PXP_NUM_ILT_RECORDS_K2)
-#define PXP_QUEUES_ZONE_MAX_NUM 320
+
+/* Host Interface */
+#define PXP_QUEUES_ZONE_MAX_NUM 320
+
 /*****************/
 /* PRM CONSTANTS */
 /*****************/
-#define PRM_DMA_PAD_BYTES_NUM  2
+#define PRM_DMA_PAD_BYTES_NUM   2
+
 /*****************/
 /* SDMs CONSTANTS  */
 /*****************/
 
-#define SDM_OP_GEN_TRIG_NONE                    0
-#define SDM_OP_GEN_TRIG_WAKE_THREAD             1
-#define SDM_OP_GEN_TRIG_AGG_INT                 2
-#define SDM_OP_GEN_TRIG_LOADER                  4
+#define SDM_OP_GEN_TRIG_NONE            0
+#define SDM_OP_GEN_TRIG_WAKE_THREAD     1
+#define SDM_OP_GEN_TRIG_AGG_INT         2
+#define SDM_OP_GEN_TRIG_LOADER          4
 #define SDM_OP_GEN_TRIG_INDICATE_ERROR  6
 #define SDM_OP_GEN_TRIG_INC_ORDER_CNT   9
 
@@ -644,26 +633,26 @@
 /* Completion types */
 /********************/
 
-#define SDM_COMP_TYPE_NONE              0
-#define SDM_COMP_TYPE_WAKE_THREAD       1
-#define SDM_COMP_TYPE_AGG_INT           2
-#define SDM_COMP_TYPE_CM                3
-#define SDM_COMP_TYPE_LOADER            4
-#define SDM_COMP_TYPE_PXP               5
-#define SDM_COMP_TYPE_INDICATE_ERROR    6
-#define SDM_COMP_TYPE_RELEASE_THREAD    7
-#define SDM_COMP_TYPE_RAM               8
-#define SDM_COMP_TYPE_INC_ORDER_CNT     9
+#define SDM_COMP_TYPE_NONE              0
+#define SDM_COMP_TYPE_WAKE_THREAD       1
+#define SDM_COMP_TYPE_AGG_INT           2
+#define SDM_COMP_TYPE_CM                3
+#define SDM_COMP_TYPE_LOADER            4
+#define SDM_COMP_TYPE_PXP               5
+#define SDM_COMP_TYPE_INDICATE_ERROR    6
+#define SDM_COMP_TYPE_RELEASE_THREAD    7
+#define SDM_COMP_TYPE_RAM               8
+#define SDM_COMP_TYPE_INC_ORDER_CNT     9
 
 /*****************/
-/* PBF Constants */
+/* PBF CONSTANTS */
 /*****************/
 
 /* Number of PBF command queue lines. Each line is 32B. */
-#define PBF_MAX_CMD_LINES 3328
+#define PBF_MAX_CMD_LINES       3328
 
 /* Number of BTB blocks. Each block is 256B. */
-#define BTB_MAX_BLOCKS 1440
+#define BTB_MAX_BLOCKS          1440
 
 /*****************/
 /* PRS CONSTANTS */
@@ -671,14 +660,7 @@
 
 #define PRS_GFT_CAM_LINES_NO_MATCH      31
 
-/* Async data KCQ CQE */
-struct async_data {
-        __le32  cid;
-        __le16  itid;
-        u8      error_code;
-        u8      fw_debug_param;
-};
-
+/* Interrupt coalescing TimeSet */
 struct coalescing_timeset {
         u8 value;
 #define COALESCING_TIMESET_TIMESET_MASK         0x7F
@@ -692,23 +674,32 @@ struct common_queue_zone {
         __le16 reserved;
 };
 
+/* ETH Rx producers data */
 struct eth_rx_prod_data {
         __le16 bd_prod;
         __le16 cqe_prod;
 };
 
-struct regpair {
-        __le32  lo;
-        __le32  hi;
+struct tcp_ulp_connect_done_params {
+        __le16 mss;
+        u8 snd_wnd_scale;
+        u8 flags;
+#define TCP_ULP_CONNECT_DONE_PARAMS_TS_EN_MASK          0x1
+#define TCP_ULP_CONNECT_DONE_PARAMS_TS_EN_SHIFT         0
+#define TCP_ULP_CONNECT_DONE_PARAMS_RESERVED_MASK       0x7F
+#define TCP_ULP_CONNECT_DONE_PARAMS_RESERVED_SHIFT      1
 };
 
-struct vf_pf_channel_eqe_data {
-        struct regpair msg_addr;
+struct iscsi_connect_done_results {
+        __le16 icid;
+        __le16 conn_id;
+        struct tcp_ulp_connect_done_params params;
 };
 
 struct iscsi_eqe_data {
-        __le32 cid;
+        __le16 icid;
         __le16 conn_id;
+        __le16 reserved;
         u8 error_code;
         u8 error_pdu_opcode_reserved;
 #define ISCSI_EQE_DATA_ERROR_PDU_OPCODE_MASK            0x3F
@@ -719,52 +710,6 @@ struct iscsi_eqe_data {
 #define ISCSI_EQE_DATA_RESERVED0_SHIFT                  7
 };
 
-struct rdma_eqe_destroy_qp {
-        __le32 cid;
-        u8 reserved[4];
-};
-
-union rdma_eqe_data {
-        struct regpair async_handle;
-        struct rdma_eqe_destroy_qp rdma_destroy_qp_data;
-};
-
-struct malicious_vf_eqe_data {
-        u8 vf_id;
-        u8 err_id;
-        __le16 reserved[3];
-};
-
-struct initial_cleanup_eqe_data {
-        u8 vf_id;
-        u8 reserved[7];
-};
-
-/* Event Data Union */
-union event_ring_data {
-        u8 bytes[8];
-        struct vf_pf_channel_eqe_data vf_pf_channel;
-        struct iscsi_eqe_data iscsi_info;
-        union rdma_eqe_data rdma_data;
-        struct malicious_vf_eqe_data malicious_vf;
-        struct initial_cleanup_eqe_data vf_init_cleanup;
-};
-
-/* Event Ring Entry */
-struct event_ring_entry {
-        u8                      protocol_id;
-        u8                      opcode;
-        __le16                  reserved0;
-        __le16                  echo;
-        u8                      fw_return_code;
-        u8                      flags;
-#define EVENT_RING_ENTRY_ASYNC_MASK      0x1
-#define EVENT_RING_ENTRY_ASYNC_SHIFT     0
-#define EVENT_RING_ENTRY_RESERVED1_MASK  0x7F
-#define EVENT_RING_ENTRY_RESERVED1_SHIFT 1
-        union event_ring_data   data;
-};
-
 /* Multi function mode */
 enum mf_mode {
         ERROR_MODE /* Unsupported mode */,
@@ -781,13 +726,31 @@ enum protocol_type {
         PROTOCOLID_CORE,
         PROTOCOLID_ETH,
         PROTOCOLID_IWARP,
-        PROTOCOLID_RESERVED5,
+        PROTOCOLID_RESERVED0,
         PROTOCOLID_PREROCE,
         PROTOCOLID_COMMON,
-        PROTOCOLID_RESERVED6,
+        PROTOCOLID_RESERVED1,
         MAX_PROTOCOL_TYPE
 };
 
+struct regpair {
+        __le32 lo;
+        __le32 hi;
+};
+
+/* RoCE Destroy Event Data */
+struct rdma_eqe_destroy_qp {
+        __le32 cid;
+        u8 reserved[4];
+};
+
+/* RDMA Event Data Union */
+union rdma_eqe_data {
+        struct regpair async_handle;
+        struct rdma_eqe_destroy_qp rdma_destroy_qp_data;
+};
+
+/* Ustorm Queue Zone */
 struct ustorm_eth_queue_zone {
         struct coalescing_timeset int_coalescing_timeset;
         u8 reserved[3];
@@ -798,62 +761,71 @@ struct ustorm_queue_zone {
         struct common_queue_zone common;
 };
 
-/* status block structure */
+/* Status block structure */
 struct cau_pi_entry {
-        u32 prod;
-#define CAU_PI_ENTRY_PROD_VAL_MASK    0xFFFF
-#define CAU_PI_ENTRY_PROD_VAL_SHIFT   0
-#define CAU_PI_ENTRY_PI_TIMESET_MASK  0x7F
-#define CAU_PI_ENTRY_PI_TIMESET_SHIFT 16
-#define CAU_PI_ENTRY_FSM_SEL_MASK     0x1
-#define CAU_PI_ENTRY_FSM_SEL_SHIFT    23
-#define CAU_PI_ENTRY_RESERVED_MASK    0xFF
-#define CAU_PI_ENTRY_RESERVED_SHIFT   24
+        __le32 prod;
+#define CAU_PI_ENTRY_PROD_VAL_MASK      0xFFFF
+#define CAU_PI_ENTRY_PROD_VAL_SHIFT     0
+#define CAU_PI_ENTRY_PI_TIMESET_MASK    0x7F
+#define CAU_PI_ENTRY_PI_TIMESET_SHIFT   16
+#define CAU_PI_ENTRY_FSM_SEL_MASK       0x1
+#define CAU_PI_ENTRY_FSM_SEL_SHIFT      23
+#define CAU_PI_ENTRY_RESERVED_MASK      0xFF
+#define CAU_PI_ENTRY_RESERVED_SHIFT     24
 };
 
-/* status block structure */
+/* Status block structure */
 struct cau_sb_entry {
-        u32 data;
-#define CAU_SB_ENTRY_SB_PROD_MASK      0xFFFFFF
-#define CAU_SB_ENTRY_SB_PROD_SHIFT     0
-#define CAU_SB_ENTRY_STATE0_MASK       0xF
-#define CAU_SB_ENTRY_STATE0_SHIFT      24
-#define CAU_SB_ENTRY_STATE1_MASK       0xF
-#define CAU_SB_ENTRY_STATE1_SHIFT      28
-        u32 params;
-#define CAU_SB_ENTRY_SB_TIMESET0_MASK  0x7F
-#define CAU_SB_ENTRY_SB_TIMESET0_SHIFT 0
-#define CAU_SB_ENTRY_SB_TIMESET1_MASK  0x7F
-#define CAU_SB_ENTRY_SB_TIMESET1_SHIFT 7
-#define CAU_SB_ENTRY_TIMER_RES0_MASK   0x3
-#define CAU_SB_ENTRY_TIMER_RES0_SHIFT  14
-#define CAU_SB_ENTRY_TIMER_RES1_MASK   0x3
-#define CAU_SB_ENTRY_TIMER_RES1_SHIFT  16
-#define CAU_SB_ENTRY_VF_NUMBER_MASK    0xFF
-#define CAU_SB_ENTRY_VF_NUMBER_SHIFT   18
-#define CAU_SB_ENTRY_VF_VALID_MASK     0x1
-#define CAU_SB_ENTRY_VF_VALID_SHIFT    26
-#define CAU_SB_ENTRY_PF_NUMBER_MASK    0xF
-#define CAU_SB_ENTRY_PF_NUMBER_SHIFT   27
-#define CAU_SB_ENTRY_TPH_MASK          0x1
-#define CAU_SB_ENTRY_TPH_SHIFT         31
+        __le32 data;
+#define CAU_SB_ENTRY_SB_PROD_MASK       0xFFFFFF
+#define CAU_SB_ENTRY_SB_PROD_SHIFT      0
+#define CAU_SB_ENTRY_STATE0_MASK        0xF
+#define CAU_SB_ENTRY_STATE0_SHIFT       24
+#define CAU_SB_ENTRY_STATE1_MASK        0xF
+#define CAU_SB_ENTRY_STATE1_SHIFT       28
+        __le32 params;
+#define CAU_SB_ENTRY_SB_TIMESET0_MASK   0x7F
+#define CAU_SB_ENTRY_SB_TIMESET0_SHIFT  0
+#define CAU_SB_ENTRY_SB_TIMESET1_MASK   0x7F
+#define CAU_SB_ENTRY_SB_TIMESET1_SHIFT  7
+#define CAU_SB_ENTRY_TIMER_RES0_MASK    0x3
+#define CAU_SB_ENTRY_TIMER_RES0_SHIFT   14
+#define CAU_SB_ENTRY_TIMER_RES1_MASK    0x3
+#define CAU_SB_ENTRY_TIMER_RES1_SHIFT   16
+#define CAU_SB_ENTRY_VF_NUMBER_MASK     0xFF
+#define CAU_SB_ENTRY_VF_NUMBER_SHIFT    18
+#define CAU_SB_ENTRY_VF_VALID_MASK      0x1
+#define CAU_SB_ENTRY_VF_VALID_SHIFT     26
+#define CAU_SB_ENTRY_PF_NUMBER_MASK     0xF
+#define CAU_SB_ENTRY_PF_NUMBER_SHIFT    27
+#define CAU_SB_ENTRY_TPH_MASK           0x1
+#define CAU_SB_ENTRY_TPH_SHIFT          31
 };
 
-/* core doorbell data */
+/* Igu cleanup bit values to distinguish between clean or producer consumer
+ * update.
+ */
+enum command_type_bit {
+        IGU_COMMAND_TYPE_NOP = 0,
+        IGU_COMMAND_TYPE_SET = 1,
+        MAX_COMMAND_TYPE_BIT
+};
+
+/* Core doorbell data */
 struct core_db_data {
         u8 params;
-#define CORE_DB_DATA_DEST_MASK         0x3
-#define CORE_DB_DATA_DEST_SHIFT        0
-#define CORE_DB_DATA_AGG_CMD_MASK      0x3
-#define CORE_DB_DATA_AGG_CMD_SHIFT     2
-#define CORE_DB_DATA_BYPASS_EN_MASK    0x1
-#define CORE_DB_DATA_BYPASS_EN_SHIFT   4
-#define CORE_DB_DATA_RESERVED_MASK     0x1
-#define CORE_DB_DATA_RESERVED_SHIFT    5
-#define CORE_DB_DATA_AGG_VAL_SEL_MASK  0x3
-#define CORE_DB_DATA_AGG_VAL_SEL_SHIFT 6
-        u8      agg_flags;
-        __le16  spq_prod;
+#define CORE_DB_DATA_DEST_MASK          0x3
+#define CORE_DB_DATA_DEST_SHIFT         0
+#define CORE_DB_DATA_AGG_CMD_MASK       0x3
+#define CORE_DB_DATA_AGG_CMD_SHIFT      2
+#define CORE_DB_DATA_BYPASS_EN_MASK     0x1
+#define CORE_DB_DATA_BYPASS_EN_SHIFT    4
+#define CORE_DB_DATA_RESERVED_MASK      0x1
+#define CORE_DB_DATA_RESERVED_SHIFT     5
+#define CORE_DB_DATA_AGG_VAL_SEL_MASK   0x3
+#define CORE_DB_DATA_AGG_VAL_SEL_SHIFT  6
+        u8 agg_flags;
+        __le16 spq_prod;
 };
 
 /* Enum of doorbell aggregative command selection */
@@ -909,67 +881,69 @@ struct db_l2_dpm_sge {
         struct regpair addr;
         __le16 nbytes;
         __le16 bitfields;
-#define DB_L2_DPM_SGE_TPH_ST_INDEX_MASK 0x1FF
-#define DB_L2_DPM_SGE_TPH_ST_INDEX_SHIFT 0
-#define DB_L2_DPM_SGE_RESERVED0_MASK    0x3
-#define DB_L2_DPM_SGE_RESERVED0_SHIFT   9
-#define DB_L2_DPM_SGE_ST_VALID_MASK     0x1
-#define DB_L2_DPM_SGE_ST_VALID_SHIFT    11
-#define DB_L2_DPM_SGE_RESERVED1_MASK    0xF
-#define DB_L2_DPM_SGE_RESERVED1_SHIFT   12
+#define DB_L2_DPM_SGE_TPH_ST_INDEX_MASK         0x1FF
+#define DB_L2_DPM_SGE_TPH_ST_INDEX_SHIFT        0
+#define DB_L2_DPM_SGE_RESERVED0_MASK            0x3
+#define DB_L2_DPM_SGE_RESERVED0_SHIFT           9
+#define DB_L2_DPM_SGE_ST_VALID_MASK             0x1
+#define DB_L2_DPM_SGE_ST_VALID_SHIFT            11
+#define DB_L2_DPM_SGE_RESERVED1_MASK            0xF
+#define DB_L2_DPM_SGE_RESERVED1_SHIFT           12
         __le32 reserved2;
 };
 
 /* Structure for doorbell address, in legacy mode */
 struct db_legacy_addr {
         __le32 addr;
-#define DB_LEGACY_ADDR_RESERVED0_MASK  0x3
-#define DB_LEGACY_ADDR_RESERVED0_SHIFT 0
-#define DB_LEGACY_ADDR_DEMS_MASK       0x7
-#define DB_LEGACY_ADDR_DEMS_SHIFT      2
-#define DB_LEGACY_ADDR_ICID_MASK       0x7FFFFFF
-#define DB_LEGACY_ADDR_ICID_SHIFT      5
+#define DB_LEGACY_ADDR_RESERVED0_MASK   0x3
+#define DB_LEGACY_ADDR_RESERVED0_SHIFT  0
+#define DB_LEGACY_ADDR_DEMS_MASK        0x7
+#define DB_LEGACY_ADDR_DEMS_SHIFT       2
+#define DB_LEGACY_ADDR_ICID_MASK        0x7FFFFFF
+#define DB_LEGACY_ADDR_ICID_SHIFT       5
 };
 
 /* Structure for doorbell address, in PWM mode */
 struct db_pwm_addr {
         __le32 addr;
 #define DB_PWM_ADDR_RESERVED0_MASK      0x7
-#define DB_PWM_ADDR_RESERVED0_SHIFT 0
-#define DB_PWM_ADDR_OFFSET_MASK 0x7F
+#define DB_PWM_ADDR_RESERVED0_SHIFT     0
+#define DB_PWM_ADDR_OFFSET_MASK         0x7F
 #define DB_PWM_ADDR_OFFSET_SHIFT        3
-#define DB_PWM_ADDR_WID_MASK    0x3
-#define DB_PWM_ADDR_WID_SHIFT   10
-#define DB_PWM_ADDR_DPI_MASK    0xFFFF
-#define DB_PWM_ADDR_DPI_SHIFT   12
+#define DB_PWM_ADDR_WID_MASK            0x3
+#define DB_PWM_ADDR_WID_SHIFT           10
+#define DB_PWM_ADDR_DPI_MASK            0xFFFF
+#define DB_PWM_ADDR_DPI_SHIFT           12
 #define DB_PWM_ADDR_RESERVED1_MASK      0xF
-#define DB_PWM_ADDR_RESERVED1_SHIFT 28
+#define DB_PWM_ADDR_RESERVED1_SHIFT     28
 };
 
-/* Parameters to RoCE firmware, passed in EDPM doorbell */
+/* Parameters to RDMA firmware, passed in EDPM doorbell */
 struct db_rdma_dpm_params {
         __le32 params;
-#define DB_RDMA_DPM_PARAMS_SIZE_MASK            0x3F
-#define DB_RDMA_DPM_PARAMS_SIZE_SHIFT           0
-#define DB_RDMA_DPM_PARAMS_DPM_TYPE_MASK        0x3
-#define DB_RDMA_DPM_PARAMS_DPM_TYPE_SHIFT       6
-#define DB_RDMA_DPM_PARAMS_OPCODE_MASK          0xFF
-#define DB_RDMA_DPM_PARAMS_OPCODE_SHIFT         8
-#define DB_RDMA_DPM_PARAMS_WQE_SIZE_MASK        0x7FF
-#define DB_RDMA_DPM_PARAMS_WQE_SIZE_SHIFT       16
-#define DB_RDMA_DPM_PARAMS_RESERVED0_MASK       0x1
-#define DB_RDMA_DPM_PARAMS_RESERVED0_SHIFT      27
-#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_MASK  0x1
-#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_SHIFT 28
-#define DB_RDMA_DPM_PARAMS_S_FLG_MASK           0x1
-#define DB_RDMA_DPM_PARAMS_S_FLG_SHIFT          29
-#define DB_RDMA_DPM_PARAMS_RESERVED1_MASK       0x1
-#define DB_RDMA_DPM_PARAMS_RESERVED1_SHIFT      30
+#define DB_RDMA_DPM_PARAMS_SIZE_MASK                    0x3F
+#define DB_RDMA_DPM_PARAMS_SIZE_SHIFT                   0
+#define DB_RDMA_DPM_PARAMS_DPM_TYPE_MASK                0x3
+#define DB_RDMA_DPM_PARAMS_DPM_TYPE_SHIFT               6
+#define DB_RDMA_DPM_PARAMS_OPCODE_MASK                  0xFF
+#define DB_RDMA_DPM_PARAMS_OPCODE_SHIFT                 8
+#define DB_RDMA_DPM_PARAMS_WQE_SIZE_MASK                0x7FF
+#define DB_RDMA_DPM_PARAMS_WQE_SIZE_SHIFT               16
+#define DB_RDMA_DPM_PARAMS_RESERVED0_MASK               0x1
+#define DB_RDMA_DPM_PARAMS_RESERVED0_SHIFT              27
+#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_MASK          0x1
+#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_SHIFT         28
+#define DB_RDMA_DPM_PARAMS_S_FLG_MASK                   0x1
+#define DB_RDMA_DPM_PARAMS_S_FLG_SHIFT                  29
+#define DB_RDMA_DPM_PARAMS_RESERVED1_MASK               0x1
+#define DB_RDMA_DPM_PARAMS_RESERVED1_SHIFT              30
 #define DB_RDMA_DPM_PARAMS_CONN_TYPE_IS_IWARP_MASK      0x1
 #define DB_RDMA_DPM_PARAMS_CONN_TYPE_IS_IWARP_SHIFT     31
 };
 
-/* Structure for doorbell data, in ROCE DPM mode, for 1st db in a DPM burst */
+/* Structure for doorbell data, in RDMA DPM mode, for the first doorbell in a
+ * DPM burst.
+ */
 struct db_rdma_dpm_data {
         __le16 icid;
         __le16 prod_val;
@@ -987,22 +961,22 @@ enum igu_int_cmd {
 
 /* IGU producer or consumer update command */
 struct igu_prod_cons_update {
-        u32 sb_id_and_flags;
-#define IGU_PROD_CONS_UPDATE_SB_INDEX_MASK        0xFFFFFF
-#define IGU_PROD_CONS_UPDATE_SB_INDEX_SHIFT       0
-#define IGU_PROD_CONS_UPDATE_UPDATE_FLAG_MASK     0x1
-#define IGU_PROD_CONS_UPDATE_UPDATE_FLAG_SHIFT    24
-#define IGU_PROD_CONS_UPDATE_ENABLE_INT_MASK      0x3
-#define IGU_PROD_CONS_UPDATE_ENABLE_INT_SHIFT     25
-#define IGU_PROD_CONS_UPDATE_SEGMENT_ACCESS_MASK  0x1
-#define IGU_PROD_CONS_UPDATE_SEGMENT_ACCESS_SHIFT 27
-#define IGU_PROD_CONS_UPDATE_TIMER_MASK_MASK      0x1
-#define IGU_PROD_CONS_UPDATE_TIMER_MASK_SHIFT     28
-#define IGU_PROD_CONS_UPDATE_RESERVED0_MASK       0x3
-#define IGU_PROD_CONS_UPDATE_RESERVED0_SHIFT      29
-#define IGU_PROD_CONS_UPDATE_COMMAND_TYPE_MASK    0x1
-#define IGU_PROD_CONS_UPDATE_COMMAND_TYPE_SHIFT   31
-        u32 reserved1;
+        __le32 sb_id_and_flags;
+#define IGU_PROD_CONS_UPDATE_SB_INDEX_MASK              0xFFFFFF
+#define IGU_PROD_CONS_UPDATE_SB_INDEX_SHIFT             0
+#define IGU_PROD_CONS_UPDATE_UPDATE_FLAG_MASK           0x1
+#define IGU_PROD_CONS_UPDATE_UPDATE_FLAG_SHIFT          24
+#define IGU_PROD_CONS_UPDATE_ENABLE_INT_MASK            0x3
+#define IGU_PROD_CONS_UPDATE_ENABLE_INT_SHIFT           25
+#define IGU_PROD_CONS_UPDATE_SEGMENT_ACCESS_MASK        0x1
+#define IGU_PROD_CONS_UPDATE_SEGMENT_ACCESS_SHIFT       27
+#define IGU_PROD_CONS_UPDATE_TIMER_MASK_MASK            0x1
+#define IGU_PROD_CONS_UPDATE_TIMER_MASK_SHIFT           28
+#define IGU_PROD_CONS_UPDATE_RESERVED0_MASK             0x3
+#define IGU_PROD_CONS_UPDATE_RESERVED0_SHIFT            29
+#define IGU_PROD_CONS_UPDATE_COMMAND_TYPE_MASK          0x1
+#define IGU_PROD_CONS_UPDATE_COMMAND_TYPE_SHIFT         31
+        __le32 reserved1;
 };
 
 /* Igu segments access for default status block only */
@@ -1012,38 +986,63 @@ enum igu_seg_access {
         MAX_IGU_SEG_ACCESS
 };
 
+/* Enumeration for L3 type field of parsing_and_err_flags.
+ * L3Type: 0 - unknown (not ip), 1 - Ipv4, 2 - Ipv6
+ * (This field can be filled according to the last-ethertype)
+ */
+enum l3_type {
+        e_l3_type_unknown,
+        e_l3_type_ipv4,
+        e_l3_type_ipv6,
+        MAX_L3_TYPE
+};
+
+/* Enumeration for l4Protocol field of parsing_and_err_flags.
+ * L4-protocol: 0 - none, 1 - TCP, 2 - UDP.
+ * If the packet is IPv4 fragment, and its not the first fragment, the
+ * protocol-type should be set to none.
+ */
+enum l4_protocol {
+        e_l4_protocol_none,
+        e_l4_protocol_tcp,
+        e_l4_protocol_udp,
+        MAX_L4_PROTOCOL
+};
+
+/* Parsing and error flags field */
 struct parsing_and_err_flags {
         __le16 flags;
-#define PARSING_AND_ERR_FLAGS_L3TYPE_MASK                      0x3
-#define PARSING_AND_ERR_FLAGS_L3TYPE_SHIFT                     0
-#define PARSING_AND_ERR_FLAGS_L4PROTOCOL_MASK                  0x3
-#define PARSING_AND_ERR_FLAGS_L4PROTOCOL_SHIFT                 2
-#define PARSING_AND_ERR_FLAGS_IPV4FRAG_MASK                    0x1
-#define PARSING_AND_ERR_FLAGS_IPV4FRAG_SHIFT                   4
-#define PARSING_AND_ERR_FLAGS_TAG8021QEXIST_MASK               0x1
-#define PARSING_AND_ERR_FLAGS_TAG8021QEXIST_SHIFT              5
-#define PARSING_AND_ERR_FLAGS_L4CHKSMWASCALCULATED_MASK        0x1
-#define PARSING_AND_ERR_FLAGS_L4CHKSMWASCALCULATED_SHIFT       6
-#define PARSING_AND_ERR_FLAGS_TIMESYNCPKT_MASK                 0x1
-#define PARSING_AND_ERR_FLAGS_TIMESYNCPKT_SHIFT                7
-#define PARSING_AND_ERR_FLAGS_TIMESTAMPRECORDED_MASK           0x1
-#define PARSING_AND_ERR_FLAGS_TIMESTAMPRECORDED_SHIFT          8
-#define PARSING_AND_ERR_FLAGS_IPHDRERROR_MASK                  0x1
-#define PARSING_AND_ERR_FLAGS_IPHDRERROR_SHIFT                 9
-#define PARSING_AND_ERR_FLAGS_L4CHKSMERROR_MASK                0x1
-#define PARSING_AND_ERR_FLAGS_L4CHKSMERROR_SHIFT               10
-#define PARSING_AND_ERR_FLAGS_TUNNELEXIST_MASK                 0x1
-#define PARSING_AND_ERR_FLAGS_TUNNELEXIST_SHIFT                11
-#define PARSING_AND_ERR_FLAGS_TUNNEL8021QTAGEXIST_MASK         0x1
-#define PARSING_AND_ERR_FLAGS_TUNNEL8021QTAGEXIST_SHIFT        12
-#define PARSING_AND_ERR_FLAGS_TUNNELIPHDRERROR_MASK            0x1
-#define PARSING_AND_ERR_FLAGS_TUNNELIPHDRERROR_SHIFT           13
-#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMWASCALCULATED_MASK  0x1
-#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMWASCALCULATED_SHIFT 14
-#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMERROR_MASK          0x1
-#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMERROR_SHIFT         15
+#define PARSING_AND_ERR_FLAGS_L3TYPE_MASK                       0x3
+#define PARSING_AND_ERR_FLAGS_L3TYPE_SHIFT                      0
+#define PARSING_AND_ERR_FLAGS_L4PROTOCOL_MASK                   0x3
+#define PARSING_AND_ERR_FLAGS_L4PROTOCOL_SHIFT                  2
+#define PARSING_AND_ERR_FLAGS_IPV4FRAG_MASK                     0x1
+#define PARSING_AND_ERR_FLAGS_IPV4FRAG_SHIFT                    4
+#define PARSING_AND_ERR_FLAGS_TAG8021QEXIST_MASK                0x1
+#define PARSING_AND_ERR_FLAGS_TAG8021QEXIST_SHIFT               5
+#define PARSING_AND_ERR_FLAGS_L4CHKSMWASCALCULATED_MASK         0x1
+#define PARSING_AND_ERR_FLAGS_L4CHKSMWASCALCULATED_SHIFT        6
+#define PARSING_AND_ERR_FLAGS_TIMESYNCPKT_MASK                  0x1
+#define PARSING_AND_ERR_FLAGS_TIMESYNCPKT_SHIFT                 7
+#define PARSING_AND_ERR_FLAGS_TIMESTAMPRECORDED_MASK            0x1
+#define PARSING_AND_ERR_FLAGS_TIMESTAMPRECORDED_SHIFT           8
+#define PARSING_AND_ERR_FLAGS_IPHDRERROR_MASK                   0x1
+#define PARSING_AND_ERR_FLAGS_IPHDRERROR_SHIFT                  9
+#define PARSING_AND_ERR_FLAGS_L4CHKSMERROR_MASK                 0x1
+#define PARSING_AND_ERR_FLAGS_L4CHKSMERROR_SHIFT                10
+#define PARSING_AND_ERR_FLAGS_TUNNELEXIST_MASK                  0x1
+#define PARSING_AND_ERR_FLAGS_TUNNELEXIST_SHIFT                 11
+#define PARSING_AND_ERR_FLAGS_TUNNEL8021QTAGEXIST_MASK          0x1
+#define PARSING_AND_ERR_FLAGS_TUNNEL8021QTAGEXIST_SHIFT         12
+#define PARSING_AND_ERR_FLAGS_TUNNELIPHDRERROR_MASK             0x1
+#define PARSING_AND_ERR_FLAGS_TUNNELIPHDRERROR_SHIFT            13
+#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMWASCALCULATED_MASK   0x1
+#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMWASCALCULATED_SHIFT  14
+#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMERROR_MASK           0x1
+#define PARSING_AND_ERR_FLAGS_TUNNELL4CHKSMERROR_SHIFT          15
 };
 
+/* Parsing error flags bitmap */
 struct parsing_err_flags {
         __le16 flags;
 #define PARSING_ERR_FLAGS_MAC_ERROR_MASK                                0x1
@@ -1080,266 +1079,260 @@ struct parsing_err_flags {
 #define PARSING_ERR_FLAGS_TUNNEL_L4_CHKSM_ERROR_SHIFT                   15
 };
 
+/* Pb context */
 struct pb_context {
         __le32 crc[4];
 };
 
+/* Concrete Function ID */
 struct pxp_concrete_fid {
         __le16 fid;
-#define PXP_CONCRETE_FID_PFID_MASK     0xF
-#define PXP_CONCRETE_FID_PFID_SHIFT    0
-#define PXP_CONCRETE_FID_PORT_MASK     0x3
-#define PXP_CONCRETE_FID_PORT_SHIFT    4
-#define PXP_CONCRETE_FID_PATH_MASK     0x1
-#define PXP_CONCRETE_FID_PATH_SHIFT    6
-#define PXP_CONCRETE_FID_VFVALID_MASK  0x1
-#define PXP_CONCRETE_FID_VFVALID_SHIFT 7
-#define PXP_CONCRETE_FID_VFID_MASK     0xFF
-#define PXP_CONCRETE_FID_VFID_SHIFT    8
+#define PXP_CONCRETE_FID_PFID_MASK      0xF
+#define PXP_CONCRETE_FID_PFID_SHIFT     0
+#define PXP_CONCRETE_FID_PORT_MASK      0x3
+#define PXP_CONCRETE_FID_PORT_SHIFT     4
+#define PXP_CONCRETE_FID_PATH_MASK      0x1
+#define PXP_CONCRETE_FID_PATH_SHIFT     6
+#define PXP_CONCRETE_FID_VFVALID_MASK   0x1
+#define PXP_CONCRETE_FID_VFVALID_SHIFT  7
+#define PXP_CONCRETE_FID_VFID_MASK      0xFF
+#define PXP_CONCRETE_FID_VFID_SHIFT     8
 };
 
+/* Concrete Function ID */
 struct pxp_pretend_concrete_fid {
         __le16 fid;
-#define PXP_PRETEND_CONCRETE_FID_PFID_MASK      0xF
-#define PXP_PRETEND_CONCRETE_FID_PFID_SHIFT     0
-#define PXP_PRETEND_CONCRETE_FID_RESERVED_MASK  0x7
-#define PXP_PRETEND_CONCRETE_FID_RESERVED_SHIFT 4
-#define PXP_PRETEND_CONCRETE_FID_VFVALID_MASK   0x1
-#define PXP_PRETEND_CONCRETE_FID_VFVALID_SHIFT  7
-#define PXP_PRETEND_CONCRETE_FID_VFID_MASK      0xFF
-#define PXP_PRETEND_CONCRETE_FID_VFID_SHIFT     8
+#define PXP_PRETEND_CONCRETE_FID_PFID_MASK      0xF
+#define PXP_PRETEND_CONCRETE_FID_PFID_SHIFT     0
+#define PXP_PRETEND_CONCRETE_FID_RESERVED_MASK  0x7
+#define PXP_PRETEND_CONCRETE_FID_RESERVED_SHIFT 4
+#define PXP_PRETEND_CONCRETE_FID_VFVALID_MASK   0x1
+#define PXP_PRETEND_CONCRETE_FID_VFVALID_SHIFT  7
+#define PXP_PRETEND_CONCRETE_FID_VFID_MASK      0xFF
+#define PXP_PRETEND_CONCRETE_FID_VFID_SHIFT     8
 };
 
+/* Function ID */
 union pxp_pretend_fid {
         struct pxp_pretend_concrete_fid concrete_fid;
-        __le16                          opaque_fid;
+        __le16 opaque_fid;
 };
 
-/* Pxp Pretend Command Register. */
+/* Pxp Pretend Command Register */
 struct pxp_pretend_cmd {
-        union pxp_pretend_fid   fid;
-        __le16                  control;
-#define PXP_PRETEND_CMD_PATH_MASK              0x1
-#define PXP_PRETEND_CMD_PATH_SHIFT             0
-#define PXP_PRETEND_CMD_USE_PORT_MASK          0x1
-#define PXP_PRETEND_CMD_USE_PORT_SHIFT         1
-#define PXP_PRETEND_CMD_PORT_MASK              0x3
-#define PXP_PRETEND_CMD_PORT_SHIFT             2
-#define PXP_PRETEND_CMD_RESERVED0_MASK         0xF
-#define PXP_PRETEND_CMD_RESERVED0_SHIFT        4
-#define PXP_PRETEND_CMD_RESERVED1_MASK         0xF
-#define PXP_PRETEND_CMD_RESERVED1_SHIFT        8
-#define PXP_PRETEND_CMD_PRETEND_PATH_MASK      0x1
-#define PXP_PRETEND_CMD_PRETEND_PATH_SHIFT     12
-#define PXP_PRETEND_CMD_PRETEND_PORT_MASK      0x1
-#define PXP_PRETEND_CMD_PRETEND_PORT_SHIFT     13
-#define PXP_PRETEND_CMD_PRETEND_FUNCTION_MASK  0x1
-#define PXP_PRETEND_CMD_PRETEND_FUNCTION_SHIFT 14
-#define PXP_PRETEND_CMD_IS_CONCRETE_MASK       0x1
-#define PXP_PRETEND_CMD_IS_CONCRETE_SHIFT      15
+        union pxp_pretend_fid fid;
+        __le16 control;
+#define PXP_PRETEND_CMD_PATH_MASK               0x1
+#define PXP_PRETEND_CMD_PATH_SHIFT              0
+#define PXP_PRETEND_CMD_USE_PORT_MASK           0x1
+#define PXP_PRETEND_CMD_USE_PORT_SHIFT          1
+#define PXP_PRETEND_CMD_PORT_MASK               0x3
+#define PXP_PRETEND_CMD_PORT_SHIFT              2
+#define PXP_PRETEND_CMD_RESERVED0_MASK          0xF
+#define PXP_PRETEND_CMD_RESERVED0_SHIFT         4
+#define PXP_PRETEND_CMD_RESERVED1_MASK          0xF
+#define PXP_PRETEND_CMD_RESERVED1_SHIFT         8
+#define PXP_PRETEND_CMD_PRETEND_PATH_MASK       0x1
+#define PXP_PRETEND_CMD_PRETEND_PATH_SHIFT      12
+#define PXP_PRETEND_CMD_PRETEND_PORT_MASK       0x1
+#define PXP_PRETEND_CMD_PRETEND_PORT_SHIFT      13
+#define PXP_PRETEND_CMD_PRETEND_FUNCTION_MASK   0x1
+#define PXP_PRETEND_CMD_PRETEND_FUNCTION_SHIFT  14
+#define PXP_PRETEND_CMD_IS_CONCRETE_MASK        0x1
+#define PXP_PRETEND_CMD_IS_CONCRETE_SHIFT       15
 };
 
-/* PTT Record in PXP Admin Window. */
+/* PTT Record in PXP Admin Window */
 struct pxp_ptt_entry {
-        __le32                  offset;
-#define PXP_PTT_ENTRY_OFFSET_MASK     0x7FFFFF
-#define PXP_PTT_ENTRY_OFFSET_SHIFT    0
-#define PXP_PTT_ENTRY_RESERVED0_MASK  0x1FF
-#define PXP_PTT_ENTRY_RESERVED0_SHIFT 23
-        struct pxp_pretend_cmd  pretend;
+        __le32 offset;
+#define PXP_PTT_ENTRY_OFFSET_MASK       0x7FFFFF
+#define PXP_PTT_ENTRY_OFFSET_SHIFT      0
+#define PXP_PTT_ENTRY_RESERVED0_MASK    0x1FF
+#define PXP_PTT_ENTRY_RESERVED0_SHIFT   23
+        struct pxp_pretend_cmd pretend;
 };
 
-/* VF Zone A Permission Register. */
+/* VF Zone A Permission Register */
 struct pxp_vf_zone_a_permission {
         __le32 control;
-#define PXP_VF_ZONE_A_PERMISSION_VFID_MASK      0xFF
-#define PXP_VF_ZONE_A_PERMISSION_VFID_SHIFT     0
-#define PXP_VF_ZONE_A_PERMISSION_VALID_MASK     0x1
-#define PXP_VF_ZONE_A_PERMISSION_VALID_SHIFT    8
-#define PXP_VF_ZONE_A_PERMISSION_RESERVED0_MASK 0x7F
-#define PXP_VF_ZONE_A_PERMISSION_RESERVED0_SHIFT 9
-#define PXP_VF_ZONE_A_PERMISSION_RESERVED1_MASK 0xFFFF
-#define PXP_VF_ZONE_A_PERMISSION_RESERVED1_SHIFT 16
+#define PXP_VF_ZONE_A_PERMISSION_VFID_MASK              0xFF
+#define PXP_VF_ZONE_A_PERMISSION_VFID_SHIFT             0
+#define PXP_VF_ZONE_A_PERMISSION_VALID_MASK             0x1
+#define PXP_VF_ZONE_A_PERMISSION_VALID_SHIFT            8
+#define PXP_VF_ZONE_A_PERMISSION_RESERVED0_MASK         0x7F
+#define PXP_VF_ZONE_A_PERMISSION_RESERVED0_SHIFT        9
+#define PXP_VF_ZONE_A_PERMISSION_RESERVED1_MASK         0xFFFF
+#define PXP_VF_ZONE_A_PERMISSION_RESERVED1_SHIFT        16
 };
 
-/* RSS hash type */
+/* Rdif context */
 struct rdif_task_context {
         __le32 initial_ref_tag;
         __le16 app_tag_value;
         __le16 app_tag_mask;
         u8 flags0;
-#define RDIF_TASK_CONTEXT_IGNOREAPPTAG_MASK            0x1
-#define RDIF_TASK_CONTEXT_IGNOREAPPTAG_SHIFT           0
-#define RDIF_TASK_CONTEXT_INITIALREFTAGVALID_MASK      0x1
-#define RDIF_TASK_CONTEXT_INITIALREFTAGVALID_SHIFT     1
-#define RDIF_TASK_CONTEXT_HOSTGUARDTYPE_MASK           0x1
-#define RDIF_TASK_CONTEXT_HOSTGUARDTYPE_SHIFT          2
-#define RDIF_TASK_CONTEXT_SETERRORWITHEOP_MASK         0x1
-#define RDIF_TASK_CONTEXT_SETERRORWITHEOP_SHIFT        3
-#define RDIF_TASK_CONTEXT_PROTECTIONTYPE_MASK          0x3
-#define RDIF_TASK_CONTEXT_PROTECTIONTYPE_SHIFT         4
-#define RDIF_TASK_CONTEXT_CRC_SEED_MASK                0x1
-#define RDIF_TASK_CONTEXT_CRC_SEED_SHIFT               6
-#define RDIF_TASK_CONTEXT_KEEPREFTAGCONST_MASK         0x1
-#define RDIF_TASK_CONTEXT_KEEPREFTAGCONST_SHIFT        7
+#define RDIF_TASK_CONTEXT_IGNORE_APP_TAG_MASK           0x1
+#define RDIF_TASK_CONTEXT_IGNORE_APP_TAG_SHIFT          0
+#define RDIF_TASK_CONTEXT_INITIAL_REF_TAG_VALID_MASK    0x1
+#define RDIF_TASK_CONTEXT_INITIAL_REF_TAG_VALID_SHIFT   1
+#define RDIF_TASK_CONTEXT_HOST_GUARD_TYPE_MASK          0x1
+#define RDIF_TASK_CONTEXT_HOST_GUARD_TYPE_SHIFT         2
+#define RDIF_TASK_CONTEXT_SET_ERROR_WITH_EOP_MASK       0x1
+#define RDIF_TASK_CONTEXT_SET_ERROR_WITH_EOP_SHIFT      3
+#define RDIF_TASK_CONTEXT_PROTECTION_TYPE_MASK          0x3
+#define RDIF_TASK_CONTEXT_PROTECTION_TYPE_SHIFT         4
+#define RDIF_TASK_CONTEXT_CRC_SEED_MASK                 0x1
+#define RDIF_TASK_CONTEXT_CRC_SEED_SHIFT                6
+#define RDIF_TASK_CONTEXT_KEEP_REF_TAG_CONST_MASK       0x1
+#define RDIF_TASK_CONTEXT_KEEP_REF_TAG_CONST_SHIFT      7
         u8 partial_dif_data[7];
         __le16 partial_crc_value;
         __le16 partial_checksum_value;
         __le32 offset_in_io;
         __le16 flags1;
-#define RDIF_TASK_CONTEXT_VALIDATEGUARD_MASK           0x1
-#define RDIF_TASK_CONTEXT_VALIDATEGUARD_SHIFT          0
-#define RDIF_TASK_CONTEXT_VALIDATEAPPTAG_MASK          0x1
-#define RDIF_TASK_CONTEXT_VALIDATEAPPTAG_SHIFT         1
-#define RDIF_TASK_CONTEXT_VALIDATEREFTAG_MASK          0x1
-#define RDIF_TASK_CONTEXT_VALIDATEREFTAG_SHIFT         2
-#define RDIF_TASK_CONTEXT_FORWARDGUARD_MASK            0x1
-#define RDIF_TASK_CONTEXT_FORWARDGUARD_SHIFT           3
-#define RDIF_TASK_CONTEXT_FORWARDAPPTAG_MASK           0x1
-#define RDIF_TASK_CONTEXT_FORWARDAPPTAG_SHIFT          4
-#define RDIF_TASK_CONTEXT_FORWARDREFTAG_MASK           0x1
-#define RDIF_TASK_CONTEXT_FORWARDREFTAG_SHIFT          5
-#define RDIF_TASK_CONTEXT_INTERVALSIZE_MASK            0x7
-#define RDIF_TASK_CONTEXT_INTERVALSIZE_SHIFT           6
-#define RDIF_TASK_CONTEXT_HOSTINTERFACE_MASK           0x3
-#define RDIF_TASK_CONTEXT_HOSTINTERFACE_SHIFT          9
-#define RDIF_TASK_CONTEXT_DIFBEFOREDATA_MASK           0x1
-#define RDIF_TASK_CONTEXT_DIFBEFOREDATA_SHIFT          11
-#define RDIF_TASK_CONTEXT_RESERVED0_MASK               0x1
-#define RDIF_TASK_CONTEXT_RESERVED0_SHIFT              12
-#define RDIF_TASK_CONTEXT_NETWORKINTERFACE_MASK        0x1
-#define RDIF_TASK_CONTEXT_NETWORKINTERFACE_SHIFT       13
-#define RDIF_TASK_CONTEXT_FORWARDAPPTAGWITHMASK_MASK   0x1
-#define RDIF_TASK_CONTEXT_FORWARDAPPTAGWITHMASK_SHIFT  14
-#define RDIF_TASK_CONTEXT_FORWARDREFTAGWITHMASK_MASK   0x1
-#define RDIF_TASK_CONTEXT_FORWARDREFTAGWITHMASK_SHIFT  15
+#define RDIF_TASK_CONTEXT_VALIDATE_GUARD_MASK                   0x1
+#define RDIF_TASK_CONTEXT_VALIDATE_GUARD_SHIFT                  0
+#define RDIF_TASK_CONTEXT_VALIDATE_APP_TAG_MASK                 0x1
+#define RDIF_TASK_CONTEXT_VALIDATE_APP_TAG_SHIFT                1
+#define RDIF_TASK_CONTEXT_VALIDATE_REF_TAG_MASK                 0x1
+#define RDIF_TASK_CONTEXT_VALIDATE_REF_TAG_SHIFT                2
+#define RDIF_TASK_CONTEXT_FORWARD_GUARD_MASK                    0x1
+#define RDIF_TASK_CONTEXT_FORWARD_GUARD_SHIFT                   3
+#define RDIF_TASK_CONTEXT_FORWARD_APP_TAG_MASK                  0x1
+#define RDIF_TASK_CONTEXT_FORWARD_APP_TAG_SHIFT                 4
+#define RDIF_TASK_CONTEXT_FORWARD_REF_TAG_MASK                  0x1
+#define RDIF_TASK_CONTEXT_FORWARD_REF_TAG_SHIFT                 5
+#define RDIF_TASK_CONTEXT_INTERVAL_SIZE_MASK                    0x7
+#define RDIF_TASK_CONTEXT_INTERVAL_SIZE_SHIFT                   6
+#define RDIF_TASK_CONTEXT_HOST_INTERFACE_MASK                   0x3
+#define RDIF_TASK_CONTEXT_HOST_INTERFACE_SHIFT                  9
+#define RDIF_TASK_CONTEXT_DIF_BEFORE_DATA_MASK                  0x1
+#define RDIF_TASK_CONTEXT_DIF_BEFORE_DATA_SHIFT                 11
+#define RDIF_TASK_CONTEXT_RESERVED0_MASK                        0x1
+#define RDIF_TASK_CONTEXT_RESERVED0_SHIFT                       12
+#define RDIF_TASK_CONTEXT_NETWORK_INTERFACE_MASK                0x1
+#define RDIF_TASK_CONTEXT_NETWORK_INTERFACE_SHIFT               13
+#define RDIF_TASK_CONTEXT_FORWARD_APP_TAG_WITH_MASK_MASK        0x1
+#define RDIF_TASK_CONTEXT_FORWARD_APP_TAG_WITH_MASK_SHIFT       14
+#define RDIF_TASK_CONTEXT_FORWARD_REF_TAG_WITH_MASK_MASK        0x1
+#define RDIF_TASK_CONTEXT_FORWARD_REF_TAG_WITH_MASK_SHIFT       15
         __le16 state;
-#define RDIF_TASK_CONTEXT_RECEIVEDDIFBYTESLEFT_MASK    0xF
-#define RDIF_TASK_CONTEXT_RECEIVEDDIFBYTESLEFT_SHIFT   0
-#define RDIF_TASK_CONTEXT_TRANSMITEDDIFBYTESLEFT_MASK  0xF
-#define RDIF_TASK_CONTEXT_TRANSMITEDDIFBYTESLEFT_SHIFT 4
-#define RDIF_TASK_CONTEXT_ERRORINIO_MASK               0x1
-#define RDIF_TASK_CONTEXT_ERRORINIO_SHIFT              8
-#define RDIF_TASK_CONTEXT_CHECKSUMOVERFLOW_MASK        0x1
-#define RDIF_TASK_CONTEXT_CHECKSUMOVERFLOW_SHIFT       9
-#define RDIF_TASK_CONTEXT_REFTAGMASK_MASK              0xF
-#define RDIF_TASK_CONTEXT_REFTAGMASK_SHIFT             10
-#define RDIF_TASK_CONTEXT_RESERVED1_MASK               0x3
-#define RDIF_TASK_CONTEXT_RESERVED1_SHIFT              14
+#define RDIF_TASK_CONTEXT_RECEIVED_DIF_BYTES_LEFT_MASK          0xF
+#define RDIF_TASK_CONTEXT_RECEIVED_DIF_BYTES_LEFT_SHIFT         0
+#define RDIF_TASK_CONTEXT_TRANSMITED_DIF_BYTES_LEFT_MASK        0xF
+#define RDIF_TASK_CONTEXT_TRANSMITED_DIF_BYTES_LEFT_SHIFT       4
+#define RDIF_TASK_CONTEXT_ERROR_IN_IO_MASK                      0x1
+#define RDIF_TASK_CONTEXT_ERROR_IN_IO_SHIFT                     8
+#define RDIF_TASK_CONTEXT_CHECKSUM_OVERFLOW_MASK                0x1
+#define RDIF_TASK_CONTEXT_CHECKSUM_OVERFLOW_SHIFT               9
+#define RDIF_TASK_CONTEXT_REF_TAG_MASK_MASK                     0xF
+#define RDIF_TASK_CONTEXT_REF_TAG_MASK_SHIFT                    10
+#define RDIF_TASK_CONTEXT_RESERVED1_MASK                        0x3
+#define RDIF_TASK_CONTEXT_RESERVED1_SHIFT                       14
         __le32 reserved2;
 };
 
-/* RSS hash type */
-enum rss_hash_type {
-        RSS_HASH_TYPE_DEFAULT   = 0,
-        RSS_HASH_TYPE_IPV4      = 1,
-        RSS_HASH_TYPE_TCP_IPV4  = 2,
-        RSS_HASH_TYPE_IPV6      = 3,
-        RSS_HASH_TYPE_TCP_IPV6  = 4,
-        RSS_HASH_TYPE_UDP_IPV4  = 5,
-        RSS_HASH_TYPE_UDP_IPV6  = 6,
-        MAX_RSS_HASH_TYPE
-};
-
-/* status block structure */
-struct status_block {
-        __le16  pi_array[PIS_PER_SB];
+/* Status block structure */
+struct status_block_e4 {
+        __le16  pi_array[PIS_PER_SB_E4];
         __le32  sb_num;
-#define STATUS_BLOCK_SB_NUM_MASK      0x1FF
-#define STATUS_BLOCK_SB_NUM_SHIFT     0
-#define STATUS_BLOCK_ZERO_PAD_MASK    0x7F
-#define STATUS_BLOCK_ZERO_PAD_SHIFT   9
-#define STATUS_BLOCK_ZERO_PAD2_MASK   0xFFFF
-#define STATUS_BLOCK_ZERO_PAD2_SHIFT  16
+#define STATUS_BLOCK_E4_SB_NUM_MASK     0x1FF
+#define STATUS_BLOCK_E4_SB_NUM_SHIFT    0
+#define STATUS_BLOCK_E4_ZERO_PAD_MASK   0x7F
+#define STATUS_BLOCK_E4_ZERO_PAD_SHIFT  9
+#define STATUS_BLOCK_E4_ZERO_PAD2_MASK  0xFFFF
+#define STATUS_BLOCK_E4_ZERO_PAD2_SHIFT 16
         __le32 prod_index;
-#define STATUS_BLOCK_PROD_INDEX_MASK  0xFFFFFF
-#define STATUS_BLOCK_PROD_INDEX_SHIFT 0
-#define STATUS_BLOCK_ZERO_PAD3_MASK   0xFF
-#define STATUS_BLOCK_ZERO_PAD3_SHIFT  24
+#define STATUS_BLOCK_E4_PROD_INDEX_MASK         0xFFFFFF
+#define STATUS_BLOCK_E4_PROD_INDEX_SHIFT        0
+#define STATUS_BLOCK_E4_ZERO_PAD3_MASK          0xFF
+#define STATUS_BLOCK_E4_ZERO_PAD3_SHIFT         24
 };
 
+/* Tdif context */
 struct tdif_task_context {
         __le32 initial_ref_tag;
         __le16 app_tag_value;
         __le16 app_tag_mask;
-        __le16 partial_crc_valueB;
-        __le16 partial_checksum_valueB;
+        __le16 partial_crc_value_b;
+        __le16 partial_checksum_value_b;
         __le16 stateB;
-#define TDIF_TASK_CONTEXT_RECEIVEDDIFBYTESLEFTB_MASK    0xF
-#define TDIF_TASK_CONTEXT_RECEIVEDDIFBYTESLEFTB_SHIFT   0
-#define TDIF_TASK_CONTEXT_TRANSMITEDDIFBYTESLEFTB_MASK  0xF
-#define TDIF_TASK_CONTEXT_TRANSMITEDDIFBYTESLEFTB_SHIFT 4
-#define TDIF_TASK_CONTEXT_ERRORINIOB_MASK               0x1
-#define TDIF_TASK_CONTEXT_ERRORINIOB_SHIFT              8
-#define TDIF_TASK_CONTEXT_CHECKSUMOVERFLOW_MASK         0x1
-#define TDIF_TASK_CONTEXT_CHECKSUMOVERFLOW_SHIFT        9
-#define TDIF_TASK_CONTEXT_RESERVED0_MASK                0x3F
-#define TDIF_TASK_CONTEXT_RESERVED0_SHIFT               10
+#define TDIF_TASK_CONTEXT_RECEIVED_DIF_BYTES_LEFT_B_MASK        0xF
+#define TDIF_TASK_CONTEXT_RECEIVED_DIF_BYTES_LEFT_B_SHIFT       0
+#define TDIF_TASK_CONTEXT_TRANSMITED_DIF_BYTES_LEFT_B_MASK      0xF
+#define TDIF_TASK_CONTEXT_TRANSMITED_DIF_BYTES_LEFT_B_SHIFT     4
+#define TDIF_TASK_CONTEXT_ERROR_IN_IO_B_MASK                    0x1
+#define TDIF_TASK_CONTEXT_ERROR_IN_IO_B_SHIFT                   8
+#define TDIF_TASK_CONTEXT_CHECKSUM_VERFLOW_MASK                 0x1
+#define TDIF_TASK_CONTEXT_CHECKSUM_VERFLOW_SHIFT                9
+#define TDIF_TASK_CONTEXT_RESERVED0_MASK                        0x3F
+#define TDIF_TASK_CONTEXT_RESERVED0_SHIFT                       10
         u8 reserved1;
         u8 flags0;
-#define TDIF_TASK_CONTEXT_IGNOREAPPTAG_MASK             0x1
-#define TDIF_TASK_CONTEXT_IGNOREAPPTAG_SHIFT            0
-#define TDIF_TASK_CONTEXT_INITIALREFTAGVALID_MASK       0x1
-#define TDIF_TASK_CONTEXT_INITIALREFTAGVALID_SHIFT      1
-#define TDIF_TASK_CONTEXT_HOSTGUARDTYPE_MASK            0x1
-#define TDIF_TASK_CONTEXT_HOSTGUARDTYPE_SHIFT           2
-#define TDIF_TASK_CONTEXT_SETERRORWITHEOP_MASK          0x1
-#define TDIF_TASK_CONTEXT_SETERRORWITHEOP_SHIFT         3
-#define TDIF_TASK_CONTEXT_PROTECTIONTYPE_MASK           0x3
-#define TDIF_TASK_CONTEXT_PROTECTIONTYPE_SHIFT          4
-#define TDIF_TASK_CONTEXT_CRC_SEED_MASK                 0x1
-#define TDIF_TASK_CONTEXT_CRC_SEED_SHIFT                6
-#define TDIF_TASK_CONTEXT_RESERVED2_MASK                0x1
-#define TDIF_TASK_CONTEXT_RESERVED2_SHIFT               7
+#define TDIF_TASK_CONTEXT_IGNORE_APP_TAG_MASK                   0x1
+#define TDIF_TASK_CONTEXT_IGNORE_APP_TAG_SHIFT                  0
+#define TDIF_TASK_CONTEXT_INITIAL_REF_TAG_VALID_MASK            0x1
+#define TDIF_TASK_CONTEXT_INITIAL_REF_TAG_VALID_SHIFT           1
+#define TDIF_TASK_CONTEXT_HOST_GUARD_TYPE_MASK                  0x1
+#define TDIF_TASK_CONTEXT_HOST_GUARD_TYPE_SHIFT                 2
+#define TDIF_TASK_CONTEXT_SET_ERROR_WITH_EOP_MASK               0x1
+#define TDIF_TASK_CONTEXT_SET_ERROR_WITH_EOP_SHIFT              3
+#define TDIF_TASK_CONTEXT_PROTECTION_TYPE_MASK                  0x3
+#define TDIF_TASK_CONTEXT_PROTECTION_TYPE_SHIFT                 4
+#define TDIF_TASK_CONTEXT_CRC_SEED_MASK                         0x1
+#define TDIF_TASK_CONTEXT_CRC_SEED_SHIFT                        6
+#define TDIF_TASK_CONTEXT_RESERVED2_MASK                        0x1
+#define TDIF_TASK_CONTEXT_RESERVED2_SHIFT                       7
         __le32 flags1;
-#define TDIF_TASK_CONTEXT_VALIDATEGUARD_MASK            0x1
-#define TDIF_TASK_CONTEXT_VALIDATEGUARD_SHIFT           0
-#define TDIF_TASK_CONTEXT_VALIDATEAPPTAG_MASK           0x1
-#define TDIF_TASK_CONTEXT_VALIDATEAPPTAG_SHIFT          1
-#define TDIF_TASK_CONTEXT_VALIDATEREFTAG_MASK           0x1
-#define TDIF_TASK_CONTEXT_VALIDATEREFTAG_SHIFT          2
-#define TDIF_TASK_CONTEXT_FORWARDGUARD_MASK             0x1
-#define TDIF_TASK_CONTEXT_FORWARDGUARD_SHIFT            3
-#define TDIF_TASK_CONTEXT_FORWARDAPPTAG_MASK            0x1
-#define TDIF_TASK_CONTEXT_FORWARDAPPTAG_SHIFT           4
-#define TDIF_TASK_CONTEXT_FORWARDREFTAG_MASK            0x1
-#define TDIF_TASK_CONTEXT_FORWARDREFTAG_SHIFT           5
-#define TDIF_TASK_CONTEXT_INTERVALSIZE_MASK             0x7
-#define TDIF_TASK_CONTEXT_INTERVALSIZE_SHIFT            6
-#define TDIF_TASK_CONTEXT_HOSTINTERFACE_MASK            0x3
-#define TDIF_TASK_CONTEXT_HOSTINTERFACE_SHIFT           9
-#define TDIF_TASK_CONTEXT_DIFBEFOREDATA_MASK            0x1
-#define TDIF_TASK_CONTEXT_DIFBEFOREDATA_SHIFT           11
-#define TDIF_TASK_CONTEXT_RESERVED3_MASK                0x1
-#define TDIF_TASK_CONTEXT_RESERVED3_SHIFT               12
-#define TDIF_TASK_CONTEXT_NETWORKINTERFACE_MASK         0x1
-#define TDIF_TASK_CONTEXT_NETWORKINTERFACE_SHIFT        13
-#define TDIF_TASK_CONTEXT_RECEIVEDDIFBYTESLEFTA_MASK    0xF
-#define TDIF_TASK_CONTEXT_RECEIVEDDIFBYTESLEFTA_SHIFT   14
-#define TDIF_TASK_CONTEXT_TRANSMITEDDIFBYTESLEFTA_MASK  0xF
-#define TDIF_TASK_CONTEXT_TRANSMITEDDIFBYTESLEFTA_SHIFT 18
-#define TDIF_TASK_CONTEXT_ERRORINIOA_MASK               0x1
-#define TDIF_TASK_CONTEXT_ERRORINIOA_SHIFT              22
-#define TDIF_TASK_CONTEXT_CHECKSUMOVERFLOWA_MASK        0x1
-#define TDIF_TASK_CONTEXT_CHECKSUMOVERFLOWA_SHIFT       23
-#define TDIF_TASK_CONTEXT_REFTAGMASK_MASK               0xF
-#define TDIF_TASK_CONTEXT_REFTAGMASK_SHIFT              24
-#define TDIF_TASK_CONTEXT_FORWARDAPPTAGWITHMASK_MASK    0x1
-#define TDIF_TASK_CONTEXT_FORWARDAPPTAGWITHMASK_SHIFT   28
-#define TDIF_TASK_CONTEXT_FORWARDREFTAGWITHMASK_MASK    0x1
-#define TDIF_TASK_CONTEXT_FORWARDREFTAGWITHMASK_SHIFT   29
-#define TDIF_TASK_CONTEXT_KEEPREFTAGCONST_MASK          0x1
-#define TDIF_TASK_CONTEXT_KEEPREFTAGCONST_SHIFT         30
-#define TDIF_TASK_CONTEXT_RESERVED4_MASK                0x1
-#define TDIF_TASK_CONTEXT_RESERVED4_SHIFT               31
-        __le32 offset_in_iob;
+#define TDIF_TASK_CONTEXT_VALIDATE_GUARD_MASK                   0x1
+#define TDIF_TASK_CONTEXT_VALIDATE_GUARD_SHIFT                  0
+#define TDIF_TASK_CONTEXT_VALIDATE_APP_TAG_MASK                 0x1
+#define TDIF_TASK_CONTEXT_VALIDATE_APP_TAG_SHIFT                1
+#define TDIF_TASK_CONTEXT_VALIDATE_REF_TAG_MASK                 0x1
+#define TDIF_TASK_CONTEXT_VALIDATE_REF_TAG_SHIFT                2
+#define TDIF_TASK_CONTEXT_FORWARD_GUARD_MASK                    0x1
+#define TDIF_TASK_CONTEXT_FORWARD_GUARD_SHIFT                   3
+#define TDIF_TASK_CONTEXT_FORWARD_APP_TAG_MASK                  0x1
+#define TDIF_TASK_CONTEXT_FORWARD_APP_TAG_SHIFT                 4
+#define TDIF_TASK_CONTEXT_FORWARD_REF_TAG_MASK                  0x1
+#define TDIF_TASK_CONTEXT_FORWARD_REF_TAG_SHIFT                 5
+#define TDIF_TASK_CONTEXT_INTERVAL_SIZE_MASK                    0x7
+#define TDIF_TASK_CONTEXT_INTERVAL_SIZE_SHIFT                   6
+#define TDIF_TASK_CONTEXT_HOST_INTERFACE_MASK                   0x3
+#define TDIF_TASK_CONTEXT_HOST_INTERFACE_SHIFT                  9
+#define TDIF_TASK_CONTEXT_DIF_BEFORE_DATA_MASK                  0x1
+#define TDIF_TASK_CONTEXT_DIF_BEFORE_DATA_SHIFT                 11
+#define TDIF_TASK_CONTEXT_RESERVED3_MASK                        0x1
+#define TDIF_TASK_CONTEXT_RESERVED3_SHIFT                       12
+#define TDIF_TASK_CONTEXT_NETWORK_INTERFACE_MASK                0x1
+#define TDIF_TASK_CONTEXT_NETWORK_INTERFACE_SHIFT               13
+#define TDIF_TASK_CONTEXT_RECEIVED_DIF_BYTES_LEFT_A_MASK        0xF
+#define TDIF_TASK_CONTEXT_RECEIVED_DIF_BYTES_LEFT_A_SHIFT       14
+#define TDIF_TASK_CONTEXT_TRANSMITED_DIF_BYTES_LEFT_A_MASK      0xF
+#define TDIF_TASK_CONTEXT_TRANSMITED_DIF_BYTES_LEFT_A_SHIFT     18
+#define TDIF_TASK_CONTEXT_ERROR_IN_IO_A_MASK                    0x1
+#define TDIF_TASK_CONTEXT_ERROR_IN_IO_A_SHIFT                   22
+#define TDIF_TASK_CONTEXT_CHECKSUM_OVERFLOW_A_MASK              0x1
+#define TDIF_TASK_CONTEXT_CHECKSUM_OVERFLOW_A_SHIFT             23
+#define TDIF_TASK_CONTEXT_REF_TAG_MASK_MASK                     0xF
+#define TDIF_TASK_CONTEXT_REF_TAG_MASK_SHIFT                    24
+#define TDIF_TASK_CONTEXT_FORWARD_APP_TAG_WITH_MASK_MASK        0x1
+#define TDIF_TASK_CONTEXT_FORWARD_APP_TAG_WITH_MASK_SHIFT       28
+#define TDIF_TASK_CONTEXT_FORWARD_REF_TAG_WITH_MASK_MASK        0x1
+#define TDIF_TASK_CONTEXT_FORWARD_REF_TAG_WITH_MASK_SHIFT       29
+#define TDIF_TASK_CONTEXT_KEEP_REF_TAG_CONST_MASK               0x1
+#define TDIF_TASK_CONTEXT_KEEP_REF_TAG_CONST_SHIFT              30
+#define TDIF_TASK_CONTEXT_RESERVED4_MASK                        0x1
+#define TDIF_TASK_CONTEXT_RESERVED4_SHIFT                       31
+        __le32 offset_in_io_b;
         __le16 partial_crc_value_a;
-        __le16 partial_checksum_valuea_;
-        __le32 offset_in_ioa;
+        __le16 partial_checksum_value_a;
+        __le32 offset_in_io_a;
         u8 partial_dif_data_a[8];
         u8 partial_dif_data_b[8];
 };
 
+/* Timers context */
 struct timers_context {
         __le32 logical_client_0;
 #define TIMERS_CONTEXT_EXPIRATIONTIMELC0_MASK   0x7FFFFFF
@@ -1385,6 +1378,7 @@ struct timers_context {
 #define TIMERS_CONTEXT_RESERVED7_SHIFT                  29
 };
 
+/* Enum for next_protocol field of tunnel_parsing_flags / tunnelTypeDesc */
 enum tunnel_next_protocol {
         e_unknown = 0,
         e_l2 = 1,
diff --git a/include/linux/qed/eth_common.h b/include/linux/qed/eth_common.h
index cb06e6e368e1..9db02856623b 100644
--- a/include/linux/qed/eth_common.h
+++ b/include/linux/qed/eth_common.h
@@ -36,150 +36,168 @@
 /********************/
 /* ETH FW CONSTANTS */
 /********************/
-#define ETH_HSI_VER_MAJOR                   3
-#define ETH_HSI_VER_MINOR       10
+
+#define ETH_HSI_VER_MAJOR               3
+#define ETH_HSI_VER_MINOR               10
 
 #define ETH_HSI_VER_NO_PKT_LEN_TUNN     5
 
-#define ETH_CACHE_LINE_SIZE                 64
-#define ETH_RX_CQE_GAP  32
-#define ETH_MAX_RAMROD_PER_CON                          8
-#define ETH_TX_BD_PAGE_SIZE_BYTES                       4096
-#define ETH_RX_BD_PAGE_SIZE_BYTES                       4096
-#define ETH_RX_CQE_PAGE_SIZE_BYTES                      4096
-#define ETH_RX_NUM_NEXT_PAGE_BDS                        2
-
-#define ETH_MAX_TUNN_LSO_INNER_IPV4_OFFSET          253
-#define ETH_MAX_TUNN_LSO_INNER_IPV6_OFFSET          251
-
-#define ETH_TX_MIN_BDS_PER_NON_LSO_PKT                          1
-#define ETH_TX_MAX_BDS_PER_NON_LSO_PACKET                       18
-#define ETH_TX_MAX_BDS_PER_LSO_PACKET   255
-#define ETH_TX_MAX_LSO_HDR_NBD                                          4
-#define ETH_TX_MIN_BDS_PER_LSO_PKT                                      3
-#define ETH_TX_MIN_BDS_PER_TUNN_IPV6_WITH_EXT_PKT       3
-#define ETH_TX_MIN_BDS_PER_IPV6_WITH_EXT_PKT            2
-#define ETH_TX_MIN_BDS_PER_PKT_W_LOOPBACK_MODE          2
-#define ETH_TX_MAX_NON_LSO_PKT_LEN      (9700 - (4 + 4 + 12 + 8))
-#define ETH_TX_MAX_LSO_HDR_BYTES                    510
-#define ETH_TX_LSO_WINDOW_BDS_NUM       (18 - 1)
-#define ETH_TX_LSO_WINDOW_MIN_LEN       9700
-#define ETH_TX_MAX_LSO_PAYLOAD_LEN      0xFE000
-#define ETH_TX_NUM_SAME_AS_LAST_ENTRIES 320
-#define ETH_TX_INACTIVE_SAME_AS_LAST    0xFFFF
-
-#define ETH_NUM_STATISTIC_COUNTERS                      MAX_NUM_VPORTS
+#define ETH_CACHE_LINE_SIZE             64
+#define ETH_RX_CQE_GAP                  32
+#define ETH_MAX_RAMROD_PER_CON          8
+#define ETH_TX_BD_PAGE_SIZE_BYTES       4096
+#define ETH_RX_BD_PAGE_SIZE_BYTES       4096
+#define ETH_RX_CQE_PAGE_SIZE_BYTES      4096
+#define ETH_RX_NUM_NEXT_PAGE_BDS        2
+
+#define ETH_MAX_TUNN_LSO_INNER_IPV4_OFFSET      253
+#define ETH_MAX_TUNN_LSO_INNER_IPV6_OFFSET      251
+
+#define ETH_TX_MIN_BDS_PER_NON_LSO_PKT                  1
+#define ETH_TX_MAX_BDS_PER_NON_LSO_PACKET               18
+#define ETH_TX_MAX_BDS_PER_LSO_PACKET                   255
+#define ETH_TX_MAX_LSO_HDR_NBD                          4
+#define ETH_TX_MIN_BDS_PER_LSO_PKT                      3
+#define ETH_TX_MIN_BDS_PER_TUNN_IPV6_WITH_EXT_PKT       3
+#define ETH_TX_MIN_BDS_PER_IPV6_WITH_EXT_PKT            2
+#define ETH_TX_MIN_BDS_PER_PKT_W_LOOPBACK_MODE          2
+#define ETH_TX_MAX_NON_LSO_PKT_LEN              (9700 - (4 + 4 + 12 + 8))
+#define ETH_TX_MAX_LSO_HDR_BYTES                        510
+#define ETH_TX_LSO_WINDOW_BDS_NUM                       (18 - 1)
+#define ETH_TX_LSO_WINDOW_MIN_LEN                       9700
+#define ETH_TX_MAX_LSO_PAYLOAD_LEN                      0xFE000
+#define ETH_TX_NUM_SAME_AS_LAST_ENTRIES                 320
+#define ETH_TX_INACTIVE_SAME_AS_LAST                    0xFFFF
+
+#define ETH_NUM_STATISTIC_COUNTERS                      MAX_NUM_VPORTS
 #define ETH_NUM_STATISTIC_COUNTERS_DOUBLE_VF_ZONE \
         (ETH_NUM_STATISTIC_COUNTERS - MAX_NUM_VFS / 2)
 #define ETH_NUM_STATISTIC_COUNTERS_QUAD_VF_ZONE \
         (ETH_NUM_STATISTIC_COUNTERS - 3 * MAX_NUM_VFS / 4)
 
 /* Maximum number of buffers, used for RX packet placement */
-#define ETH_RX_MAX_BUFF_PER_PKT 5
-#define ETH_RX_BD_THRESHOLD     12
+#define ETH_RX_MAX_BUFF_PER_PKT         5
+#define ETH_RX_BD_THRESHOLD             12
 
-/* num of MAC/VLAN filters */
-#define ETH_NUM_MAC_FILTERS                                     512
-#define ETH_NUM_VLAN_FILTERS                            512
+/* Num of MAC/VLAN filters */
+#define ETH_NUM_MAC_FILTERS             512
+#define ETH_NUM_VLAN_FILTERS            512
 
-/* approx. multicast constants */
-#define ETH_MULTICAST_BIN_FROM_MAC_SEED     0
-#define ETH_MULTICAST_MAC_BINS                          256
-#define ETH_MULTICAST_MAC_BINS_IN_REGS          (ETH_MULTICAST_MAC_BINS / 32)
+/* Approx. multicast constants */
+#define ETH_MULTICAST_BIN_FROM_MAC_SEED 0
+#define ETH_MULTICAST_MAC_BINS          256
+#define ETH_MULTICAST_MAC_BINS_IN_REGS  (ETH_MULTICAST_MAC_BINS / 32)
 
-/*  ethernet vport update constants */
-#define ETH_FILTER_RULES_COUNT                          10
-#define ETH_RSS_IND_TABLE_ENTRIES_NUM           128
-#define ETH_RSS_KEY_SIZE_REGS                       10
-#define ETH_RSS_ENGINE_NUM_K2               207
-#define ETH_RSS_ENGINE_NUM_BB               127
+/* Ethernet vport update constants */
+#define ETH_FILTER_RULES_COUNT          10
+#define ETH_RSS_IND_TABLE_ENTRIES_NUM   128
+#define ETH_RSS_KEY_SIZE_REGS           10
+#define ETH_RSS_ENGINE_NUM_K2           207
+#define ETH_RSS_ENGINE_NUM_BB           127
 
 /* TPA constants */
-#define ETH_TPA_MAX_AGGS_NUM              64
-#define ETH_TPA_CQE_START_LEN_LIST_SIZE   ETH_RX_MAX_BUFF_PER_PKT
-#define ETH_TPA_CQE_CONT_LEN_LIST_SIZE    6
-#define ETH_TPA_CQE_END_LEN_LIST_SIZE     4
+#define ETH_TPA_MAX_AGGS_NUM            64
+#define ETH_TPA_CQE_START_LEN_LIST_SIZE ETH_RX_MAX_BUFF_PER_PKT
+#define ETH_TPA_CQE_CONT_LEN_LIST_SIZE  6
+#define ETH_TPA_CQE_END_LEN_LIST_SIZE   4
 
 /* Control frame check constants */
 #define ETH_CTL_FRAME_ETH_TYPE_NUM      4
 
+/* GFS constants */
+#define ETH_GFT_TRASH_CAN_VPORT         0x1FF
+
+/* Destination port mode */
+enum dest_port_mode {
+        DEST_PORT_PHY,
+        DEST_PORT_LOOPBACK,
+        DEST_PORT_PHY_LOOPBACK,
+        DEST_PORT_DROP,
+        MAX_DEST_PORT_MODE
+};
+
+/* Ethernet address type */
+enum eth_addr_type {
+        BROADCAST_ADDRESS,
+        MULTICAST_ADDRESS,
+        UNICAST_ADDRESS,
+        UNKNOWN_ADDRESS,
+        MAX_ETH_ADDR_TYPE
+};
+
 struct eth_tx_1st_bd_flags {
         u8 bitfields;
-#define ETH_TX_1ST_BD_FLAGS_START_BD_MASK         0x1
-#define ETH_TX_1ST_BD_FLAGS_START_BD_SHIFT        0
-#define ETH_TX_1ST_BD_FLAGS_FORCE_VLAN_MODE_MASK  0x1
-#define ETH_TX_1ST_BD_FLAGS_FORCE_VLAN_MODE_SHIFT 1
-#define ETH_TX_1ST_BD_FLAGS_IP_CSUM_MASK          0x1
-#define ETH_TX_1ST_BD_FLAGS_IP_CSUM_SHIFT         2
-#define ETH_TX_1ST_BD_FLAGS_L4_CSUM_MASK          0x1
-#define ETH_TX_1ST_BD_FLAGS_L4_CSUM_SHIFT         3
-#define ETH_TX_1ST_BD_FLAGS_VLAN_INSERTION_MASK   0x1
-#define ETH_TX_1ST_BD_FLAGS_VLAN_INSERTION_SHIFT  4
-#define ETH_TX_1ST_BD_FLAGS_LSO_MASK              0x1
-#define ETH_TX_1ST_BD_FLAGS_LSO_SHIFT             5
-#define ETH_TX_1ST_BD_FLAGS_TUNN_IP_CSUM_MASK     0x1
-#define ETH_TX_1ST_BD_FLAGS_TUNN_IP_CSUM_SHIFT    6
-#define ETH_TX_1ST_BD_FLAGS_TUNN_L4_CSUM_MASK     0x1
-#define ETH_TX_1ST_BD_FLAGS_TUNN_L4_CSUM_SHIFT    7
+#define ETH_TX_1ST_BD_FLAGS_START_BD_MASK               0x1
+#define ETH_TX_1ST_BD_FLAGS_START_BD_SHIFT              0
+#define ETH_TX_1ST_BD_FLAGS_FORCE_VLAN_MODE_MASK        0x1
+#define ETH_TX_1ST_BD_FLAGS_FORCE_VLAN_MODE_SHIFT       1
+#define ETH_TX_1ST_BD_FLAGS_IP_CSUM_MASK                0x1
+#define ETH_TX_1ST_BD_FLAGS_IP_CSUM_SHIFT               2
+#define ETH_TX_1ST_BD_FLAGS_L4_CSUM_MASK                0x1
+#define ETH_TX_1ST_BD_FLAGS_L4_CSUM_SHIFT               3
+#define ETH_TX_1ST_BD_FLAGS_VLAN_INSERTION_MASK         0x1
+#define ETH_TX_1ST_BD_FLAGS_VLAN_INSERTION_SHIFT        4
+#define ETH_TX_1ST_BD_FLAGS_LSO_MASK                    0x1
+#define ETH_TX_1ST_BD_FLAGS_LSO_SHIFT                   5
+#define ETH_TX_1ST_BD_FLAGS_TUNN_IP_CSUM_MASK           0x1
+#define ETH_TX_1ST_BD_FLAGS_TUNN_IP_CSUM_SHIFT          6
+#define ETH_TX_1ST_BD_FLAGS_TUNN_L4_CSUM_MASK           0x1
+#define ETH_TX_1ST_BD_FLAGS_TUNN_L4_CSUM_SHIFT          7
 };
 
-/* The parsing information data fo rthe first tx bd of a given packet. */
+/* The parsing information data fo rthe first tx bd of a given packet */
 struct eth_tx_data_1st_bd {
         __le16 vlan;
         u8 nbds;
         struct eth_tx_1st_bd_flags bd_flags;
         __le16 bitfields;
-#define ETH_TX_DATA_1ST_BD_TUNN_FLAG_MASK  0x1
-#define ETH_TX_DATA_1ST_BD_TUNN_FLAG_SHIFT 0
-#define ETH_TX_DATA_1ST_BD_RESERVED0_MASK          0x1
-#define ETH_TX_DATA_1ST_BD_RESERVED0_SHIFT         1
-#define ETH_TX_DATA_1ST_BD_PKT_LEN_MASK    0x3FFF
-#define ETH_TX_DATA_1ST_BD_PKT_LEN_SHIFT   2
+#define ETH_TX_DATA_1ST_BD_TUNN_FLAG_MASK       0x1
+#define ETH_TX_DATA_1ST_BD_TUNN_FLAG_SHIFT      0
+#define ETH_TX_DATA_1ST_BD_RESERVED0_MASK       0x1
+#define ETH_TX_DATA_1ST_BD_RESERVED0_SHIFT      1
+#define ETH_TX_DATA_1ST_BD_PKT_LEN_MASK         0x3FFF
+#define ETH_TX_DATA_1ST_BD_PKT_LEN_SHIFT        2
 };
 
-/* The parsing information data for the second tx bd of a given packet. */
+/* The parsing information data for the second tx bd of a given packet */
 struct eth_tx_data_2nd_bd {
         __le16 tunn_ip_size;
         __le16  bitfields1;
-#define ETH_TX_DATA_2ND_BD_TUNN_INNER_L2_HDR_SIZE_W_MASK  0xF
-#define ETH_TX_DATA_2ND_BD_TUNN_INNER_L2_HDR_SIZE_W_SHIFT 0
-#define ETH_TX_DATA_2ND_BD_TUNN_INNER_ETH_TYPE_MASK       0x3
-#define ETH_TX_DATA_2ND_BD_TUNN_INNER_ETH_TYPE_SHIFT      4
-#define ETH_TX_DATA_2ND_BD_DEST_PORT_MODE_MASK            0x3
-#define ETH_TX_DATA_2ND_BD_DEST_PORT_MODE_SHIFT           6
-#define ETH_TX_DATA_2ND_BD_START_BD_MASK                  0x1
-#define ETH_TX_DATA_2ND_BD_START_BD_SHIFT                 8
-#define ETH_TX_DATA_2ND_BD_TUNN_TYPE_MASK                 0x3
-#define ETH_TX_DATA_2ND_BD_TUNN_TYPE_SHIFT                9
-#define ETH_TX_DATA_2ND_BD_TUNN_INNER_IPV6_MASK           0x1
-#define ETH_TX_DATA_2ND_BD_TUNN_INNER_IPV6_SHIFT          11
-#define ETH_TX_DATA_2ND_BD_IPV6_EXT_MASK                  0x1
-#define ETH_TX_DATA_2ND_BD_IPV6_EXT_SHIFT                 12
-#define ETH_TX_DATA_2ND_BD_TUNN_IPV6_EXT_MASK             0x1
-#define ETH_TX_DATA_2ND_BD_TUNN_IPV6_EXT_SHIFT            13
-#define ETH_TX_DATA_2ND_BD_L4_UDP_MASK                    0x1
-#define ETH_TX_DATA_2ND_BD_L4_UDP_SHIFT                   14
-#define ETH_TX_DATA_2ND_BD_L4_PSEUDO_CSUM_MODE_MASK       0x1
-#define ETH_TX_DATA_2ND_BD_L4_PSEUDO_CSUM_MODE_SHIFT      15
+#define ETH_TX_DATA_2ND_BD_TUNN_INNER_L2_HDR_SIZE_W_MASK        0xF
+#define ETH_TX_DATA_2ND_BD_TUNN_INNER_L2_HDR_SIZE_W_SHIFT       0
+#define ETH_TX_DATA_2ND_BD_TUNN_INNER_ETH_TYPE_MASK             0x3
+#define ETH_TX_DATA_2ND_BD_TUNN_INNER_ETH_TYPE_SHIFT            4
+#define ETH_TX_DATA_2ND_BD_DEST_PORT_MODE_MASK                  0x3
+#define ETH_TX_DATA_2ND_BD_DEST_PORT_MODE_SHIFT                 6
+#define ETH_TX_DATA_2ND_BD_START_BD_MASK                        0x1
+#define ETH_TX_DATA_2ND_BD_START_BD_SHIFT                       8
+#define ETH_TX_DATA_2ND_BD_TUNN_TYPE_MASK                       0x3
+#define ETH_TX_DATA_2ND_BD_TUNN_TYPE_SHIFT                      9
+#define ETH_TX_DATA_2ND_BD_TUNN_INNER_IPV6_MASK                 0x1
+#define ETH_TX_DATA_2ND_BD_TUNN_INNER_IPV6_SHIFT                11
+#define ETH_TX_DATA_2ND_BD_IPV6_EXT_MASK                        0x1
+#define ETH_TX_DATA_2ND_BD_IPV6_EXT_SHIFT                       12
+#define ETH_TX_DATA_2ND_BD_TUNN_IPV6_EXT_MASK                   0x1
+#define ETH_TX_DATA_2ND_BD_TUNN_IPV6_EXT_SHIFT                  13
+#define ETH_TX_DATA_2ND_BD_L4_UDP_MASK                          0x1
+#define ETH_TX_DATA_2ND_BD_L4_UDP_SHIFT                         14
+#define ETH_TX_DATA_2ND_BD_L4_PSEUDO_CSUM_MODE_MASK             0x1
+#define ETH_TX_DATA_2ND_BD_L4_PSEUDO_CSUM_MODE_SHIFT            15
         __le16 bitfields2;
-#define ETH_TX_DATA_2ND_BD_L4_HDR_START_OFFSET_W_MASK     0x1FFF
-#define ETH_TX_DATA_2ND_BD_L4_HDR_START_OFFSET_W_SHIFT    0
-#define ETH_TX_DATA_2ND_BD_RESERVED0_MASK                 0x7
-#define ETH_TX_DATA_2ND_BD_RESERVED0_SHIFT                13
+#define ETH_TX_DATA_2ND_BD_L4_HDR_START_OFFSET_W_MASK           0x1FFF
+#define ETH_TX_DATA_2ND_BD_L4_HDR_START_OFFSET_W_SHIFT          0
+#define ETH_TX_DATA_2ND_BD_RESERVED0_MASK                       0x7
+#define ETH_TX_DATA_2ND_BD_RESERVED0_SHIFT                      13
 };
 
-/* Firmware data for L2-EDPM packet. */
+/* Firmware data for L2-EDPM packet */
 struct eth_edpm_fw_data {
         struct eth_tx_data_1st_bd data_1st_bd;
         struct eth_tx_data_2nd_bd data_2nd_bd;
         __le32 reserved;
 };
 
-struct eth_fast_path_cqe_fw_debug {
-        __le16 reserved2;
-};
-
-/*  tunneling parsing flags */
+/* Tunneling parsing flags */
 struct eth_tunnel_parsing_flags {
         u8 flags;
 #define ETH_TUNNEL_PARSING_FLAGS_TYPE_MASK              0x3
@@ -199,24 +217,24 @@ struct eth_tunnel_parsing_flags {
 /* PMD flow control bits */
 struct eth_pmd_flow_flags {
         u8 flags;
-#define ETH_PMD_FLOW_FLAGS_VALID_MASK   0x1
-#define ETH_PMD_FLOW_FLAGS_VALID_SHIFT  0
-#define ETH_PMD_FLOW_FLAGS_TOGGLE_MASK  0x1
-#define ETH_PMD_FLOW_FLAGS_TOGGLE_SHIFT 1
-#define ETH_PMD_FLOW_FLAGS_RESERVED_MASK 0x3F
-#define ETH_PMD_FLOW_FLAGS_RESERVED_SHIFT 2
+#define ETH_PMD_FLOW_FLAGS_VALID_MASK           0x1
+#define ETH_PMD_FLOW_FLAGS_VALID_SHIFT          0
+#define ETH_PMD_FLOW_FLAGS_TOGGLE_MASK          0x1
+#define ETH_PMD_FLOW_FLAGS_TOGGLE_SHIFT         1
+#define ETH_PMD_FLOW_FLAGS_RESERVED_MASK        0x3F
+#define ETH_PMD_FLOW_FLAGS_RESERVED_SHIFT       2
 };
 
-/* Regular ETH Rx FP CQE. */
+/* Regular ETH Rx FP CQE */
 struct eth_fast_path_rx_reg_cqe {
         u8 type;
         u8 bitfields;
-#define ETH_FAST_PATH_RX_REG_CQE_RSS_HASH_TYPE_MASK  0x7
-#define ETH_FAST_PATH_RX_REG_CQE_RSS_HASH_TYPE_SHIFT 0
-#define ETH_FAST_PATH_RX_REG_CQE_TC_MASK             0xF
-#define ETH_FAST_PATH_RX_REG_CQE_TC_SHIFT            3
-#define ETH_FAST_PATH_RX_REG_CQE_RESERVED0_MASK      0x1
-#define ETH_FAST_PATH_RX_REG_CQE_RESERVED0_SHIFT     7
+#define ETH_FAST_PATH_RX_REG_CQE_RSS_HASH_TYPE_MASK     0x7
+#define ETH_FAST_PATH_RX_REG_CQE_RSS_HASH_TYPE_SHIFT    0
+#define ETH_FAST_PATH_RX_REG_CQE_TC_MASK                0xF
+#define ETH_FAST_PATH_RX_REG_CQE_TC_SHIFT               3
+#define ETH_FAST_PATH_RX_REG_CQE_RESERVED0_MASK         0x1
+#define ETH_FAST_PATH_RX_REG_CQE_RESERVED0_SHIFT        7
         __le16 pkt_len;
         struct parsing_and_err_flags pars_flags;
         __le16 vlan_tag;
@@ -225,13 +243,13 @@ struct eth_fast_path_rx_reg_cqe {
         u8 placement_offset;
         struct eth_tunnel_parsing_flags tunnel_pars_flags;
         u8 bd_num;
-        u8 reserved[9];
-        struct eth_fast_path_cqe_fw_debug fw_debug;
-        u8 reserved1[3];
+        u8 reserved;
+        __le16 flow_id;
+        u8 reserved1[11];
         struct eth_pmd_flow_flags pmd_flags;
 };
 
-/* TPA-continue ETH Rx FP CQE. */
+/* TPA-continue ETH Rx FP CQE */
 struct eth_fast_path_rx_tpa_cont_cqe {
         u8 type;
         u8 tpa_agg_index;
@@ -243,7 +261,7 @@ struct eth_fast_path_rx_tpa_cont_cqe {
         struct eth_pmd_flow_flags pmd_flags;
 };
 
-/* TPA-end ETH Rx FP CQE. */
+/* TPA-end ETH Rx FP CQE */
 struct eth_fast_path_rx_tpa_end_cqe {
         u8 type;
         u8 tpa_agg_index;
@@ -259,16 +277,16 @@ struct eth_fast_path_rx_tpa_end_cqe {
         struct eth_pmd_flow_flags pmd_flags;
 };
 
-/* TPA-start ETH Rx FP CQE. */
+/* TPA-start ETH Rx FP CQE */
 struct eth_fast_path_rx_tpa_start_cqe {
         u8 type;
         u8 bitfields;
-#define ETH_FAST_PATH_RX_TPA_START_CQE_RSS_HASH_TYPE_MASK  0x7
-#define ETH_FAST_PATH_RX_TPA_START_CQE_RSS_HASH_TYPE_SHIFT 0
-#define ETH_FAST_PATH_RX_TPA_START_CQE_TC_MASK             0xF
-#define ETH_FAST_PATH_RX_TPA_START_CQE_TC_SHIFT            3
-#define ETH_FAST_PATH_RX_TPA_START_CQE_RESERVED0_MASK      0x1
-#define ETH_FAST_PATH_RX_TPA_START_CQE_RESERVED0_SHIFT     7
+#define ETH_FAST_PATH_RX_TPA_START_CQE_RSS_HASH_TYPE_MASK       0x7
+#define ETH_FAST_PATH_RX_TPA_START_CQE_RSS_HASH_TYPE_SHIFT      0
+#define ETH_FAST_PATH_RX_TPA_START_CQE_TC_MASK                  0xF
+#define ETH_FAST_PATH_RX_TPA_START_CQE_TC_SHIFT                 3
+#define ETH_FAST_PATH_RX_TPA_START_CQE_RESERVED0_MASK           0x1
+#define ETH_FAST_PATH_RX_TPA_START_CQE_RESERVED0_SHIFT          7
         __le16 seg_len;
         struct parsing_and_err_flags pars_flags;
         __le16 vlan_tag;
@@ -279,7 +297,7 @@ struct eth_fast_path_rx_tpa_start_cqe {
         u8 tpa_agg_index;
         u8 header_len;
         __le16 ext_bd_len_list[ETH_TPA_CQE_START_LEN_LIST_SIZE];
-        struct eth_fast_path_cqe_fw_debug fw_debug;
+        __le16 flow_id;
         u8 reserved;
         struct eth_pmd_flow_flags pmd_flags;
 };
@@ -295,24 +313,24 @@ struct eth_rx_bd {
         struct regpair addr;
 };
 
-/* regular ETH Rx SP CQE */
+/* Regular ETH Rx SP CQE */
 struct eth_slow_path_rx_cqe {
-        u8      type;
-        u8      ramrod_cmd_id;
-        u8      error_flag;
-        u8      reserved[25];
-        __le16  echo;
-        u8      reserved1;
+        u8 type;
+        u8 ramrod_cmd_id;
+        u8 error_flag;
+        u8 reserved[25];
+        __le16 echo;
+        u8 reserved1;
         struct eth_pmd_flow_flags pmd_flags;
 };
 
-/* union for all ETH Rx CQE types */
+/* Union for all ETH Rx CQE types */
 union eth_rx_cqe {
-        struct eth_fast_path_rx_reg_cqe         fast_path_regular;
-        struct eth_fast_path_rx_tpa_start_cqe   fast_path_tpa_start;
-        struct eth_fast_path_rx_tpa_cont_cqe    fast_path_tpa_cont;
-        struct eth_fast_path_rx_tpa_end_cqe     fast_path_tpa_end;
-        struct eth_slow_path_rx_cqe             slow_path;
+        struct eth_fast_path_rx_reg_cqe fast_path_regular;
+        struct eth_fast_path_rx_tpa_start_cqe fast_path_tpa_start;
+        struct eth_fast_path_rx_tpa_cont_cqe fast_path_tpa_cont;
+        struct eth_fast_path_rx_tpa_end_cqe fast_path_tpa_end;
+        struct eth_slow_path_rx_cqe slow_path;
 };
 
 /* ETH Rx CQE type */
@@ -339,7 +357,7 @@ enum eth_rx_tunn_type {
         MAX_ETH_RX_TUNN_TYPE
 };
 
-/*  Aggregation end reason. */
+/* Aggregation end reason. */
 enum eth_tpa_end_reason {
         ETH_AGG_END_UNUSED,
         ETH_AGG_END_SP_UPDATE,
@@ -354,59 +372,59 @@ enum eth_tpa_end_reason {
 
 /* The first tx bd of a given packet */
 struct eth_tx_1st_bd {
-        struct regpair                  addr;
-        __le16                          nbytes;
-        struct eth_tx_data_1st_bd       data;
+        struct regpair addr;
+        __le16 nbytes;
+        struct eth_tx_data_1st_bd data;
 };
 
 /* The second tx bd of a given packet */
 struct eth_tx_2nd_bd {
-        struct regpair                  addr;
-        __le16                          nbytes;
-        struct eth_tx_data_2nd_bd       data;
+        struct regpair addr;
+        __le16 nbytes;
+        struct eth_tx_data_2nd_bd data;
 };
 
-/* The parsing information data for the third tx bd of a given packet. */
+/* The parsing information data for the third tx bd of a given packet */
 struct eth_tx_data_3rd_bd {
         __le16 lso_mss;
         __le16 bitfields;
-#define ETH_TX_DATA_3RD_BD_TCP_HDR_LEN_DW_MASK  0xF
-#define ETH_TX_DATA_3RD_BD_TCP_HDR_LEN_DW_SHIFT 0
-#define ETH_TX_DATA_3RD_BD_HDR_NBD_MASK         0xF
-#define ETH_TX_DATA_3RD_BD_HDR_NBD_SHIFT        4
-#define ETH_TX_DATA_3RD_BD_START_BD_MASK        0x1
-#define ETH_TX_DATA_3RD_BD_START_BD_SHIFT       8
-#define ETH_TX_DATA_3RD_BD_RESERVED0_MASK       0x7F
-#define ETH_TX_DATA_3RD_BD_RESERVED0_SHIFT      9
+#define ETH_TX_DATA_3RD_BD_TCP_HDR_LEN_DW_MASK  0xF
+#define ETH_TX_DATA_3RD_BD_TCP_HDR_LEN_DW_SHIFT 0
+#define ETH_TX_DATA_3RD_BD_HDR_NBD_MASK         0xF
+#define ETH_TX_DATA_3RD_BD_HDR_NBD_SHIFT        4
+#define ETH_TX_DATA_3RD_BD_START_BD_MASK        0x1
+#define ETH_TX_DATA_3RD_BD_START_BD_SHIFT       8
+#define ETH_TX_DATA_3RD_BD_RESERVED0_MASK       0x7F
+#define ETH_TX_DATA_3RD_BD_RESERVED0_SHIFT      9
         u8 tunn_l4_hdr_start_offset_w;
         u8 tunn_hdr_size_w;
 };
 
 /* The third tx bd of a given packet */
 struct eth_tx_3rd_bd {
-        struct regpair                  addr;
-        __le16                          nbytes;
-        struct eth_tx_data_3rd_bd       data;
+        struct regpair addr;
+        __le16 nbytes;
+        struct eth_tx_data_3rd_bd data;
 };
 
-/* Complementary information for the regular tx bd of a given packet. */
+/* Complementary information for the regular tx bd of a given packet */
 struct eth_tx_data_bd {
-        __le16  reserved0;
-        __le16  bitfields;
-#define ETH_TX_DATA_BD_RESERVED1_MASK  0xFF
-#define ETH_TX_DATA_BD_RESERVED1_SHIFT 0
-#define ETH_TX_DATA_BD_START_BD_MASK   0x1
-#define ETH_TX_DATA_BD_START_BD_SHIFT  8
-#define ETH_TX_DATA_BD_RESERVED2_MASK  0x7F
-#define ETH_TX_DATA_BD_RESERVED2_SHIFT 9
+        __le16 reserved0;
+        __le16 bitfields;
+#define ETH_TX_DATA_BD_RESERVED1_MASK   0xFF
+#define ETH_TX_DATA_BD_RESERVED1_SHIFT  0
+#define ETH_TX_DATA_BD_START_BD_MASK    0x1
+#define ETH_TX_DATA_BD_START_BD_SHIFT   8
+#define ETH_TX_DATA_BD_RESERVED2_MASK   0x7F
+#define ETH_TX_DATA_BD_RESERVED2_SHIFT  9
         __le16 reserved3;
 };
 
 /* The common non-special TX BD ring element */
 struct eth_tx_bd {
-        struct regpair  addr;
-        __le16          nbytes;
-        struct eth_tx_data_bd   data;
+        struct regpair addr;
+        __le16 nbytes;
+        struct eth_tx_data_bd data;
 };
 
 union eth_tx_bd_types {
@@ -434,18 +452,30 @@ struct xstorm_eth_queue_zone {
 /* ETH doorbell data */
 struct eth_db_data {
         u8 params;
-#define ETH_DB_DATA_DEST_MASK         0x3
-#define ETH_DB_DATA_DEST_SHIFT        0
-#define ETH_DB_DATA_AGG_CMD_MASK      0x3
-#define ETH_DB_DATA_AGG_CMD_SHIFT     2
-#define ETH_DB_DATA_BYPASS_EN_MASK    0x1
-#define ETH_DB_DATA_BYPASS_EN_SHIFT   4
-#define ETH_DB_DATA_RESERVED_MASK     0x1
-#define ETH_DB_DATA_RESERVED_SHIFT    5
-#define ETH_DB_DATA_AGG_VAL_SEL_MASK  0x3
-#define ETH_DB_DATA_AGG_VAL_SEL_SHIFT 6
+#define ETH_DB_DATA_DEST_MASK           0x3
+#define ETH_DB_DATA_DEST_SHIFT          0
+#define ETH_DB_DATA_AGG_CMD_MASK        0x3
+#define ETH_DB_DATA_AGG_CMD_SHIFT       2
+#define ETH_DB_DATA_BYPASS_EN_MASK      0x1
+#define ETH_DB_DATA_BYPASS_EN_SHIFT     4
+#define ETH_DB_DATA_RESERVED_MASK       0x1
+#define ETH_DB_DATA_RESERVED_SHIFT      5
+#define ETH_DB_DATA_AGG_VAL_SEL_MASK    0x3
+#define ETH_DB_DATA_AGG_VAL_SEL_SHIFT   6
         u8 agg_flags;
         __le16 bd_prod;
 };
 
+/* RSS hash type */
+enum rss_hash_type {
+        RSS_HASH_TYPE_DEFAULT = 0,
+        RSS_HASH_TYPE_IPV4 = 1,
+        RSS_HASH_TYPE_TCP_IPV4 = 2,
+        RSS_HASH_TYPE_IPV6 = 3,
+        RSS_HASH_TYPE_TCP_IPV6 = 4,
+        RSS_HASH_TYPE_UDP_IPV4 = 5,
+        RSS_HASH_TYPE_UDP_IPV6 = 6,
+        MAX_RSS_HASH_TYPE
+};
+
 #endif /* __ETH_COMMON__ */
diff --git a/include/linux/qed/fcoe_common.h b/include/linux/qed/fcoe_common.h
index 12fc9e788eea..22077c586853 100644
--- a/include/linux/qed/fcoe_common.h
+++ b/include/linux/qed/fcoe_common.h
@@ -8,217 +8,78 @@
 
 #ifndef __FCOE_COMMON__
 #define __FCOE_COMMON__
+
 /*********************/
 /* FCOE FW CONSTANTS */
 /*********************/
 
 #define FC_ABTS_REPLY_MAX_PAYLOAD_LEN   12
 
-struct fcoe_abts_pkt {
-        __le32 abts_rsp_fc_payload_lo;
-        __le16 abts_rsp_rx_id;
-        u8 abts_rsp_rctl;
-        u8 reserved2;
-};
-
-/* FCoE additional WQE (Sq/XferQ) information */
-union fcoe_additional_info_union {
-        __le32 previous_tid;
-        __le32 parent_tid;
-        __le32 burst_length;
-        __le32 seq_rec_updated_offset;
-};
-
-struct fcoe_exp_ro {
-        __le32 data_offset;
-        __le32 reserved;
-};
-
-union fcoe_cleanup_addr_exp_ro_union {
-        struct regpair abts_rsp_fc_payload_hi;
-        struct fcoe_exp_ro exp_ro;
-};
-
-/* FCoE Ramrod Command IDs */
-enum fcoe_completion_status {
-        FCOE_COMPLETION_STATUS_SUCCESS,
-        FCOE_COMPLETION_STATUS_FCOE_VER_ERR,
-        FCOE_COMPLETION_STATUS_SRC_MAC_ADD_ARR_ERR,
-        MAX_FCOE_COMPLETION_STATUS
-};
-
-struct fc_addr_nw {
-        u8 addr_lo;
-        u8 addr_mid;
-        u8 addr_hi;
-};
-
-/* FCoE connection offload */
-struct fcoe_conn_offload_ramrod_data {
-        struct regpair sq_pbl_addr;
-        struct regpair sq_curr_page_addr;
-        struct regpair sq_next_page_addr;
-        struct regpair xferq_pbl_addr;
-        struct regpair xferq_curr_page_addr;
-        struct regpair xferq_next_page_addr;
-        struct regpair respq_pbl_addr;
-        struct regpair respq_curr_page_addr;
-        struct regpair respq_next_page_addr;
-        __le16 dst_mac_addr_lo;
-        __le16 dst_mac_addr_mid;
-        __le16 dst_mac_addr_hi;
-        __le16 src_mac_addr_lo;
-        __le16 src_mac_addr_mid;
-        __le16 src_mac_addr_hi;
-        __le16 tx_max_fc_pay_len;
-        __le16 e_d_tov_timer_val;
-        __le16 rx_max_fc_pay_len;
-        __le16 vlan_tag;
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_VLAN_ID_MASK              0xFFF
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_VLAN_ID_SHIFT             0
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_CFI_MASK                  0x1
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_CFI_SHIFT                 12
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_PRIORITY_MASK             0x7
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_PRIORITY_SHIFT            13
-        __le16 physical_q0;
-        __le16 rec_rr_tov_timer_val;
-        struct fc_addr_nw s_id;
-        u8 max_conc_seqs_c3;
-        struct fc_addr_nw d_id;
-        u8 flags;
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONT_INCR_SEQ_CNT_MASK  0x1
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONT_INCR_SEQ_CNT_SHIFT 0
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONF_REQ_MASK           0x1
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONF_REQ_SHIFT          1
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_REC_VALID_MASK          0x1
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_REC_VALID_SHIFT         2
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_MASK          0x1
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_SHIFT         3
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_MODE_MASK                 0x3
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_MODE_SHIFT                4
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_RESERVED0_MASK            0x3
-#define FCOE_CONN_OFFLOAD_RAMROD_DATA_RESERVED0_SHIFT           6
-        __le16 conn_id;
-        u8 def_q_idx;
-        u8 reserved[5];
-};
-
-/* FCoE terminate connection request */
-struct fcoe_conn_terminate_ramrod_data {
-        struct regpair terminate_params_addr;
-};
-
-struct fcoe_slow_sgl_ctx {
-        struct regpair base_sgl_addr;
-        __le16 curr_sge_off;
-        __le16 remainder_num_sges;
-        __le16 curr_sgl_index;
-        __le16 reserved;
-};
-
-union fcoe_dix_desc_ctx {
-        struct fcoe_slow_sgl_ctx dix_sgl;
-        struct scsi_sge cached_dix_sge;
+/* The fcoe storm task context protection-information of Ystorm */
+struct protection_info_ctx {
+        __le16 flags;
+#define PROTECTION_INFO_CTX_HOST_INTERFACE_MASK         0x3
+#define PROTECTION_INFO_CTX_HOST_INTERFACE_SHIFT        0
+#define PROTECTION_INFO_CTX_DIF_TO_PEER_MASK            0x1
+#define PROTECTION_INFO_CTX_DIF_TO_PEER_SHIFT           2
+#define PROTECTION_INFO_CTX_VALIDATE_DIX_APP_TAG_MASK   0x1
+#define PROTECTION_INFO_CTX_VALIDATE_DIX_APP_TAG_SHIFT  3
+#define PROTECTION_INFO_CTX_INTERVAL_SIZE_LOG_MASK      0xF
+#define PROTECTION_INFO_CTX_INTERVAL_SIZE_LOG_SHIFT     4
+#define PROTECTION_INFO_CTX_VALIDATE_DIX_REF_TAG_MASK   0x1
+#define PROTECTION_INFO_CTX_VALIDATE_DIX_REF_TAG_SHIFT  8
+#define PROTECTION_INFO_CTX_RESERVED0_MASK              0x7F
+#define PROTECTION_INFO_CTX_RESERVED0_SHIFT             9
+        u8 dix_block_size;
+        u8 dst_size;
 };
 
-struct fcoe_fast_sgl_ctx {
-        struct regpair sgl_start_addr;
-        __le32 sgl_byte_offset;
-        __le16 task_reuse_cnt;
-        __le16 init_offset_in_first_sge;
+/* The fcoe storm task context protection-information of Ystorm */
+union protection_info_union_ctx {
+        struct protection_info_ctx info;
+        __le32 value;
 };
 
+/* FCP CMD payload */
 struct fcoe_fcp_cmd_payload {
         __le32 opaque[8];
 };
 
+/* FCP RSP payload */
 struct fcoe_fcp_rsp_payload {
         __le32 opaque[6];
 };
 
-struct fcoe_fcp_xfer_payload {
-        __le32 opaque[3];
-};
-
-/* FCoE firmware function init */
-struct fcoe_init_func_ramrod_data {
-        struct scsi_init_func_params func_params;
-        struct scsi_init_func_queues q_params;
-        __le16 mtu;
-        __le16 sq_num_pages_in_pbl;
-        __le32 reserved;
-};
-
-/* FCoE: Mode of the connection: Target or Initiator or both */
-enum fcoe_mode_type {
-        FCOE_INITIATOR_MODE = 0x0,
-        FCOE_TARGET_MODE = 0x1,
-        FCOE_BOTH_OR_NOT_CHOSEN = 0x3,
-        MAX_FCOE_MODE_TYPE
-};
-
-struct fcoe_rx_stat {
-        struct regpair fcoe_rx_byte_cnt;
-        struct regpair fcoe_rx_data_pkt_cnt;
-        struct regpair fcoe_rx_xfer_pkt_cnt;
-        struct regpair fcoe_rx_other_pkt_cnt;
-        __le32 fcoe_silent_drop_pkt_cmdq_full_cnt;
-        __le32 fcoe_silent_drop_pkt_rq_full_cnt;
-        __le32 fcoe_silent_drop_pkt_crc_error_cnt;
-        __le32 fcoe_silent_drop_pkt_task_invalid_cnt;
-        __le32 fcoe_silent_drop_total_pkt_cnt;
-        __le32 rsrv;
-};
-
-struct fcoe_stat_ramrod_data {
-        struct regpair stat_params_addr;
-};
-
-struct protection_info_ctx {
-        __le16 flags;
-#define PROTECTION_INFO_CTX_HOST_INTERFACE_MASK        0x3
-#define PROTECTION_INFO_CTX_HOST_INTERFACE_SHIFT       0
-#define PROTECTION_INFO_CTX_DIF_TO_PEER_MASK           0x1
-#define PROTECTION_INFO_CTX_DIF_TO_PEER_SHIFT          2
-#define PROTECTION_INFO_CTX_VALIDATE_DIX_APP_TAG_MASK  0x1
-#define PROTECTION_INFO_CTX_VALIDATE_DIX_APP_TAG_SHIFT 3
-#define PROTECTION_INFO_CTX_INTERVAL_SIZE_LOG_MASK     0xF
-#define PROTECTION_INFO_CTX_INTERVAL_SIZE_LOG_SHIFT    4
-#define PROTECTION_INFO_CTX_VALIDATE_DIX_REF_TAG_MASK  0x1
-#define PROTECTION_INFO_CTX_VALIDATE_DIX_REF_TAG_SHIFT 8
-#define PROTECTION_INFO_CTX_RESERVED0_MASK             0x7F
-#define PROTECTION_INFO_CTX_RESERVED0_SHIFT            9
-        u8 dix_block_size;
-        u8 dst_size;
-};
-
-union protection_info_union_ctx {
-        struct protection_info_ctx info;
-        __le32 value;
-};
-
+/* FCP RSP payload */
 struct fcp_rsp_payload_padded {
         struct fcoe_fcp_rsp_payload rsp_payload;
         __le32 reserved[2];
 };
 
+/* FCP RSP payload */
+struct fcoe_fcp_xfer_payload {
+        __le32 opaque[3];
+};
+
+/* FCP RSP payload */
 struct fcp_xfer_payload_padded {
         struct fcoe_fcp_xfer_payload xfer_payload;
         __le32 reserved[5];
 };
 
+/* Task params */
 struct fcoe_tx_data_params {
         __le32 data_offset;
         __le32 offset_in_io;
         u8 flags;
-#define FCOE_TX_DATA_PARAMS_OFFSET_IN_IO_VALID_MASK  0x1
-#define FCOE_TX_DATA_PARAMS_OFFSET_IN_IO_VALID_SHIFT 0
-#define FCOE_TX_DATA_PARAMS_DROP_DATA_MASK           0x1
-#define FCOE_TX_DATA_PARAMS_DROP_DATA_SHIFT          1
-#define FCOE_TX_DATA_PARAMS_AFTER_SEQ_REC_MASK       0x1
-#define FCOE_TX_DATA_PARAMS_AFTER_SEQ_REC_SHIFT      2
-#define FCOE_TX_DATA_PARAMS_RESERVED0_MASK           0x1F
-#define FCOE_TX_DATA_PARAMS_RESERVED0_SHIFT          3
+#define FCOE_TX_DATA_PARAMS_OFFSET_IN_IO_VALID_MASK     0x1
+#define FCOE_TX_DATA_PARAMS_OFFSET_IN_IO_VALID_SHIFT    0
+#define FCOE_TX_DATA_PARAMS_DROP_DATA_MASK              0x1
+#define FCOE_TX_DATA_PARAMS_DROP_DATA_SHIFT             1
+#define FCOE_TX_DATA_PARAMS_AFTER_SEQ_REC_MASK          0x1
+#define FCOE_TX_DATA_PARAMS_AFTER_SEQ_REC_SHIFT         2
+#define FCOE_TX_DATA_PARAMS_RESERVED0_MASK              0x1F
+#define FCOE_TX_DATA_PARAMS_RESERVED0_SHIFT             3
         u8 dif_residual;
         __le16 seq_cnt;
         __le16 single_sge_saved_offset;
@@ -227,6 +88,7 @@ struct fcoe_tx_data_params {
         __le16 reserved3;
 };
 
+/* Middle path parameters: FC header fields provided by the driver */
 struct fcoe_tx_mid_path_params {
         __le32 parameter;
         u8 r_ctl;
@@ -237,11 +99,13 @@ struct fcoe_tx_mid_path_params {
         __le16 ox_id;
 };
 
+/* Task params */
 struct fcoe_tx_params {
         struct fcoe_tx_data_params data;
         struct fcoe_tx_mid_path_params mid_path;
 };
 
+/* Union of FCP CMD payload \ TX params \ ABTS \ Cleanup */
 union fcoe_tx_info_union_ctx {
         struct fcoe_fcp_cmd_payload fcp_cmd_payload;
         struct fcp_rsp_payload_padded fcp_rsp_payload;
@@ -249,13 +113,29 @@ union fcoe_tx_info_union_ctx {
         struct fcoe_tx_params tx_params;
 };
 
+/* Data sgl */
+struct fcoe_slow_sgl_ctx {
+        struct regpair base_sgl_addr;
+        __le16 curr_sge_off;
+        __le16 remainder_num_sges;
+        __le16 curr_sgl_index;
+        __le16 reserved;
+};
+
+/* Union of DIX SGL \ cached DIX sges */
+union fcoe_dix_desc_ctx {
+        struct fcoe_slow_sgl_ctx dix_sgl;
+        struct scsi_sge cached_dix_sge;
+};
+
+/* The fcoe storm task context of Ystorm */
 struct ystorm_fcoe_task_st_ctx {
         u8 task_type;
         u8 sgl_mode;
-#define YSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_MASK  0x1
-#define YSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_SHIFT 0
-#define YSTORM_FCOE_TASK_ST_CTX_RSRV_MASK         0x7F
-#define YSTORM_FCOE_TASK_ST_CTX_RSRV_SHIFT        1
+#define YSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_MASK        0x1
+#define YSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_SHIFT       0
+#define YSTORM_FCOE_TASK_ST_CTX_RSRV_MASK               0x7F
+#define YSTORM_FCOE_TASK_ST_CTX_RSRV_SHIFT              1
         u8 cached_dix_sge;
         u8 expect_first_xfer;
         __le32 num_pbf_zero_write;
@@ -272,49 +152,49 @@ struct ystorm_fcoe_task_st_ctx {
         u8 reserved2[8];
 };
 
-struct ystorm_fcoe_task_ag_ctx {
+struct e4_ystorm_fcoe_task_ag_ctx {
         u8 byte0;
         u8 byte1;
         __le16 word0;
         u8 flags0;
-#define YSTORM_FCOE_TASK_AG_CTX_NIBBLE0_MASK     0xF
-#define YSTORM_FCOE_TASK_AG_CTX_NIBBLE0_SHIFT    0
-#define YSTORM_FCOE_TASK_AG_CTX_BIT0_MASK        0x1
-#define YSTORM_FCOE_TASK_AG_CTX_BIT0_SHIFT       4
-#define YSTORM_FCOE_TASK_AG_CTX_BIT1_MASK        0x1
-#define YSTORM_FCOE_TASK_AG_CTX_BIT1_SHIFT       5
-#define YSTORM_FCOE_TASK_AG_CTX_BIT2_MASK        0x1
-#define YSTORM_FCOE_TASK_AG_CTX_BIT2_SHIFT       6
-#define YSTORM_FCOE_TASK_AG_CTX_BIT3_MASK        0x1
-#define YSTORM_FCOE_TASK_AG_CTX_BIT3_SHIFT       7
+#define E4_YSTORM_FCOE_TASK_AG_CTX_NIBBLE0_MASK         0xF
+#define E4_YSTORM_FCOE_TASK_AG_CTX_NIBBLE0_SHIFT        0
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT0_MASK            0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT0_SHIFT           4
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT1_MASK            0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT1_SHIFT           5
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT2_MASK            0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT2_SHIFT           6
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT3_MASK            0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT3_SHIFT           7
         u8 flags1;
-#define YSTORM_FCOE_TASK_AG_CTX_CF0_MASK         0x3
-#define YSTORM_FCOE_TASK_AG_CTX_CF0_SHIFT        0
-#define YSTORM_FCOE_TASK_AG_CTX_CF1_MASK         0x3
-#define YSTORM_FCOE_TASK_AG_CTX_CF1_SHIFT        2
-#define YSTORM_FCOE_TASK_AG_CTX_CF2SPECIAL_MASK  0x3
-#define YSTORM_FCOE_TASK_AG_CTX_CF2SPECIAL_SHIFT 4
-#define YSTORM_FCOE_TASK_AG_CTX_CF0EN_MASK       0x1
-#define YSTORM_FCOE_TASK_AG_CTX_CF0EN_SHIFT      6
-#define YSTORM_FCOE_TASK_AG_CTX_CF1EN_MASK       0x1
-#define YSTORM_FCOE_TASK_AG_CTX_CF1EN_SHIFT      7
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF0_MASK             0x3
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF0_SHIFT            0
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF1_MASK             0x3
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF1_SHIFT            2
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF2SPECIAL_MASK      0x3
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF2SPECIAL_SHIFT     4
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF0EN_MASK           0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF0EN_SHIFT          6
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF1EN_MASK           0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_CF1EN_SHIFT          7
         u8 flags2;
-#define YSTORM_FCOE_TASK_AG_CTX_BIT4_MASK        0x1
-#define YSTORM_FCOE_TASK_AG_CTX_BIT4_SHIFT       0
-#define YSTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK     0x1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT    1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK     0x1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT    2
-#define YSTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK     0x1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT    3
-#define YSTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK     0x1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT    4
-#define YSTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK     0x1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT    5
-#define YSTORM_FCOE_TASK_AG_CTX_RULE5EN_MASK     0x1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE5EN_SHIFT    6
-#define YSTORM_FCOE_TASK_AG_CTX_RULE6EN_MASK     0x1
-#define YSTORM_FCOE_TASK_AG_CTX_RULE6EN_SHIFT    7
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT4_MASK            0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_BIT4_SHIFT           0
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK         0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT        1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK         0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT        2
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK         0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT        3
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK         0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT        4
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK         0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT        5
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE5EN_MASK         0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE5EN_SHIFT        6
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE6EN_MASK         0x1
+#define E4_YSTORM_FCOE_TASK_AG_CTX_RULE6EN_SHIFT        7
         u8 byte2;
         __le32 reg0;
         u8 byte3;
@@ -328,73 +208,73 @@ struct ystorm_fcoe_task_ag_ctx {
         __le32 reg2;
 };
 
-struct tstorm_fcoe_task_ag_ctx {
+struct e4_tstorm_fcoe_task_ag_ctx {
         u8 reserved;
         u8 byte1;
         __le16 icid;
         u8 flags0;
-#define TSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_MASK     0xF
-#define TSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_SHIFT    0
-#define TSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_MASK        0x1
-#define TSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_SHIFT       4
-#define TSTORM_FCOE_TASK_AG_CTX_BIT1_MASK                0x1
-#define TSTORM_FCOE_TASK_AG_CTX_BIT1_SHIFT               5
-#define TSTORM_FCOE_TASK_AG_CTX_WAIT_ABTS_RSP_F_MASK     0x1
-#define TSTORM_FCOE_TASK_AG_CTX_WAIT_ABTS_RSP_F_SHIFT    6
-#define TSTORM_FCOE_TASK_AG_CTX_VALID_MASK               0x1
-#define TSTORM_FCOE_TASK_AG_CTX_VALID_SHIFT              7
+#define E4_TSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_MASK         0xF
+#define E4_TSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_SHIFT        0
+#define E4_TSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_MASK            0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_SHIFT           4
+#define E4_TSTORM_FCOE_TASK_AG_CTX_BIT1_MASK                    0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_BIT1_SHIFT                   5
+#define E4_TSTORM_FCOE_TASK_AG_CTX_WAIT_ABTS_RSP_F_MASK         0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_WAIT_ABTS_RSP_F_SHIFT        6
+#define E4_TSTORM_FCOE_TASK_AG_CTX_VALID_MASK                   0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_VALID_SHIFT                  7
         u8 flags1;
-#define TSTORM_FCOE_TASK_AG_CTX_FALSE_RR_TOV_MASK        0x1
-#define TSTORM_FCOE_TASK_AG_CTX_FALSE_RR_TOV_SHIFT       0
-#define TSTORM_FCOE_TASK_AG_CTX_BIT5_MASK                0x1
-#define TSTORM_FCOE_TASK_AG_CTX_BIT5_SHIFT               1
-#define TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_MASK       0x3
-#define TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_SHIFT      2
-#define TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_MASK           0x3
-#define TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_SHIFT          4
-#define TSTORM_FCOE_TASK_AG_CTX_CF2_MASK                 0x3
-#define TSTORM_FCOE_TASK_AG_CTX_CF2_SHIFT                6
+#define E4_TSTORM_FCOE_TASK_AG_CTX_FALSE_RR_TOV_MASK    0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_FALSE_RR_TOV_SHIFT   0
+#define E4_TSTORM_FCOE_TASK_AG_CTX_BIT5_MASK            0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_BIT5_SHIFT           1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_MASK   0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_SHIFT  2
+#define E4_TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_MASK       0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_SHIFT      4
+#define E4_TSTORM_FCOE_TASK_AG_CTX_CF2_MASK             0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_CF2_SHIFT            6
         u8 flags2;
-#define TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_MASK      0x3
-#define TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_SHIFT     0
-#define TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_MASK       0x3
-#define TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_SHIFT      2
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_MASK         0x3
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_SHIFT        4
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_MASK     0x3
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_SHIFT    6
+#define E4_TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_MASK          0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_SHIFT         0
+#define E4_TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_MASK           0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_SHIFT          2
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_MASK             0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_SHIFT            4
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_MASK         0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_SHIFT        6
         u8 flags3;
-#define TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_MASK       0x3
-#define TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_SHIFT      0
-#define TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_EN_MASK    0x1
-#define TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_EN_SHIFT   2
-#define TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_EN_MASK        0x1
-#define TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_EN_SHIFT       3
-#define TSTORM_FCOE_TASK_AG_CTX_CF2EN_MASK               0x1
-#define TSTORM_FCOE_TASK_AG_CTX_CF2EN_SHIFT              4
-#define TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_EN_MASK   0x1
-#define TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_EN_SHIFT  5
-#define TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_MASK    0x1
-#define TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_SHIFT   6
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_EN_MASK      0x1
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_EN_SHIFT     7
+#define E4_TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_MASK           0x3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_SHIFT          0
+#define E4_TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_EN_MASK        0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_REC_RR_TOV_CF_EN_SHIFT       2
+#define E4_TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_EN_MASK            0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_ED_TOV_CF_EN_SHIFT           3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_CF2EN_MASK                   0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_CF2EN_SHIFT                  4
+#define E4_TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_EN_MASK       0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_TIMER_STOP_ALL_EN_SHIFT      5
+#define E4_TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_MASK        0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_SHIFT       6
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_EN_MASK          0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_INIT_CF_EN_SHIFT         7
         u8 flags4;
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_EN_MASK  0x1
-#define TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_EN_SHIFT 0
-#define TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_EN_MASK    0x1
-#define TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_EN_SHIFT   1
-#define TSTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK             0x1
-#define TSTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT            2
-#define TSTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK             0x1
-#define TSTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT            3
-#define TSTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK             0x1
-#define TSTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT            4
-#define TSTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK             0x1
-#define TSTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT            5
-#define TSTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK             0x1
-#define TSTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT            6
-#define TSTORM_FCOE_TASK_AG_CTX_RULE5EN_MASK             0x1
-#define TSTORM_FCOE_TASK_AG_CTX_RULE5EN_SHIFT            7
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_EN_MASK      0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_SEQ_RECOVERY_CF_EN_SHIFT     0
+#define E4_TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_EN_MASK        0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_UNSOL_COMP_CF_EN_SHIFT       1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK                 0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT                2
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK                 0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT                3
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK                 0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT                4
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK                 0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT                5
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK                 0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT                6
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE5EN_MASK                 0x1
+#define E4_TSTORM_FCOE_TASK_AG_CTX_RULE5EN_SHIFT                7
         u8 cleanup_state;
         __le16 last_sent_tid;
         __le32 rec_rr_tov_exp_timeout;
@@ -407,25 +287,46 @@ struct tstorm_fcoe_task_ag_ctx {
         __le32 data_offset_next;
 };
 
+/* Cached data sges */
+struct fcoe_exp_ro {
+        __le32 data_offset;
+        __le32 reserved;
+};
+
+/* Union of Cleanup address \ expected relative offsets */
+union fcoe_cleanup_addr_exp_ro_union {
+        struct regpair abts_rsp_fc_payload_hi;
+        struct fcoe_exp_ro exp_ro;
+};
+
+/* Fields coppied from ABTSrsp pckt */
+struct fcoe_abts_pkt {
+        __le32 abts_rsp_fc_payload_lo;
+        __le16 abts_rsp_rx_id;
+        u8 abts_rsp_rctl;
+        u8 reserved2;
+};
+
+/* FW read- write (modifyable) part The fcoe task storm context of Tstorm */
 struct fcoe_tstorm_fcoe_task_st_ctx_read_write {
         union fcoe_cleanup_addr_exp_ro_union cleanup_addr_exp_ro_union;
         __le16 flags;
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RX_SGL_MODE_MASK       0x1
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RX_SGL_MODE_SHIFT      0
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_EXP_FIRST_FRAME_MASK   0x1
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_EXP_FIRST_FRAME_SHIFT  1
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_ACTIVE_MASK        0x1
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_ACTIVE_SHIFT       2
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_TIMEOUT_MASK       0x1
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_TIMEOUT_SHIFT      3
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SINGLE_PKT_IN_EX_MASK  0x1
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SINGLE_PKT_IN_EX_SHIFT 4
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_OOO_RX_SEQ_STAT_MASK   0x1
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_OOO_RX_SEQ_STAT_SHIFT  5
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_CQ_ADD_ADV_MASK        0x3
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_CQ_ADD_ADV_SHIFT       6
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RSRV1_MASK             0xFF
-#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RSRV1_SHIFT            8
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RX_SGL_MODE_MASK        0x1
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RX_SGL_MODE_SHIFT       0
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_EXP_FIRST_FRAME_MASK    0x1
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_EXP_FIRST_FRAME_SHIFT   1
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_ACTIVE_MASK         0x1
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_ACTIVE_SHIFT        2
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_TIMEOUT_MASK        0x1
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SEQ_TIMEOUT_SHIFT       3
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SINGLE_PKT_IN_EX_MASK   0x1
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_SINGLE_PKT_IN_EX_SHIFT  4
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_OOO_RX_SEQ_STAT_MASK    0x1
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_OOO_RX_SEQ_STAT_SHIFT   5
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_CQ_ADD_ADV_MASK         0x3
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_CQ_ADD_ADV_SHIFT        6
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RSRV1_MASK              0xFF
+#define FCOE_TSTORM_FCOE_TASK_ST_CTX_READ_WRITE_RSRV1_SHIFT             8
         __le16 seq_cnt;
         u8 seq_id;
         u8 ooo_rx_seq_id;
@@ -436,6 +337,7 @@ struct fcoe_tstorm_fcoe_task_st_ctx_read_write {
         __le16 reserved1;
 };
 
+/* FW read only part The fcoe task storm context of Tstorm */
 struct fcoe_tstorm_fcoe_task_st_ctx_read_only {
         u8 task_type;
         u8 dev_type;
@@ -446,54 +348,55 @@ struct fcoe_tstorm_fcoe_task_st_ctx_read_only {
         __le32 rsrv;
 };
 
+/** The fcoe task storm context of Tstorm */
 struct tstorm_fcoe_task_st_ctx {
         struct fcoe_tstorm_fcoe_task_st_ctx_read_write read_write;
         struct fcoe_tstorm_fcoe_task_st_ctx_read_only read_only;
 };
 
-struct mstorm_fcoe_task_ag_ctx {
+struct e4_mstorm_fcoe_task_ag_ctx {
         u8 byte0;
         u8 byte1;
         __le16 icid;
         u8 flags0;
-#define MSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_MASK    0xF
-#define MSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_SHIFT   0
-#define MSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_MASK       0x1
-#define MSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_SHIFT      4
-#define MSTORM_FCOE_TASK_AG_CTX_CQE_PLACED_MASK         0x1
-#define MSTORM_FCOE_TASK_AG_CTX_CQE_PLACED_SHIFT        5
-#define MSTORM_FCOE_TASK_AG_CTX_BIT2_MASK               0x1
-#define MSTORM_FCOE_TASK_AG_CTX_BIT2_SHIFT              6
-#define MSTORM_FCOE_TASK_AG_CTX_BIT3_MASK               0x1
-#define MSTORM_FCOE_TASK_AG_CTX_BIT3_SHIFT              7
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_MASK         0xF
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_SHIFT        0
+#define E4_MSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_MASK            0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_SHIFT           4
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CQE_PLACED_MASK              0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CQE_PLACED_SHIFT             5
+#define E4_MSTORM_FCOE_TASK_AG_CTX_BIT2_MASK                    0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_BIT2_SHIFT                   6
+#define E4_MSTORM_FCOE_TASK_AG_CTX_BIT3_MASK                    0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_BIT3_SHIFT                   7
         u8 flags1;
-#define MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_MASK      0x3
-#define MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_SHIFT     0
-#define MSTORM_FCOE_TASK_AG_CTX_CF1_MASK                0x3
-#define MSTORM_FCOE_TASK_AG_CTX_CF1_SHIFT               2
-#define MSTORM_FCOE_TASK_AG_CTX_CF2_MASK                0x3
-#define MSTORM_FCOE_TASK_AG_CTX_CF2_SHIFT               4
-#define MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_MASK   0x1
-#define MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_SHIFT  6
-#define MSTORM_FCOE_TASK_AG_CTX_CF1EN_MASK              0x1
-#define MSTORM_FCOE_TASK_AG_CTX_CF1EN_SHIFT             7
+#define E4_MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_MASK           0x3
+#define E4_MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_SHIFT          0
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF1_MASK                     0x3
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF1_SHIFT                    2
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF2_MASK                     0x3
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF2_SHIFT                    4
+#define E4_MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_MASK        0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_EX_CLEANUP_CF_EN_SHIFT       6
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF1EN_MASK                   0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF1EN_SHIFT                  7
         u8 flags2;
-#define MSTORM_FCOE_TASK_AG_CTX_CF2EN_MASK              0x1
-#define MSTORM_FCOE_TASK_AG_CTX_CF2EN_SHIFT             0
-#define MSTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK            0x1
-#define MSTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT           1
-#define MSTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK            0x1
-#define MSTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT           2
-#define MSTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK            0x1
-#define MSTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT           3
-#define MSTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK            0x1
-#define MSTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT           4
-#define MSTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK            0x1
-#define MSTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT           5
-#define MSTORM_FCOE_TASK_AG_CTX_XFER_PLACEMENT_EN_MASK  0x1
-#define MSTORM_FCOE_TASK_AG_CTX_XFER_PLACEMENT_EN_SHIFT 6
-#define MSTORM_FCOE_TASK_AG_CTX_RULE6EN_MASK            0x1
-#define MSTORM_FCOE_TASK_AG_CTX_RULE6EN_SHIFT           7
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF2EN_MASK                   0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_CF2EN_SHIFT                  0
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK                 0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT                1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK                 0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT                2
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK                 0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT                3
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK                 0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT                4
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK                 0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT                5
+#define E4_MSTORM_FCOE_TASK_AG_CTX_XFER_PLACEMENT_EN_MASK       0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_XFER_PLACEMENT_EN_SHIFT      6
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE6EN_MASK                 0x1
+#define E4_MSTORM_FCOE_TASK_AG_CTX_RULE6EN_SHIFT                7
         u8 cleanup_state;
         __le32 received_bytes;
         u8 byte3;
@@ -507,6 +410,7 @@ struct mstorm_fcoe_task_ag_ctx {
         __le32 reg2;
 };
 
+/* The fcoe task storm context of Mstorm */
 struct mstorm_fcoe_task_st_ctx {
         struct regpair rsp_buf_addr;
         __le32 rsrv[2];
@@ -515,79 +419,79 @@ struct mstorm_fcoe_task_st_ctx {
         __le32 data_buffer_offset;
         __le16 parent_id;
         __le16 flags;
-#define MSTORM_FCOE_TASK_ST_CTX_INTERVAL_SIZE_LOG_MASK     0xF
-#define MSTORM_FCOE_TASK_ST_CTX_INTERVAL_SIZE_LOG_SHIFT    0
-#define MSTORM_FCOE_TASK_ST_CTX_HOST_INTERFACE_MASK        0x3
-#define MSTORM_FCOE_TASK_ST_CTX_HOST_INTERFACE_SHIFT       4
-#define MSTORM_FCOE_TASK_ST_CTX_DIF_TO_PEER_MASK           0x1
-#define MSTORM_FCOE_TASK_ST_CTX_DIF_TO_PEER_SHIFT          6
-#define MSTORM_FCOE_TASK_ST_CTX_MP_INCLUDE_FC_HEADER_MASK  0x1
-#define MSTORM_FCOE_TASK_ST_CTX_MP_INCLUDE_FC_HEADER_SHIFT 7
-#define MSTORM_FCOE_TASK_ST_CTX_DIX_BLOCK_SIZE_MASK        0x3
-#define MSTORM_FCOE_TASK_ST_CTX_DIX_BLOCK_SIZE_SHIFT       8
-#define MSTORM_FCOE_TASK_ST_CTX_VALIDATE_DIX_REF_TAG_MASK  0x1
-#define MSTORM_FCOE_TASK_ST_CTX_VALIDATE_DIX_REF_TAG_SHIFT 10
-#define MSTORM_FCOE_TASK_ST_CTX_DIX_CACHED_SGE_FLG_MASK    0x1
-#define MSTORM_FCOE_TASK_ST_CTX_DIX_CACHED_SGE_FLG_SHIFT   11
-#define MSTORM_FCOE_TASK_ST_CTX_DIF_SUPPORTED_MASK         0x1
-#define MSTORM_FCOE_TASK_ST_CTX_DIF_SUPPORTED_SHIFT        12
-#define MSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_MASK           0x1
-#define MSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_SHIFT          13
-#define MSTORM_FCOE_TASK_ST_CTX_RESERVED_MASK              0x3
-#define MSTORM_FCOE_TASK_ST_CTX_RESERVED_SHIFT             14
+#define MSTORM_FCOE_TASK_ST_CTX_INTERVAL_SIZE_LOG_MASK          0xF
+#define MSTORM_FCOE_TASK_ST_CTX_INTERVAL_SIZE_LOG_SHIFT         0
+#define MSTORM_FCOE_TASK_ST_CTX_HOST_INTERFACE_MASK             0x3
+#define MSTORM_FCOE_TASK_ST_CTX_HOST_INTERFACE_SHIFT            4
+#define MSTORM_FCOE_TASK_ST_CTX_DIF_TO_PEER_MASK                0x1
+#define MSTORM_FCOE_TASK_ST_CTX_DIF_TO_PEER_SHIFT               6
+#define MSTORM_FCOE_TASK_ST_CTX_MP_INCLUDE_FC_HEADER_MASK       0x1
+#define MSTORM_FCOE_TASK_ST_CTX_MP_INCLUDE_FC_HEADER_SHIFT      7
+#define MSTORM_FCOE_TASK_ST_CTX_DIX_BLOCK_SIZE_MASK             0x3
+#define MSTORM_FCOE_TASK_ST_CTX_DIX_BLOCK_SIZE_SHIFT            8
+#define MSTORM_FCOE_TASK_ST_CTX_VALIDATE_DIX_REF_TAG_MASK       0x1
+#define MSTORM_FCOE_TASK_ST_CTX_VALIDATE_DIX_REF_TAG_SHIFT      10
+#define MSTORM_FCOE_TASK_ST_CTX_DIX_CACHED_SGE_FLG_MASK         0x1
+#define MSTORM_FCOE_TASK_ST_CTX_DIX_CACHED_SGE_FLG_SHIFT        11
+#define MSTORM_FCOE_TASK_ST_CTX_DIF_SUPPORTED_MASK              0x1
+#define MSTORM_FCOE_TASK_ST_CTX_DIF_SUPPORTED_SHIFT             12
+#define MSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_MASK                0x1
+#define MSTORM_FCOE_TASK_ST_CTX_TX_SGL_MODE_SHIFT               13
+#define MSTORM_FCOE_TASK_ST_CTX_RESERVED_MASK                   0x3
+#define MSTORM_FCOE_TASK_ST_CTX_RESERVED_SHIFT                  14
         struct scsi_cached_sges data_desc;
 };
 
-struct ustorm_fcoe_task_ag_ctx {
+struct e4_ustorm_fcoe_task_ag_ctx {
         u8 reserved;
         u8 byte1;
         __le16 icid;
         u8 flags0;
-#define USTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_MASK  0xF
-#define USTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_SHIFT 0
-#define USTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_MASK     0x1
-#define USTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_SHIFT    4
-#define USTORM_FCOE_TASK_AG_CTX_BIT1_MASK             0x1
-#define USTORM_FCOE_TASK_AG_CTX_BIT1_SHIFT            5
-#define USTORM_FCOE_TASK_AG_CTX_CF0_MASK              0x3
-#define USTORM_FCOE_TASK_AG_CTX_CF0_SHIFT             6
+#define E4_USTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_MASK         0xF
+#define E4_USTORM_FCOE_TASK_AG_CTX_CONNECTION_TYPE_SHIFT        0
+#define E4_USTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_MASK            0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_EXIST_IN_QM0_SHIFT           4
+#define E4_USTORM_FCOE_TASK_AG_CTX_BIT1_MASK                    0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_BIT1_SHIFT                   5
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF0_MASK                     0x3
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF0_SHIFT                    6
         u8 flags1;
-#define USTORM_FCOE_TASK_AG_CTX_CF1_MASK              0x3
-#define USTORM_FCOE_TASK_AG_CTX_CF1_SHIFT             0
-#define USTORM_FCOE_TASK_AG_CTX_CF2_MASK              0x3
-#define USTORM_FCOE_TASK_AG_CTX_CF2_SHIFT             2
-#define USTORM_FCOE_TASK_AG_CTX_CF3_MASK              0x3
-#define USTORM_FCOE_TASK_AG_CTX_CF3_SHIFT             4
-#define USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_MASK     0x3
-#define USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_SHIFT    6
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF1_MASK             0x3
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF1_SHIFT            0
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF2_MASK             0x3
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF2_SHIFT            2
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF3_MASK             0x3
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF3_SHIFT            4
+#define E4_USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_MASK    0x3
+#define E4_USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_SHIFT   6
         u8 flags2;
-#define USTORM_FCOE_TASK_AG_CTX_CF0EN_MASK            0x1
-#define USTORM_FCOE_TASK_AG_CTX_CF0EN_SHIFT           0
-#define USTORM_FCOE_TASK_AG_CTX_CF1EN_MASK            0x1
-#define USTORM_FCOE_TASK_AG_CTX_CF1EN_SHIFT           1
-#define USTORM_FCOE_TASK_AG_CTX_CF2EN_MASK            0x1
-#define USTORM_FCOE_TASK_AG_CTX_CF2EN_SHIFT           2
-#define USTORM_FCOE_TASK_AG_CTX_CF3EN_MASK            0x1
-#define USTORM_FCOE_TASK_AG_CTX_CF3EN_SHIFT           3
-#define USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_EN_MASK  0x1
-#define USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_EN_SHIFT 4
-#define USTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK          0x1
-#define USTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT         5
-#define USTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK          0x1
-#define USTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT         6
-#define USTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK          0x1
-#define USTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT         7
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF0EN_MASK                   0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF0EN_SHIFT                  0
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF1EN_MASK                   0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF1EN_SHIFT                  1
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF2EN_MASK                   0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF2EN_SHIFT                  2
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF3EN_MASK                   0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_CF3EN_SHIFT                  3
+#define E4_USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_EN_MASK         0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_CF_EN_SHIFT        4
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE0EN_MASK                 0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE0EN_SHIFT                5
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE1EN_MASK                 0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE1EN_SHIFT                6
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE2EN_MASK                 0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE2EN_SHIFT                7
         u8 flags3;
-#define USTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK          0x1
-#define USTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT         0
-#define USTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK          0x1
-#define USTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT         1
-#define USTORM_FCOE_TASK_AG_CTX_RULE5EN_MASK          0x1
-#define USTORM_FCOE_TASK_AG_CTX_RULE5EN_SHIFT         2
-#define USTORM_FCOE_TASK_AG_CTX_RULE6EN_MASK          0x1
-#define USTORM_FCOE_TASK_AG_CTX_RULE6EN_SHIFT         3
-#define USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_TYPE_MASK   0xF
-#define USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_TYPE_SHIFT  4
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE3EN_MASK         0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE3EN_SHIFT        0
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE4EN_MASK         0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE4EN_SHIFT        1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE5EN_MASK         0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE5EN_SHIFT        2
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE6EN_MASK         0x1
+#define E4_USTORM_FCOE_TASK_AG_CTX_RULE6EN_SHIFT        3
+#define E4_USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_TYPE_MASK  0xF
+#define E4_USTORM_FCOE_TASK_AG_CTX_DIF_ERROR_TYPE_SHIFT 4
         __le32 dif_err_intervals;
         __le32 dif_error_1st_interval;
         __le32 global_cq_num;
@@ -596,21 +500,189 @@ struct ustorm_fcoe_task_ag_ctx {
         __le32 reg5;
 };
 
-struct fcoe_task_context {
+/* FCoE task context */
+struct e4_fcoe_task_context {
         struct ystorm_fcoe_task_st_ctx ystorm_st_context;
         struct regpair ystorm_st_padding[2];
         struct tdif_task_context tdif_context;
-        struct ystorm_fcoe_task_ag_ctx ystorm_ag_context;
-        struct tstorm_fcoe_task_ag_ctx tstorm_ag_context;
+        struct e4_ystorm_fcoe_task_ag_ctx ystorm_ag_context;
+        struct e4_tstorm_fcoe_task_ag_ctx tstorm_ag_context;
         struct timers_context timer_context;
         struct tstorm_fcoe_task_st_ctx tstorm_st_context;
         struct regpair tstorm_st_padding[2];
-        struct mstorm_fcoe_task_ag_ctx mstorm_ag_context;
+        struct e4_mstorm_fcoe_task_ag_ctx mstorm_ag_context;
         struct mstorm_fcoe_task_st_ctx mstorm_st_context;
-        struct ustorm_fcoe_task_ag_ctx ustorm_ag_context;
+        struct e4_ustorm_fcoe_task_ag_ctx ustorm_ag_context;
         struct rdif_task_context rdif_context;
 };
 
+/* FCoE additional WQE (Sq/XferQ) information */
+union fcoe_additional_info_union {
+        __le32 previous_tid;
+        __le32 parent_tid;
+        __le32 burst_length;
+        __le32 seq_rec_updated_offset;
+};
+
+/* FCoE Ramrod Command IDs */
+enum fcoe_completion_status {
+        FCOE_COMPLETION_STATUS_SUCCESS,
+        FCOE_COMPLETION_STATUS_FCOE_VER_ERR,
+        FCOE_COMPLETION_STATUS_SRC_MAC_ADD_ARR_ERR,
+        MAX_FCOE_COMPLETION_STATUS
+};
+
+/* FC address (SID/DID) network presentation */
+struct fc_addr_nw {
+        u8 addr_lo;
+        u8 addr_mid;
+        u8 addr_hi;
+};
+
+/* FCoE connection offload */
+struct fcoe_conn_offload_ramrod_data {
+        struct regpair sq_pbl_addr;
+        struct regpair sq_curr_page_addr;
+        struct regpair sq_next_page_addr;
+        struct regpair xferq_pbl_addr;
+        struct regpair xferq_curr_page_addr;
+        struct regpair xferq_next_page_addr;
+        struct regpair respq_pbl_addr;
+        struct regpair respq_curr_page_addr;
+        struct regpair respq_next_page_addr;
+        __le16 dst_mac_addr_lo;
+        __le16 dst_mac_addr_mid;
+        __le16 dst_mac_addr_hi;
+        __le16 src_mac_addr_lo;
+        __le16 src_mac_addr_mid;
+        __le16 src_mac_addr_hi;
+        __le16 tx_max_fc_pay_len;
+        __le16 e_d_tov_timer_val;
+        __le16 rx_max_fc_pay_len;
+        __le16 vlan_tag;
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_VLAN_ID_MASK      0xFFF
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_VLAN_ID_SHIFT     0
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_CFI_MASK          0x1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_CFI_SHIFT         12
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_PRIORITY_MASK     0x7
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_PRIORITY_SHIFT    13
+        __le16 physical_q0;
+        __le16 rec_rr_tov_timer_val;
+        struct fc_addr_nw s_id;
+        u8 max_conc_seqs_c3;
+        struct fc_addr_nw d_id;
+        u8 flags;
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONT_INCR_SEQ_CNT_MASK  0x1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONT_INCR_SEQ_CNT_SHIFT 0
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONF_REQ_MASK           0x1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONF_REQ_SHIFT          1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_REC_VALID_MASK          0x1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_REC_VALID_SHIFT         2
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_MASK          0x1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_SHIFT         3
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_SINGLE_VLAN_MASK        0x1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_B_SINGLE_VLAN_SHIFT       4
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_MODE_MASK                 0x3
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_MODE_SHIFT                5
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_RESERVED0_MASK            0x1
+#define FCOE_CONN_OFFLOAD_RAMROD_DATA_RESERVED0_SHIFT           7
+        __le16 conn_id;
+        u8 def_q_idx;
+        u8 reserved[5];
+};
+
+/* FCoE terminate connection request */
+struct fcoe_conn_terminate_ramrod_data {
+        struct regpair terminate_params_addr;
+};
+
+/* FCoE device type */
+enum fcoe_device_type {
+        FCOE_TASK_DEV_TYPE_DISK,
+        FCOE_TASK_DEV_TYPE_TAPE,
+        MAX_FCOE_DEVICE_TYPE
+};
+
+/* Data sgl */
+struct fcoe_fast_sgl_ctx {
+        struct regpair sgl_start_addr;
+        __le32 sgl_byte_offset;
+        __le16 task_reuse_cnt;
+        __le16 init_offset_in_first_sge;
+};
+
+/* FCoE firmware function init */
+struct fcoe_init_func_ramrod_data {
+        struct scsi_init_func_params func_params;
+        struct scsi_init_func_queues q_params;
+        __le16 mtu;
+        __le16 sq_num_pages_in_pbl;
+        __le32 reserved[3];
+};
+
+/* FCoE: Mode of the connection: Target or Initiator or both */
+enum fcoe_mode_type {
+        FCOE_INITIATOR_MODE = 0x0,
+        FCOE_TARGET_MODE = 0x1,
+        FCOE_BOTH_OR_NOT_CHOSEN = 0x3,
+        MAX_FCOE_MODE_TYPE
+};
+
+/* Per PF FCoE receive path statistics - tStorm RAM structure */
+struct fcoe_rx_stat {
+        struct regpair fcoe_rx_byte_cnt;
+        struct regpair fcoe_rx_data_pkt_cnt;
+        struct regpair fcoe_rx_xfer_pkt_cnt;
+        struct regpair fcoe_rx_other_pkt_cnt;
+        __le32 fcoe_silent_drop_pkt_cmdq_full_cnt;
+        __le32 fcoe_silent_drop_pkt_rq_full_cnt;
+        __le32 fcoe_silent_drop_pkt_crc_error_cnt;
+        __le32 fcoe_silent_drop_pkt_task_invalid_cnt;
+        __le32 fcoe_silent_drop_total_pkt_cnt;
+        __le32 rsrv;
+};
+
+/* FCoE SQE request type */
+enum fcoe_sqe_request_type {
+        SEND_FCOE_CMD,
+        SEND_FCOE_MIDPATH,
+        SEND_FCOE_ABTS_REQUEST,
+        FCOE_EXCHANGE_CLEANUP,
+        FCOE_SEQUENCE_RECOVERY,
+        SEND_FCOE_XFER_RDY,
+        SEND_FCOE_RSP,
+        SEND_FCOE_RSP_WITH_SENSE_DATA,
+        SEND_FCOE_TARGET_DATA,
+        SEND_FCOE_INITIATOR_DATA,
+        SEND_FCOE_XFER_CONTINUATION_RDY,
+        SEND_FCOE_TARGET_ABTS_RSP,
+        MAX_FCOE_SQE_REQUEST_TYPE
+};
+
+/* FCoe statistics request */
+struct fcoe_stat_ramrod_data {
+        struct regpair stat_params_addr;
+};
+
+/* FCoE task type */
+enum fcoe_task_type {
+        FCOE_TASK_TYPE_WRITE_INITIATOR,
+        FCOE_TASK_TYPE_READ_INITIATOR,
+        FCOE_TASK_TYPE_MIDPATH,
+        FCOE_TASK_TYPE_UNSOLICITED,
+        FCOE_TASK_TYPE_ABTS,
+        FCOE_TASK_TYPE_EXCHANGE_CLEANUP,
+        FCOE_TASK_TYPE_SEQUENCE_CLEANUP,
+        FCOE_TASK_TYPE_WRITE_TARGET,
+        FCOE_TASK_TYPE_READ_TARGET,
+        FCOE_TASK_TYPE_RSP,
+        FCOE_TASK_TYPE_RSP_SENSE_DATA,
+        FCOE_TASK_TYPE_ABTS_TARGET,
+        FCOE_TASK_TYPE_ENUM_SIZE,
+        MAX_FCOE_TASK_TYPE
+};
+
+/* Per PF FCoE transmit path statistics - pStorm RAM structure */
 struct fcoe_tx_stat {
         struct regpair fcoe_tx_byte_cnt;
         struct regpair fcoe_tx_data_pkt_cnt;
@@ -618,51 +690,55 @@ struct fcoe_tx_stat {
         struct regpair fcoe_tx_other_pkt_cnt;
 };
 
+/* FCoE SQ/XferQ element */
 struct fcoe_wqe {
         __le16 task_id;
         __le16 flags;
-#define FCOE_WQE_REQ_TYPE_MASK       0xF
-#define FCOE_WQE_REQ_TYPE_SHIFT      0
-#define FCOE_WQE_SGL_MODE_MASK       0x1
-#define FCOE_WQE_SGL_MODE_SHIFT      4
-#define FCOE_WQE_CONTINUATION_MASK   0x1
-#define FCOE_WQE_CONTINUATION_SHIFT  5
-#define FCOE_WQE_SEND_AUTO_RSP_MASK  0x1
-#define FCOE_WQE_SEND_AUTO_RSP_SHIFT 6
-#define FCOE_WQE_RESERVED_MASK       0x1
-#define FCOE_WQE_RESERVED_SHIFT      7
-#define FCOE_WQE_NUM_SGES_MASK       0xF
-#define FCOE_WQE_NUM_SGES_SHIFT      8
-#define FCOE_WQE_RESERVED1_MASK      0xF
-#define FCOE_WQE_RESERVED1_SHIFT     12
+#define FCOE_WQE_REQ_TYPE_MASK          0xF
+#define FCOE_WQE_REQ_TYPE_SHIFT         0
+#define FCOE_WQE_SGL_MODE_MASK          0x1
+#define FCOE_WQE_SGL_MODE_SHIFT         4
+#define FCOE_WQE_CONTINUATION_MASK      0x1
+#define FCOE_WQE_CONTINUATION_SHIFT     5
+#define FCOE_WQE_SEND_AUTO_RSP_MASK     0x1
+#define FCOE_WQE_SEND_AUTO_RSP_SHIFT    6
+#define FCOE_WQE_RESERVED_MASK          0x1
+#define FCOE_WQE_RESERVED_SHIFT         7
+#define FCOE_WQE_NUM_SGES_MASK          0xF
+#define FCOE_WQE_NUM_SGES_SHIFT         8
+#define FCOE_WQE_RESERVED1_MASK         0xF
+#define FCOE_WQE_RESERVED1_SHIFT        12
         union fcoe_additional_info_union additional_info_union;
 };
 
+/* FCoE XFRQ element */
 struct xfrqe_prot_flags {
         u8 flags;
-#define XFRQE_PROT_FLAGS_PROT_INTERVAL_SIZE_LOG_MASK  0xF
-#define XFRQE_PROT_FLAGS_PROT_INTERVAL_SIZE_LOG_SHIFT 0
-#define XFRQE_PROT_FLAGS_DIF_TO_PEER_MASK             0x1
-#define XFRQE_PROT_FLAGS_DIF_TO_PEER_SHIFT            4
-#define XFRQE_PROT_FLAGS_HOST_INTERFACE_MASK          0x3
-#define XFRQE_PROT_FLAGS_HOST_INTERFACE_SHIFT         5
-#define XFRQE_PROT_FLAGS_RESERVED_MASK                0x1
-#define XFRQE_PROT_FLAGS_RESERVED_SHIFT               7
+#define XFRQE_PROT_FLAGS_PROT_INTERVAL_SIZE_LOG_MASK    0xF
+#define XFRQE_PROT_FLAGS_PROT_INTERVAL_SIZE_LOG_SHIFT   0
+#define XFRQE_PROT_FLAGS_DIF_TO_PEER_MASK               0x1
+#define XFRQE_PROT_FLAGS_DIF_TO_PEER_SHIFT              4
+#define XFRQE_PROT_FLAGS_HOST_INTERFACE_MASK            0x3
+#define XFRQE_PROT_FLAGS_HOST_INTERFACE_SHIFT           5
+#define XFRQE_PROT_FLAGS_RESERVED_MASK                  0x1
+#define XFRQE_PROT_FLAGS_RESERVED_SHIFT                 7
 };
 
+/* FCoE doorbell data */
 struct fcoe_db_data {
         u8 params;
-#define FCOE_DB_DATA_DEST_MASK         0x3
-#define FCOE_DB_DATA_DEST_SHIFT        0
-#define FCOE_DB_DATA_AGG_CMD_MASK      0x3
-#define FCOE_DB_DATA_AGG_CMD_SHIFT     2
-#define FCOE_DB_DATA_BYPASS_EN_MASK    0x1
-#define FCOE_DB_DATA_BYPASS_EN_SHIFT   4
-#define FCOE_DB_DATA_RESERVED_MASK     0x1
-#define FCOE_DB_DATA_RESERVED_SHIFT    5
-#define FCOE_DB_DATA_AGG_VAL_SEL_MASK  0x3
-#define FCOE_DB_DATA_AGG_VAL_SEL_SHIFT 6
+#define FCOE_DB_DATA_DEST_MASK          0x3
+#define FCOE_DB_DATA_DEST_SHIFT         0
+#define FCOE_DB_DATA_AGG_CMD_MASK       0x3
+#define FCOE_DB_DATA_AGG_CMD_SHIFT      2
+#define FCOE_DB_DATA_BYPASS_EN_MASK     0x1
+#define FCOE_DB_DATA_BYPASS_EN_SHIFT    4
+#define FCOE_DB_DATA_RESERVED_MASK      0x1
+#define FCOE_DB_DATA_RESERVED_SHIFT     5
+#define FCOE_DB_DATA_AGG_VAL_SEL_MASK   0x3
+#define FCOE_DB_DATA_AGG_VAL_SEL_SHIFT  6
         u8 agg_flags;
         __le16 sq_prod;
 };
+
 #endif /* __FCOE_COMMON__ */
diff --git a/include/linux/qed/iscsi_common.h b/include/linux/qed/iscsi_common.h
index 85e086cba639..4cc9b37b8d95 100644
--- a/include/linux/qed/iscsi_common.h
+++ b/include/linux/qed/iscsi_common.h
@@ -32,47 +32,48 @@
 
 #ifndef __ISCSI_COMMON__
 #define __ISCSI_COMMON__
+
 /**********************/
 /* ISCSI FW CONSTANTS */
 /**********************/
 
 /* iSCSI HSI constants */
-#define ISCSI_DEFAULT_MTU       (1500)
+#define ISCSI_DEFAULT_MTU       (1500)
 
 /* KWQ (kernel work queue) layer codes */
-#define ISCSI_SLOW_PATH_LAYER_CODE   (6)
+#define ISCSI_SLOW_PATH_LAYER_CODE      (6)
 
 /* iSCSI parameter defaults */
-#define ISCSI_DEFAULT_HEADER_DIGEST         (0)
-#define ISCSI_DEFAULT_DATA_DIGEST           (0)
-#define ISCSI_DEFAULT_INITIAL_R2T           (1)
-#define ISCSI_DEFAULT_IMMEDIATE_DATA        (1)
-#define ISCSI_DEFAULT_MAX_PDU_LENGTH        (0x2000)
-#define ISCSI_DEFAULT_FIRST_BURST_LENGTH    (0x10000)
-#define ISCSI_DEFAULT_MAX_BURST_LENGTH      (0x40000)
-#define ISCSI_DEFAULT_MAX_OUTSTANDING_R2T   (1)
+#define ISCSI_DEFAULT_HEADER_DIGEST             (0)
+#define ISCSI_DEFAULT_DATA_DIGEST               (0)
+#define ISCSI_DEFAULT_INITIAL_R2T               (1)
+#define ISCSI_DEFAULT_IMMEDIATE_DATA            (1)
+#define ISCSI_DEFAULT_MAX_PDU_LENGTH            (0x2000)
+#define ISCSI_DEFAULT_FIRST_BURST_LENGTH        (0x10000)
+#define ISCSI_DEFAULT_MAX_BURST_LENGTH          (0x40000)
+#define ISCSI_DEFAULT_MAX_OUTSTANDING_R2T       (1)
 
 /* iSCSI parameter limits */
-#define ISCSI_MIN_VAL_MAX_PDU_LENGTH        (0x200)
-#define ISCSI_MAX_VAL_MAX_PDU_LENGTH        (0xffffff)
-#define ISCSI_MIN_VAL_BURST_LENGTH          (0x200)
-#define ISCSI_MAX_VAL_BURST_LENGTH          (0xffffff)
-#define ISCSI_MIN_VAL_MAX_OUTSTANDING_R2T   (1)
-#define ISCSI_MAX_VAL_MAX_OUTSTANDING_R2T   (0xff)
+#define ISCSI_MIN_VAL_MAX_PDU_LENGTH            (0x200)
+#define ISCSI_MAX_VAL_MAX_PDU_LENGTH            (0xffffff)
+#define ISCSI_MIN_VAL_BURST_LENGTH              (0x200)
+#define ISCSI_MAX_VAL_BURST_LENGTH              (0xffffff)
+#define ISCSI_MIN_VAL_MAX_OUTSTANDING_R2T       (1)
+#define ISCSI_MAX_VAL_MAX_OUTSTANDING_R2T       (0xff)
 
-#define ISCSI_AHS_CNTL_SIZE 4
+#define ISCSI_AHS_CNTL_SIZE     4
 
-#define ISCSI_WQE_NUM_SGES_SLOWIO           (0xf)
+#define ISCSI_WQE_NUM_SGES_SLOWIO       (0xf)
 
 /* iSCSI reserved params */
 #define ISCSI_ITT_ALL_ONES      (0xffffffff)
 #define ISCSI_TTT_ALL_ONES      (0xffffffff)
 
-#define ISCSI_OPTION_1_OFF_CHIP_TCP 1
-#define ISCSI_OPTION_2_ON_CHIP_TCP 2
+#define ISCSI_OPTION_1_OFF_CHIP_TCP     1
+#define ISCSI_OPTION_2_ON_CHIP_TCP      2
 
-#define ISCSI_INITIATOR_MODE 0
-#define ISCSI_TARGET_MODE 1
+#define ISCSI_INITIATOR_MODE    0
+#define ISCSI_TARGET_MODE       1
 
 /* iSCSI request op codes */
 #define ISCSI_OPCODE_NOP_OUT            (0)
@@ -84,41 +85,48 @@
 #define ISCSI_OPCODE_LOGOUT_REQUEST     (6)
 
 /* iSCSI response/messages op codes */
-#define ISCSI_OPCODE_NOP_IN             (0x20)
-#define ISCSI_OPCODE_SCSI_RESPONSE      (0x21)
-#define ISCSI_OPCODE_TMF_RESPONSE       (0x22)
-#define ISCSI_OPCODE_LOGIN_RESPONSE     (0x23)
-#define ISCSI_OPCODE_TEXT_RESPONSE      (0x24)
-#define ISCSI_OPCODE_DATA_IN            (0x25)
-#define ISCSI_OPCODE_LOGOUT_RESPONSE    (0x26)
-#define ISCSI_OPCODE_R2T                (0x31)
-#define ISCSI_OPCODE_ASYNC_MSG          (0x32)
-#define ISCSI_OPCODE_REJECT             (0x3f)
+#define ISCSI_OPCODE_NOP_IN             (0x20)
+#define ISCSI_OPCODE_SCSI_RESPONSE      (0x21)
+#define ISCSI_OPCODE_TMF_RESPONSE       (0x22)
+#define ISCSI_OPCODE_LOGIN_RESPONSE     (0x23)
+#define ISCSI_OPCODE_TEXT_RESPONSE      (0x24)
+#define ISCSI_OPCODE_DATA_IN            (0x25)
+#define ISCSI_OPCODE_LOGOUT_RESPONSE    (0x26)
+#define ISCSI_OPCODE_R2T                (0x31)
+#define ISCSI_OPCODE_ASYNC_MSG          (0x32)
+#define ISCSI_OPCODE_REJECT             (0x3f)
 
 /* iSCSI stages */
-#define ISCSI_STAGE_SECURITY_NEGOTIATION            (0)
-#define ISCSI_STAGE_LOGIN_OPERATIONAL_NEGOTIATION   (1)
-#define ISCSI_STAGE_FULL_FEATURE_PHASE              (3)
+#define ISCSI_STAGE_SECURITY_NEGOTIATION                (0)
+#define ISCSI_STAGE_LOGIN_OPERATIONAL_NEGOTIATION       (1)
+#define ISCSI_STAGE_FULL_FEATURE_PHASE                  (3)
 
 /* iSCSI CQE errors */
-#define CQE_ERROR_BITMAP_DATA_DIGEST          (0x08)
-#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN  (0x10)
-#define CQE_ERROR_BITMAP_DATA_TRUNCATED       (0x20)
+#define CQE_ERROR_BITMAP_DATA_DIGEST            (0x08)
+#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN    (0x10)
+#define CQE_ERROR_BITMAP_DATA_TRUNCATED         (0x20)
+
+/* Union of data bd_opaque/ tq_tid */
+union bd_opaque_tq_union {
+        __le16 bd_opaque;
+        __le16 tq_tid;
+};
 
+/* ISCSI SGL entry */
 struct cqe_error_bitmap {
         u8 cqe_error_status_bits;
-#define CQE_ERROR_BITMAP_DIF_ERR_BITS_MASK         0x7
-#define CQE_ERROR_BITMAP_DIF_ERR_BITS_SHIFT        0
-#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_MASK      0x1
-#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_SHIFT     3
-#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_MASK  0x1
-#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_SHIFT 4
-#define CQE_ERROR_BITMAP_DATA_TRUNCATED_ERR_MASK   0x1
-#define CQE_ERROR_BITMAP_DATA_TRUNCATED_ERR_SHIFT  5
-#define CQE_ERROR_BITMAP_UNDER_RUN_ERR_MASK        0x1
-#define CQE_ERROR_BITMAP_UNDER_RUN_ERR_SHIFT       6
-#define CQE_ERROR_BITMAP_RESERVED2_MASK            0x1
-#define CQE_ERROR_BITMAP_RESERVED2_SHIFT           7
+#define CQE_ERROR_BITMAP_DIF_ERR_BITS_MASK              0x7
+#define CQE_ERROR_BITMAP_DIF_ERR_BITS_SHIFT             0
+#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_MASK           0x1
+#define CQE_ERROR_BITMAP_DATA_DIGEST_ERR_SHIFT          3
+#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_MASK       0x1
+#define CQE_ERROR_BITMAP_RCV_ON_INVALID_CONN_SHIFT      4
+#define CQE_ERROR_BITMAP_DATA_TRUNCATED_ERR_MASK        0x1
+#define CQE_ERROR_BITMAP_DATA_TRUNCATED_ERR_SHIFT       5
+#define CQE_ERROR_BITMAP_UNDER_RUN_ERR_MASK             0x1
+#define CQE_ERROR_BITMAP_UNDER_RUN_ERR_SHIFT            6
+#define CQE_ERROR_BITMAP_RESERVED2_MASK                 0x1
+#define CQE_ERROR_BITMAP_RESERVED2_SHIFT                7
 };
 
 union cqe_error_status {
@@ -126,86 +134,133 @@ union cqe_error_status {
         struct cqe_error_bitmap error_bits;
 };
 
+/* iSCSI Login Response PDU header */
 struct data_hdr {
         __le32 data[12];
 };
 
-struct iscsi_async_msg_hdr {
-        __le16 reserved0;
-        u8 flags_attr;
-#define ISCSI_ASYNC_MSG_HDR_RSRV_MASK           0x7F
-#define ISCSI_ASYNC_MSG_HDR_RSRV_SHIFT          0
-#define ISCSI_ASYNC_MSG_HDR_CONST1_MASK         0x1
-#define ISCSI_ASYNC_MSG_HDR_CONST1_SHIFT        7
-        u8 opcode;
-        __le32 hdr_second_dword;
-#define ISCSI_ASYNC_MSG_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_ASYNC_MSG_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_ASYNC_MSG_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_ASYNC_MSG_HDR_TOTAL_AHS_LEN_SHIFT 24
-        struct regpair lun;
-        __le32 all_ones;
-        __le32 reserved1;
-        __le32 stat_sn;
-        __le32 exp_cmd_sn;
-        __le32 max_cmd_sn;
-        __le16 param1_rsrv;
-        u8 async_vcode;
-        u8 async_event;
-        __le16 param3_rsrv;
-        __le16 param2_rsrv;
-        __le32 reserved7;
+struct lun_mapper_addr_reserved {
+        struct regpair lun_mapper_addr;
+        u8 reserved0[8];
+};
+
+/* rdif conetxt for dif on immediate */
+struct dif_on_immediate_params {
+        __le32 initial_ref_tag;
+        __le16 application_tag;
+        __le16 application_tag_mask;
+        __le16 flags1;
+#define DIF_ON_IMMEDIATE_PARAMS_VALIDATE_GUARD_MASK             0x1
+#define DIF_ON_IMMEDIATE_PARAMS_VALIDATE_GUARD_SHIFT            0
+#define DIF_ON_IMMEDIATE_PARAMS_VALIDATE_APP_TAG_MASK           0x1
+#define DIF_ON_IMMEDIATE_PARAMS_VALIDATE_APP_TAG_SHIFT          1
+#define DIF_ON_IMMEDIATE_PARAMS_VALIDATE_REF_TAG_MASK           0x1
+#define DIF_ON_IMMEDIATE_PARAMS_VALIDATE_REF_TAG_SHIFT          2
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_GUARD_MASK              0x1
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_GUARD_SHIFT             3
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_APP_TAG_MASK            0x1
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_APP_TAG_SHIFT           4
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_REF_TAG_MASK            0x1
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_REF_TAG_SHIFT           5
+#define DIF_ON_IMMEDIATE_PARAMS_INTERVAL_SIZE_MASK              0x1
+#define DIF_ON_IMMEDIATE_PARAMS_INTERVAL_SIZE_SHIFT             6
+#define DIF_ON_IMMEDIATE_PARAMS_NETWORK_INTERFACE_MASK          0x1
+#define DIF_ON_IMMEDIATE_PARAMS_NETWORK_INTERFACE_SHIFT         7
+#define DIF_ON_IMMEDIATE_PARAMS_HOST_INTERFACE_MASK             0x3
+#define DIF_ON_IMMEDIATE_PARAMS_HOST_INTERFACE_SHIFT            8
+#define DIF_ON_IMMEDIATE_PARAMS_REF_TAG_MASK_MASK               0xF
+#define DIF_ON_IMMEDIATE_PARAMS_REF_TAG_MASK_SHIFT              10
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_APP_TAG_WITH_MASK_MASK  0x1
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_APP_TAG_WITH_MASK_SHIFT 14
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_REF_TAG_WITH_MASK_MASK  0x1
+#define DIF_ON_IMMEDIATE_PARAMS_FORWARD_REF_TAG_WITH_MASK_SHIFT 15
+        u8 flags0;
+#define DIF_ON_IMMEDIATE_PARAMS_RESERVED_MASK                   0x1
+#define DIF_ON_IMMEDIATE_PARAMS_RESERVED_SHIFT                  0
+#define DIF_ON_IMMEDIATE_PARAMS_IGNORE_APP_TAG_MASK             0x1
+#define DIF_ON_IMMEDIATE_PARAMS_IGNORE_APP_TAG_SHIFT            1
+#define DIF_ON_IMMEDIATE_PARAMS_INITIAL_REF_TAG_IS_VALID_MASK   0x1
+#define DIF_ON_IMMEDIATE_PARAMS_INITIAL_REF_TAG_IS_VALID_SHIFT  2
+#define DIF_ON_IMMEDIATE_PARAMS_HOST_GUARD_TYPE_MASK            0x1
+#define DIF_ON_IMMEDIATE_PARAMS_HOST_GUARD_TYPE_SHIFT           3
+#define DIF_ON_IMMEDIATE_PARAMS_PROTECTION_TYPE_MASK            0x3
+#define DIF_ON_IMMEDIATE_PARAMS_PROTECTION_TYPE_SHIFT           4
+#define DIF_ON_IMMEDIATE_PARAMS_CRC_SEED_MASK                   0x1
+#define DIF_ON_IMMEDIATE_PARAMS_CRC_SEED_SHIFT                  6
+#define DIF_ON_IMMEDIATE_PARAMS_KEEP_REF_TAG_CONST_MASK         0x1
+#define DIF_ON_IMMEDIATE_PARAMS_KEEP_REF_TAG_CONST_SHIFT        7
+        u8 reserved_zero[5];
+};
+
+/* iSCSI dif on immediate mode attributes union */
+union dif_configuration_params {
+        struct lun_mapper_addr_reserved lun_mapper_address;
+        struct dif_on_immediate_params def_dif_conf;
+};
+
+/* Union of data/r2t sequence number */
+union iscsi_seq_num {
+        __le16 data_sn;
+        __le16 r2t_sn;
 };
 
-struct iscsi_cmd_hdr {
-        __le16 reserved1;
-        u8 flags_attr;
-#define ISCSI_CMD_HDR_ATTR_MASK         0x7
-#define ISCSI_CMD_HDR_ATTR_SHIFT        0
-#define ISCSI_CMD_HDR_RSRV_MASK         0x3
-#define ISCSI_CMD_HDR_RSRV_SHIFT        3
-#define ISCSI_CMD_HDR_WRITE_MASK        0x1
-#define ISCSI_CMD_HDR_WRITE_SHIFT       5
-#define ISCSI_CMD_HDR_READ_MASK         0x1
-#define ISCSI_CMD_HDR_READ_SHIFT        6
-#define ISCSI_CMD_HDR_FINAL_MASK        0x1
-#define ISCSI_CMD_HDR_FINAL_SHIFT       7
-        u8 hdr_first_byte;
-#define ISCSI_CMD_HDR_OPCODE_MASK       0x3F
-#define ISCSI_CMD_HDR_OPCODE_SHIFT      0
-#define ISCSI_CMD_HDR_IMM_MASK          0x1
-#define ISCSI_CMD_HDR_IMM_SHIFT         6
-#define ISCSI_CMD_HDR_RSRV1_MASK        0x1
-#define ISCSI_CMD_HDR_RSRV1_SHIFT       7
-        __le32 hdr_second_dword;
-#define ISCSI_CMD_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_CMD_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_CMD_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_CMD_HDR_TOTAL_AHS_LEN_SHIFT 24
-        struct regpair lun;
-        __le32 itt;
-        __le32 expected_transfer_length;
-        __le32 cmd_sn;
-        __le32 exp_stat_sn;
-        __le32 cdb[4];
+/* iSCSI DIF flags */
+struct iscsi_dif_flags {
+        u8 flags;
+#define ISCSI_DIF_FLAGS_PROT_INTERVAL_SIZE_LOG_MASK     0xF
+#define ISCSI_DIF_FLAGS_PROT_INTERVAL_SIZE_LOG_SHIFT    0
+#define ISCSI_DIF_FLAGS_DIF_TO_PEER_MASK                0x1
+#define ISCSI_DIF_FLAGS_DIF_TO_PEER_SHIFT               4
+#define ISCSI_DIF_FLAGS_HOST_INTERFACE_MASK             0x7
+#define ISCSI_DIF_FLAGS_HOST_INTERFACE_SHIFT            5
 };
 
+/* The iscsi storm task context of Ystorm */
+struct ystorm_iscsi_task_state {
+        struct scsi_cached_sges data_desc;
+        struct scsi_sgl_params sgl_params;
+        __le32 exp_r2t_sn;
+        __le32 buffer_offset;
+        union iscsi_seq_num seq_num;
+        struct iscsi_dif_flags dif_flags;
+        u8 flags;
+#define YSTORM_ISCSI_TASK_STATE_LOCAL_COMP_MASK         0x1
+#define YSTORM_ISCSI_TASK_STATE_LOCAL_COMP_SHIFT        0
+#define YSTORM_ISCSI_TASK_STATE_SLOW_IO_MASK            0x1
+#define YSTORM_ISCSI_TASK_STATE_SLOW_IO_SHIFT           1
+#define YSTORM_ISCSI_TASK_STATE_SET_DIF_OFFSET_MASK     0x1
+#define YSTORM_ISCSI_TASK_STATE_SET_DIF_OFFSET_SHIFT    2
+#define YSTORM_ISCSI_TASK_STATE_RESERVED0_MASK          0x1F
+#define YSTORM_ISCSI_TASK_STATE_RESERVED0_SHIFT         3
+};
+
+/* The iscsi storm task context of Ystorm */
+struct ystorm_iscsi_task_rxmit_opt {
+        __le32 fast_rxmit_sge_offset;
+        __le32 scan_start_buffer_offset;
+        __le32 fast_rxmit_buffer_offset;
+        u8 scan_start_sgl_index;
+        u8 fast_rxmit_sgl_index;
+        __le16 reserved;
+};
+
+/* iSCSI Common PDU header */
 struct iscsi_common_hdr {
         u8 hdr_status;
         u8 hdr_response;
         u8 hdr_flags;
         u8 hdr_first_byte;
-#define ISCSI_COMMON_HDR_OPCODE_MASK         0x3F
-#define ISCSI_COMMON_HDR_OPCODE_SHIFT        0
-#define ISCSI_COMMON_HDR_IMM_MASK            0x1
-#define ISCSI_COMMON_HDR_IMM_SHIFT           6
-#define ISCSI_COMMON_HDR_RSRV_MASK           0x1
-#define ISCSI_COMMON_HDR_RSRV_SHIFT          7
+#define ISCSI_COMMON_HDR_OPCODE_MASK            0x3F
+#define ISCSI_COMMON_HDR_OPCODE_SHIFT           0
+#define ISCSI_COMMON_HDR_IMM_MASK               0x1
+#define ISCSI_COMMON_HDR_IMM_SHIFT              6
+#define ISCSI_COMMON_HDR_RSRV_MASK              0x1
+#define ISCSI_COMMON_HDR_RSRV_SHIFT             7
         __le32 hdr_second_dword;
-#define ISCSI_COMMON_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_COMMON_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_COMMON_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_COMMON_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_COMMON_HDR_DATA_SEG_LEN_MASK      0xFFFFFF
+#define ISCSI_COMMON_HDR_DATA_SEG_LEN_SHIFT     0
+#define ISCSI_COMMON_HDR_TOTAL_AHS_LEN_MASK     0xFF
+#define ISCSI_COMMON_HDR_TOTAL_AHS_LEN_SHIFT    24
         struct regpair lun_reserved;
         __le32 itt;
         __le32 ttt;
@@ -215,86 +270,60 @@ struct iscsi_common_hdr {
         __le32 data[3];
 };
 
-struct iscsi_conn_offload_params {
-        struct regpair sq_pbl_addr;
-        struct regpair r2tq_pbl_addr;
-        struct regpair xhq_pbl_addr;
-        struct regpair uhq_pbl_addr;
-        __le32 initial_ack;
-        __le16 physical_q0;
-        __le16 physical_q1;
-        u8 flags;
-#define ISCSI_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_MASK  0x1
-#define ISCSI_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_SHIFT 0
-#define ISCSI_CONN_OFFLOAD_PARAMS_TARGET_MODE_MASK     0x1
-#define ISCSI_CONN_OFFLOAD_PARAMS_TARGET_MODE_SHIFT    1
-#define ISCSI_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_MASK  0x1
-#define ISCSI_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_SHIFT 2
-#define ISCSI_CONN_OFFLOAD_PARAMS_RESERVED1_MASK        0x1F
-#define ISCSI_CONN_OFFLOAD_PARAMS_RESERVED1_SHIFT       3
-        u8 pbl_page_size_log;
-        u8 pbe_page_size_log;
-        u8 default_cq;
-        __le32 stat_sn;
-};
-
-struct iscsi_slow_path_hdr {
-        u8 op_code;
-        u8 flags;
-#define ISCSI_SLOW_PATH_HDR_RESERVED0_MASK   0xF
-#define ISCSI_SLOW_PATH_HDR_RESERVED0_SHIFT  0
-#define ISCSI_SLOW_PATH_HDR_LAYER_CODE_MASK  0x7
-#define ISCSI_SLOW_PATH_HDR_LAYER_CODE_SHIFT 4
-#define ISCSI_SLOW_PATH_HDR_RESERVED1_MASK   0x1
-#define ISCSI_SLOW_PATH_HDR_RESERVED1_SHIFT  7
-};
-
-struct iscsi_conn_update_ramrod_params {
-        struct iscsi_slow_path_hdr hdr;
-        __le16 conn_id;
-        __le32 fw_cid;
-        u8 flags;
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN_MASK           0x1
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN_SHIFT          0
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DD_EN_MASK           0x1
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DD_EN_SHIFT          1
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_INITIAL_R2T_MASK     0x1
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_INITIAL_R2T_SHIFT    2
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_IMMEDIATE_DATA_MASK  0x1
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_IMMEDIATE_DATA_SHIFT 3
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_BLOCK_SIZE_MASK  0x1
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_BLOCK_SIZE_SHIFT 4
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_ON_HOST_EN_MASK  0x1
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_ON_HOST_EN_SHIFT 5
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_RESERVED1_MASK       0x3
-#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_RESERVED1_SHIFT      6
-        u8 reserved0[3];
-        __le32 max_seq_size;
-        __le32 max_send_pdu_length;
-        __le32 max_recv_pdu_length;
-        __le32 first_seq_length;
+/* iSCSI Command PDU header */
+struct iscsi_cmd_hdr {
+        __le16 reserved1;
+        u8 flags_attr;
+#define ISCSI_CMD_HDR_ATTR_MASK                 0x7
+#define ISCSI_CMD_HDR_ATTR_SHIFT                0
+#define ISCSI_CMD_HDR_RSRV_MASK                 0x3
+#define ISCSI_CMD_HDR_RSRV_SHIFT                3
+#define ISCSI_CMD_HDR_WRITE_MASK                0x1
+#define ISCSI_CMD_HDR_WRITE_SHIFT               5
+#define ISCSI_CMD_HDR_READ_MASK                 0x1
+#define ISCSI_CMD_HDR_READ_SHIFT                6
+#define ISCSI_CMD_HDR_FINAL_MASK                0x1
+#define ISCSI_CMD_HDR_FINAL_SHIFT               7
+        u8 hdr_first_byte;
+#define ISCSI_CMD_HDR_OPCODE_MASK               0x3F
+#define ISCSI_CMD_HDR_OPCODE_SHIFT              0
+#define ISCSI_CMD_HDR_IMM_MASK                  0x1
+#define ISCSI_CMD_HDR_IMM_SHIFT                 6
+#define ISCSI_CMD_HDR_RSRV1_MASK                0x1
+#define ISCSI_CMD_HDR_RSRV1_SHIFT               7
+        __le32 hdr_second_dword;
+#define ISCSI_CMD_HDR_DATA_SEG_LEN_MASK         0xFFFFFF
+#define ISCSI_CMD_HDR_DATA_SEG_LEN_SHIFT        0
+#define ISCSI_CMD_HDR_TOTAL_AHS_LEN_MASK        0xFF
+#define ISCSI_CMD_HDR_TOTAL_AHS_LEN_SHIFT       24
+        struct regpair lun;
+        __le32 itt;
+        __le32 expected_transfer_length;
+        __le32 cmd_sn;
         __le32 exp_stat_sn;
+        __le32 cdb[4];
 };
 
+/* iSCSI Command PDU header with Extended CDB (Initiator Mode) */
 struct iscsi_ext_cdb_cmd_hdr {
         __le16 reserved1;
         u8 flags_attr;
-#define ISCSI_EXT_CDB_CMD_HDR_ATTR_MASK          0x7
-#define ISCSI_EXT_CDB_CMD_HDR_ATTR_SHIFT         0
-#define ISCSI_EXT_CDB_CMD_HDR_RSRV_MASK          0x3
-#define ISCSI_EXT_CDB_CMD_HDR_RSRV_SHIFT         3
-#define ISCSI_EXT_CDB_CMD_HDR_WRITE_MASK         0x1
-#define ISCSI_EXT_CDB_CMD_HDR_WRITE_SHIFT        5
-#define ISCSI_EXT_CDB_CMD_HDR_READ_MASK          0x1
-#define ISCSI_EXT_CDB_CMD_HDR_READ_SHIFT         6
-#define ISCSI_EXT_CDB_CMD_HDR_FINAL_MASK         0x1
-#define ISCSI_EXT_CDB_CMD_HDR_FINAL_SHIFT        7
+#define ISCSI_EXT_CDB_CMD_HDR_ATTR_MASK         0x7
+#define ISCSI_EXT_CDB_CMD_HDR_ATTR_SHIFT        0
+#define ISCSI_EXT_CDB_CMD_HDR_RSRV_MASK         0x3
+#define ISCSI_EXT_CDB_CMD_HDR_RSRV_SHIFT        3
+#define ISCSI_EXT_CDB_CMD_HDR_WRITE_MASK        0x1
+#define ISCSI_EXT_CDB_CMD_HDR_WRITE_SHIFT       5
+#define ISCSI_EXT_CDB_CMD_HDR_READ_MASK         0x1
+#define ISCSI_EXT_CDB_CMD_HDR_READ_SHIFT        6
+#define ISCSI_EXT_CDB_CMD_HDR_FINAL_MASK        0x1
+#define ISCSI_EXT_CDB_CMD_HDR_FINAL_SHIFT       7
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_EXT_CDB_CMD_HDR_DATA_SEG_LEN_MASK  0xFFFFFF
-#define ISCSI_EXT_CDB_CMD_HDR_DATA_SEG_LEN_SHIFT 0
-#define ISCSI_EXT_CDB_CMD_HDR_CDB_SIZE_MASK      0xFF
-#define ISCSI_EXT_CDB_CMD_HDR_CDB_SIZE_SHIFT     24
+#define ISCSI_EXT_CDB_CMD_HDR_DATA_SEG_LEN_MASK         0xFFFFFF
+#define ISCSI_EXT_CDB_CMD_HDR_DATA_SEG_LEN_SHIFT        0
+#define ISCSI_EXT_CDB_CMD_HDR_CDB_SIZE_MASK             0xFF
+#define ISCSI_EXT_CDB_CMD_HDR_CDB_SIZE_SHIFT            24
         struct regpair lun;
         __le32 itt;
         __le32 expected_transfer_length;
@@ -303,26 +332,27 @@ struct iscsi_ext_cdb_cmd_hdr {
         struct scsi_sge cdb_sge;
 };
 
+/* iSCSI login request PDU header */
 struct iscsi_login_req_hdr {
         u8 version_min;
         u8 version_max;
         u8 flags_attr;
-#define ISCSI_LOGIN_REQ_HDR_NSG_MASK            0x3
-#define ISCSI_LOGIN_REQ_HDR_NSG_SHIFT           0
-#define ISCSI_LOGIN_REQ_HDR_CSG_MASK            0x3
-#define ISCSI_LOGIN_REQ_HDR_CSG_SHIFT           2
-#define ISCSI_LOGIN_REQ_HDR_RSRV_MASK           0x3
-#define ISCSI_LOGIN_REQ_HDR_RSRV_SHIFT          4
-#define ISCSI_LOGIN_REQ_HDR_C_MASK              0x1
-#define ISCSI_LOGIN_REQ_HDR_C_SHIFT             6
-#define ISCSI_LOGIN_REQ_HDR_T_MASK              0x1
-#define ISCSI_LOGIN_REQ_HDR_T_SHIFT             7
+#define ISCSI_LOGIN_REQ_HDR_NSG_MASK    0x3
+#define ISCSI_LOGIN_REQ_HDR_NSG_SHIFT   0
+#define ISCSI_LOGIN_REQ_HDR_CSG_MASK    0x3
+#define ISCSI_LOGIN_REQ_HDR_CSG_SHIFT   2
+#define ISCSI_LOGIN_REQ_HDR_RSRV_MASK   0x3
+#define ISCSI_LOGIN_REQ_HDR_RSRV_SHIFT  4
+#define ISCSI_LOGIN_REQ_HDR_C_MASK      0x1
+#define ISCSI_LOGIN_REQ_HDR_C_SHIFT     6
+#define ISCSI_LOGIN_REQ_HDR_T_MASK      0x1
+#define ISCSI_LOGIN_REQ_HDR_T_SHIFT     7
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_LOGIN_REQ_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_LOGIN_REQ_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_LOGIN_REQ_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_LOGIN_REQ_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_LOGIN_REQ_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
+#define ISCSI_LOGIN_REQ_HDR_DATA_SEG_LEN_SHIFT  0
+#define ISCSI_LOGIN_REQ_HDR_TOTAL_AHS_LEN_MASK  0xFF
+#define ISCSI_LOGIN_REQ_HDR_TOTAL_AHS_LEN_SHIFT 24
         __le32 isid_tabc;
         __le16 tsih;
         __le16 isid_d;
@@ -334,6 +364,7 @@ struct iscsi_login_req_hdr {
         __le32 reserved2[4];
 };
 
+/* iSCSI logout request PDU header */
 struct iscsi_logout_req_hdr {
         __le16 reserved0;
         u8 reason_code;
@@ -348,13 +379,14 @@ struct iscsi_logout_req_hdr {
         __le32 reserved4[4];
 };
 
+/* iSCSI Data-out PDU header */
 struct iscsi_data_out_hdr {
         __le16 reserved1;
         u8 flags_attr;
-#define ISCSI_DATA_OUT_HDR_RSRV_MASK   0x7F
-#define ISCSI_DATA_OUT_HDR_RSRV_SHIFT  0
-#define ISCSI_DATA_OUT_HDR_FINAL_MASK  0x1
-#define ISCSI_DATA_OUT_HDR_FINAL_SHIFT 7
+#define ISCSI_DATA_OUT_HDR_RSRV_MASK    0x7F
+#define ISCSI_DATA_OUT_HDR_RSRV_SHIFT   0
+#define ISCSI_DATA_OUT_HDR_FINAL_MASK   0x1
+#define ISCSI_DATA_OUT_HDR_FINAL_SHIFT  7
         u8 opcode;
         __le32 reserved2;
         struct regpair lun;
@@ -368,22 +400,23 @@ struct iscsi_data_out_hdr {
         __le32 reserved5;
 };
 
+/* iSCSI Data-in PDU header */
 struct iscsi_data_in_hdr {
         u8 status_rsvd;
         u8 reserved1;
         u8 flags;
-#define ISCSI_DATA_IN_HDR_STATUS_MASK     0x1
-#define ISCSI_DATA_IN_HDR_STATUS_SHIFT    0
-#define ISCSI_DATA_IN_HDR_UNDERFLOW_MASK  0x1
-#define ISCSI_DATA_IN_HDR_UNDERFLOW_SHIFT 1
-#define ISCSI_DATA_IN_HDR_OVERFLOW_MASK   0x1
-#define ISCSI_DATA_IN_HDR_OVERFLOW_SHIFT  2
-#define ISCSI_DATA_IN_HDR_RSRV_MASK       0x7
-#define ISCSI_DATA_IN_HDR_RSRV_SHIFT      3
-#define ISCSI_DATA_IN_HDR_ACK_MASK        0x1
-#define ISCSI_DATA_IN_HDR_ACK_SHIFT       6
-#define ISCSI_DATA_IN_HDR_FINAL_MASK      0x1
-#define ISCSI_DATA_IN_HDR_FINAL_SHIFT     7
+#define ISCSI_DATA_IN_HDR_STATUS_MASK           0x1
+#define ISCSI_DATA_IN_HDR_STATUS_SHIFT          0
+#define ISCSI_DATA_IN_HDR_UNDERFLOW_MASK        0x1
+#define ISCSI_DATA_IN_HDR_UNDERFLOW_SHIFT       1
+#define ISCSI_DATA_IN_HDR_OVERFLOW_MASK         0x1
+#define ISCSI_DATA_IN_HDR_OVERFLOW_SHIFT        2
+#define ISCSI_DATA_IN_HDR_RSRV_MASK             0x7
+#define ISCSI_DATA_IN_HDR_RSRV_SHIFT            3
+#define ISCSI_DATA_IN_HDR_ACK_MASK              0x1
+#define ISCSI_DATA_IN_HDR_ACK_SHIFT             6
+#define ISCSI_DATA_IN_HDR_FINAL_MASK            0x1
+#define ISCSI_DATA_IN_HDR_FINAL_SHIFT           7
         u8 opcode;
         __le32 reserved2;
         struct regpair lun;
@@ -397,6 +430,7 @@ struct iscsi_data_in_hdr {
         __le32 residual_count;
 };
 
+/* iSCSI R2T PDU header */
 struct iscsi_r2t_hdr {
         u8 reserved0[3];
         u8 opcode;
@@ -412,13 +446,14 @@ struct iscsi_r2t_hdr {
         __le32 desired_data_trns_len;
 };
 
+/* iSCSI NOP-out PDU header */
 struct iscsi_nop_out_hdr {
         __le16 reserved1;
         u8 flags_attr;
-#define ISCSI_NOP_OUT_HDR_RSRV_MASK    0x7F
-#define ISCSI_NOP_OUT_HDR_RSRV_SHIFT   0
-#define ISCSI_NOP_OUT_HDR_CONST1_MASK  0x1
-#define ISCSI_NOP_OUT_HDR_CONST1_SHIFT 7
+#define ISCSI_NOP_OUT_HDR_RSRV_MASK     0x7F
+#define ISCSI_NOP_OUT_HDR_RSRV_SHIFT    0
+#define ISCSI_NOP_OUT_HDR_CONST1_MASK   0x1
+#define ISCSI_NOP_OUT_HDR_CONST1_SHIFT  7
         u8 opcode;
         __le32 reserved2;
         struct regpair lun;
@@ -432,19 +467,20 @@ struct iscsi_nop_out_hdr {
         __le32 reserved6;
 };
 
+/* iSCSI NOP-in PDU header */
 struct iscsi_nop_in_hdr {
         __le16 reserved0;
         u8 flags_attr;
-#define ISCSI_NOP_IN_HDR_RSRV_MASK           0x7F
-#define ISCSI_NOP_IN_HDR_RSRV_SHIFT          0
-#define ISCSI_NOP_IN_HDR_CONST1_MASK         0x1
-#define ISCSI_NOP_IN_HDR_CONST1_SHIFT        7
+#define ISCSI_NOP_IN_HDR_RSRV_MASK      0x7F
+#define ISCSI_NOP_IN_HDR_RSRV_SHIFT     0
+#define ISCSI_NOP_IN_HDR_CONST1_MASK    0x1
+#define ISCSI_NOP_IN_HDR_CONST1_SHIFT   7
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_NOP_IN_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_NOP_IN_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_NOP_IN_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_NOP_IN_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_NOP_IN_HDR_DATA_SEG_LEN_MASK      0xFFFFFF
+#define ISCSI_NOP_IN_HDR_DATA_SEG_LEN_SHIFT     0
+#define ISCSI_NOP_IN_HDR_TOTAL_AHS_LEN_MASK     0xFF
+#define ISCSI_NOP_IN_HDR_TOTAL_AHS_LEN_SHIFT    24
         struct regpair lun;
         __le32 itt;
         __le32 ttt;
@@ -456,26 +492,27 @@ struct iscsi_nop_in_hdr {
         __le32 reserved7;
 };
 
+/* iSCSI Login Response PDU header */
 struct iscsi_login_response_hdr {
         u8 version_active;
         u8 version_max;
         u8 flags_attr;
-#define ISCSI_LOGIN_RESPONSE_HDR_NSG_MASK            0x3
-#define ISCSI_LOGIN_RESPONSE_HDR_NSG_SHIFT           0
-#define ISCSI_LOGIN_RESPONSE_HDR_CSG_MASK            0x3
-#define ISCSI_LOGIN_RESPONSE_HDR_CSG_SHIFT           2
-#define ISCSI_LOGIN_RESPONSE_HDR_RSRV_MASK           0x3
-#define ISCSI_LOGIN_RESPONSE_HDR_RSRV_SHIFT          4
-#define ISCSI_LOGIN_RESPONSE_HDR_C_MASK              0x1
-#define ISCSI_LOGIN_RESPONSE_HDR_C_SHIFT             6
-#define ISCSI_LOGIN_RESPONSE_HDR_T_MASK              0x1
-#define ISCSI_LOGIN_RESPONSE_HDR_T_SHIFT             7
+#define ISCSI_LOGIN_RESPONSE_HDR_NSG_MASK       0x3
+#define ISCSI_LOGIN_RESPONSE_HDR_NSG_SHIFT      0
+#define ISCSI_LOGIN_RESPONSE_HDR_CSG_MASK       0x3
+#define ISCSI_LOGIN_RESPONSE_HDR_CSG_SHIFT      2
+#define ISCSI_LOGIN_RESPONSE_HDR_RSRV_MASK      0x3
+#define ISCSI_LOGIN_RESPONSE_HDR_RSRV_SHIFT     4
+#define ISCSI_LOGIN_RESPONSE_HDR_C_MASK         0x1
+#define ISCSI_LOGIN_RESPONSE_HDR_C_SHIFT        6
+#define ISCSI_LOGIN_RESPONSE_HDR_T_MASK         0x1
+#define ISCSI_LOGIN_RESPONSE_HDR_T_SHIFT        7
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_LOGIN_RESPONSE_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_LOGIN_RESPONSE_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_LOGIN_RESPONSE_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_LOGIN_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_LOGIN_RESPONSE_HDR_DATA_SEG_LEN_MASK      0xFFFFFF
+#define ISCSI_LOGIN_RESPONSE_HDR_DATA_SEG_LEN_SHIFT     0
+#define ISCSI_LOGIN_RESPONSE_HDR_TOTAL_AHS_LEN_MASK     0xFF
+#define ISCSI_LOGIN_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT    24
         __le32 isid_tabc;
         __le16 tsih;
         __le16 isid_d;
@@ -490,16 +527,17 @@ struct iscsi_login_response_hdr {
         __le32 reserved4[2];
 };
 
+/* iSCSI Logout Response PDU header */
 struct iscsi_logout_response_hdr {
         u8 reserved1;
         u8 response;
         u8 flags;
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_LOGOUT_RESPONSE_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_LOGOUT_RESPONSE_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_LOGOUT_RESPONSE_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_LOGOUT_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_LOGOUT_RESPONSE_HDR_DATA_SEG_LEN_MASK     0xFFFFFF
+#define ISCSI_LOGOUT_RESPONSE_HDR_DATA_SEG_LEN_SHIFT    0
+#define ISCSI_LOGOUT_RESPONSE_HDR_TOTAL_AHS_LEN_MASK    0xFF
+#define ISCSI_LOGOUT_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT   24
         __le32 reserved2[2];
         __le32 itt;
         __le32 reserved3;
@@ -512,21 +550,22 @@ struct iscsi_logout_response_hdr {
         __le32 reserved5[1];
 };
 
+/* iSCSI Text Request PDU header */
 struct iscsi_text_request_hdr {
         __le16 reserved0;
         u8 flags_attr;
-#define ISCSI_TEXT_REQUEST_HDR_RSRV_MASK           0x3F
-#define ISCSI_TEXT_REQUEST_HDR_RSRV_SHIFT          0
-#define ISCSI_TEXT_REQUEST_HDR_C_MASK              0x1
-#define ISCSI_TEXT_REQUEST_HDR_C_SHIFT             6
-#define ISCSI_TEXT_REQUEST_HDR_F_MASK              0x1
-#define ISCSI_TEXT_REQUEST_HDR_F_SHIFT             7
+#define ISCSI_TEXT_REQUEST_HDR_RSRV_MASK        0x3F
+#define ISCSI_TEXT_REQUEST_HDR_RSRV_SHIFT       0
+#define ISCSI_TEXT_REQUEST_HDR_C_MASK           0x1
+#define ISCSI_TEXT_REQUEST_HDR_C_SHIFT          6
+#define ISCSI_TEXT_REQUEST_HDR_F_MASK           0x1
+#define ISCSI_TEXT_REQUEST_HDR_F_SHIFT          7
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_TEXT_REQUEST_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_TEXT_REQUEST_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_TEXT_REQUEST_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_TEXT_REQUEST_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_TEXT_REQUEST_HDR_DATA_SEG_LEN_MASK        0xFFFFFF
+#define ISCSI_TEXT_REQUEST_HDR_DATA_SEG_LEN_SHIFT       0
+#define ISCSI_TEXT_REQUEST_HDR_TOTAL_AHS_LEN_MASK       0xFF
+#define ISCSI_TEXT_REQUEST_HDR_TOTAL_AHS_LEN_SHIFT      24
         struct regpair lun;
         __le32 itt;
         __le32 ttt;
@@ -535,21 +574,22 @@ struct iscsi_text_request_hdr {
         __le32 reserved4[4];
 };
 
+/* iSCSI Text Response PDU header */
 struct iscsi_text_response_hdr {
         __le16 reserved1;
         u8 flags;
-#define ISCSI_TEXT_RESPONSE_HDR_RSRV_MASK           0x3F
-#define ISCSI_TEXT_RESPONSE_HDR_RSRV_SHIFT          0
-#define ISCSI_TEXT_RESPONSE_HDR_C_MASK              0x1
-#define ISCSI_TEXT_RESPONSE_HDR_C_SHIFT             6
-#define ISCSI_TEXT_RESPONSE_HDR_F_MASK              0x1
-#define ISCSI_TEXT_RESPONSE_HDR_F_SHIFT             7
+#define ISCSI_TEXT_RESPONSE_HDR_RSRV_MASK       0x3F
+#define ISCSI_TEXT_RESPONSE_HDR_RSRV_SHIFT      0
+#define ISCSI_TEXT_RESPONSE_HDR_C_MASK          0x1
+#define ISCSI_TEXT_RESPONSE_HDR_C_SHIFT         6
+#define ISCSI_TEXT_RESPONSE_HDR_F_MASK          0x1
+#define ISCSI_TEXT_RESPONSE_HDR_F_SHIFT         7
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_TEXT_RESPONSE_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_TEXT_RESPONSE_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_TEXT_RESPONSE_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_TEXT_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_TEXT_RESPONSE_HDR_DATA_SEG_LEN_MASK       0xFFFFFF
+#define ISCSI_TEXT_RESPONSE_HDR_DATA_SEG_LEN_SHIFT      0
+#define ISCSI_TEXT_RESPONSE_HDR_TOTAL_AHS_LEN_MASK      0xFF
+#define ISCSI_TEXT_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT     24
         struct regpair lun;
         __le32 itt;
         __le32 ttt;
@@ -559,15 +599,16 @@ struct iscsi_text_response_hdr {
         __le32 reserved4[3];
 };
 
+/* iSCSI TMF Request PDU header */
 struct iscsi_tmf_request_hdr {
         __le16 reserved0;
         u8 function;
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_TMF_REQUEST_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_TMF_REQUEST_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_TMF_REQUEST_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_TMF_REQUEST_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_TMF_REQUEST_HDR_DATA_SEG_LEN_MASK         0xFFFFFF
+#define ISCSI_TMF_REQUEST_HDR_DATA_SEG_LEN_SHIFT        0
+#define ISCSI_TMF_REQUEST_HDR_TOTAL_AHS_LEN_MASK        0xFF
+#define ISCSI_TMF_REQUEST_HDR_TOTAL_AHS_LEN_SHIFT       24
         struct regpair lun;
         __le32 itt;
         __le32 rtt;
@@ -584,10 +625,10 @@ struct iscsi_tmf_response_hdr {
         u8 hdr_flags;
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_TMF_RESPONSE_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_TMF_RESPONSE_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_TMF_RESPONSE_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_TMF_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_TMF_RESPONSE_HDR_DATA_SEG_LEN_MASK        0xFFFFFF
+#define ISCSI_TMF_RESPONSE_HDR_DATA_SEG_LEN_SHIFT       0
+#define ISCSI_TMF_RESPONSE_HDR_TOTAL_AHS_LEN_MASK       0xFF
+#define ISCSI_TMF_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT      24
         struct regpair reserved0;
         __le32 itt;
         __le32 reserved1;
@@ -597,16 +638,17 @@ struct iscsi_tmf_response_hdr {
         __le32 reserved4[3];
 };
 
+/* iSCSI Response PDU header */
 struct iscsi_response_hdr {
         u8 hdr_status;
         u8 hdr_response;
         u8 hdr_flags;
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_RESPONSE_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_RESPONSE_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_RESPONSE_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_RESPONSE_HDR_DATA_SEG_LEN_MASK    0xFFFFFF
+#define ISCSI_RESPONSE_HDR_DATA_SEG_LEN_SHIFT   0
+#define ISCSI_RESPONSE_HDR_TOTAL_AHS_LEN_MASK   0xFF
+#define ISCSI_RESPONSE_HDR_TOTAL_AHS_LEN_SHIFT  24
         struct regpair lun;
         __le32 itt;
         __le32 snack_tag;
@@ -618,16 +660,17 @@ struct iscsi_response_hdr {
         __le32 residual_count;
 };
 
+/* iSCSI Reject PDU header */
 struct iscsi_reject_hdr {
         u8 reserved4;
         u8 hdr_reason;
         u8 hdr_flags;
         u8 opcode;
         __le32 hdr_second_dword;
-#define ISCSI_REJECT_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
-#define ISCSI_REJECT_HDR_DATA_SEG_LEN_SHIFT  0
-#define ISCSI_REJECT_HDR_TOTAL_AHS_LEN_MASK  0xFF
-#define ISCSI_REJECT_HDR_TOTAL_AHS_LEN_SHIFT 24
+#define ISCSI_REJECT_HDR_DATA_SEG_LEN_MASK      0xFFFFFF
+#define ISCSI_REJECT_HDR_DATA_SEG_LEN_SHIFT     0
+#define ISCSI_REJECT_HDR_TOTAL_AHS_LEN_MASK     0xFF
+#define ISCSI_REJECT_HDR_TOTAL_AHS_LEN_SHIFT    24
         struct regpair reserved0;
         __le32 all_ones;
         __le32 reserved2;
@@ -638,6 +681,35 @@ struct iscsi_reject_hdr {
         __le32 reserved3[2];
 };
 
+/* iSCSI Asynchronous Message PDU header */
+struct iscsi_async_msg_hdr {
+        __le16 reserved0;
+        u8 flags_attr;
+#define ISCSI_ASYNC_MSG_HDR_RSRV_MASK           0x7F
+#define ISCSI_ASYNC_MSG_HDR_RSRV_SHIFT          0
+#define ISCSI_ASYNC_MSG_HDR_CONST1_MASK         0x1
+#define ISCSI_ASYNC_MSG_HDR_CONST1_SHIFT        7
+        u8 opcode;
+        __le32 hdr_second_dword;
+#define ISCSI_ASYNC_MSG_HDR_DATA_SEG_LEN_MASK   0xFFFFFF
+#define ISCSI_ASYNC_MSG_HDR_DATA_SEG_LEN_SHIFT  0
+#define ISCSI_ASYNC_MSG_HDR_TOTAL_AHS_LEN_MASK  0xFF
+#define ISCSI_ASYNC_MSG_HDR_TOTAL_AHS_LEN_SHIFT 24
+        struct regpair lun;
+        __le32 all_ones;
+        __le32 reserved1;
+        __le32 stat_sn;
+        __le32 exp_cmd_sn;
+        __le32 max_cmd_sn;
+        __le16 param1_rsrv;
+        u8 async_vcode;
+        u8 async_event;
+        __le16 param3_rsrv;
+        __le16 param2_rsrv;
+        __le32 reserved7;
+};
+
+/* PDU header part of Ystorm task context */
 union iscsi_task_hdr {
         struct iscsi_common_hdr common;
         struct data_hdr data;
@@ -661,6 +733,348 @@ union iscsi_task_hdr {
         struct iscsi_async_msg_hdr async_msg;
 };
 
+/* The iscsi storm task context of Ystorm */
+struct ystorm_iscsi_task_st_ctx {
+        struct ystorm_iscsi_task_state state;
+        struct ystorm_iscsi_task_rxmit_opt rxmit_opt;
+        union iscsi_task_hdr pdu_hdr;
+};
+
+struct e4_ystorm_iscsi_task_ag_ctx {
+        u8 reserved;
+        u8 byte1;
+        __le16 word0;
+        u8 flags0;
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_MASK        0xF
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_SHIFT       0
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT0_MASK           0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT0_SHIFT          4
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT1_MASK           0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT          5
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_VALID_MASK          0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_VALID_SHIFT         6
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT3_MASK           0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT3_SHIFT          7
+        u8 flags1;
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF0_MASK            0x3
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF0_SHIFT           0
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF1_MASK            0x3
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF1_SHIFT           2
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF2SPECIAL_MASK     0x3
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF2SPECIAL_SHIFT    4
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF0EN_MASK          0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF0EN_SHIFT         6
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF1EN_MASK          0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_CF1EN_SHIFT         7
+        u8 flags2;
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT4_MASK           0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_BIT4_SHIFT          0
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE0EN_MASK        0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE0EN_SHIFT       1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK        0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT       2
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE2EN_MASK        0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE2EN_SHIFT       3
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK        0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT       4
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK        0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT       5
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK        0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT       6
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE6EN_MASK        0x1
+#define E4_YSTORM_ISCSI_TASK_AG_CTX_RULE6EN_SHIFT       7
+        u8 byte2;
+        __le32 TTT;
+        u8 byte3;
+        u8 byte4;
+        __le16 word1;
+};
+
+struct e4_mstorm_iscsi_task_ag_ctx {
+        u8 cdu_validation;
+        u8 byte1;
+        __le16 task_cid;
+        u8 flags0;
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_MASK        0xF
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_SHIFT       0
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_MASK           0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_SHIFT          4
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_BIT1_MASK                   0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT                  5
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_VALID_MASK                  0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_VALID_SHIFT                 6
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_FLAG_MASK      0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_FLAG_SHIFT     7
+        u8 flags1;
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_MASK        0x3
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_SHIFT       0
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF1_MASK                    0x3
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF1_SHIFT                   2
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF2_MASK                    0x3
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF2_SHIFT                   4
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_EN_MASK     0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_EN_SHIFT    6
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF1EN_MASK                  0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF1EN_SHIFT                 7
+        u8 flags2;
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF2EN_MASK          0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_CF2EN_SHIFT         0
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE0EN_MASK        0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE0EN_SHIFT       1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK        0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT       2
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE2EN_MASK        0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE2EN_SHIFT       3
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK        0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT       4
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK        0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT       5
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK        0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT       6
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE6EN_MASK        0x1
+#define E4_MSTORM_ISCSI_TASK_AG_CTX_RULE6EN_SHIFT       7
+        u8 byte2;
+        __le32 reg0;
+        u8 byte3;
+        u8 byte4;
+        __le16 word1;
+};
+
+struct e4_ustorm_iscsi_task_ag_ctx {
+        u8 reserved;
+        u8 state;
+        __le16 icid;
+        u8 flags0;
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_MASK        0xF
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_SHIFT       0
+#define E4_USTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_MASK           0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_SHIFT          4
+#define E4_USTORM_ISCSI_TASK_AG_CTX_BIT1_MASK                   0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT                  5
+#define E4_USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_MASK          0x3
+#define E4_USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_SHIFT         6
+        u8 flags1;
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RESERVED1_MASK      0x3
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RESERVED1_SHIFT     0
+#define E4_USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_MASK       0x3
+#define E4_USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_SHIFT      2
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CF3_MASK            0x3
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CF3_SHIFT           4
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_MASK   0x3
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_SHIFT  6
+        u8 flags2;
+#define E4_USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_EN_MASK       0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_EN_SHIFT      0
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DISABLE_DATA_ACKED_MASK     0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DISABLE_DATA_ACKED_SHIFT    1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_EN_MASK            0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_EN_SHIFT           2
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CF3EN_MASK                  0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CF3EN_SHIFT                 3
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_EN_MASK        0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_EN_SHIFT       4
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_MASK  0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_SHIFT 5
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK                0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT               6
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_MASK    0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_SHIFT   7
+        u8 flags3;
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK                0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT               0
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK                0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT               1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK                0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT               2
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE6EN_MASK                0x1
+#define E4_USTORM_ISCSI_TASK_AG_CTX_RULE6EN_SHIFT               3
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_TYPE_MASK         0xF
+#define E4_USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_TYPE_SHIFT        4
+        __le32 dif_err_intervals;
+        __le32 dif_error_1st_interval;
+        __le32 rcv_cont_len;
+        __le32 exp_cont_len;
+        __le32 total_data_acked;
+        __le32 exp_data_acked;
+        u8 next_tid_valid;
+        u8 byte3;
+        __le16 word1;
+        __le16 next_tid;
+        __le16 word3;
+        __le32 hdr_residual_count;
+        __le32 exp_r2t_sn;
+};
+
+/* The iscsi storm task context of Mstorm */
+struct mstorm_iscsi_task_st_ctx {
+        struct scsi_cached_sges data_desc;
+        struct scsi_sgl_params sgl_params;
+        __le32 rem_task_size;
+        __le32 data_buffer_offset;
+        u8 task_type;
+        struct iscsi_dif_flags dif_flags;
+        __le16 dif_task_icid;
+        struct regpair sense_db;
+        __le32 expected_itt;
+        __le32 reserved1;
+};
+
+struct iscsi_reg1 {
+        __le32 reg1_map;
+#define ISCSI_REG1_NUM_SGES_MASK        0xF
+#define ISCSI_REG1_NUM_SGES_SHIFT       0
+#define ISCSI_REG1_RESERVED1_MASK       0xFFFFFFF
+#define ISCSI_REG1_RESERVED1_SHIFT      4
+};
+
+struct tqe_opaque {
+        __le16 opaque[2];
+};
+
+/* The iscsi storm task context of Ustorm */
+struct ustorm_iscsi_task_st_ctx {
+        __le32 rem_rcv_len;
+        __le32 exp_data_transfer_len;
+        __le32 exp_data_sn;
+        struct regpair lun;
+        struct iscsi_reg1 reg1;
+        u8 flags2;
+#define USTORM_ISCSI_TASK_ST_CTX_AHS_EXIST_MASK         0x1
+#define USTORM_ISCSI_TASK_ST_CTX_AHS_EXIST_SHIFT        0
+#define USTORM_ISCSI_TASK_ST_CTX_RESERVED1_MASK         0x7F
+#define USTORM_ISCSI_TASK_ST_CTX_RESERVED1_SHIFT        1
+        struct iscsi_dif_flags dif_flags;
+        __le16 reserved3;
+        struct tqe_opaque tqe_opaque_list;
+        __le32 reserved5;
+        __le32 reserved6;
+        __le32 reserved7;
+        u8 task_type;
+        u8 error_flags;
+#define USTORM_ISCSI_TASK_ST_CTX_DATA_DIGEST_ERROR_MASK         0x1
+#define USTORM_ISCSI_TASK_ST_CTX_DATA_DIGEST_ERROR_SHIFT        0
+#define USTORM_ISCSI_TASK_ST_CTX_DATA_TRUNCATED_ERROR_MASK      0x1
+#define USTORM_ISCSI_TASK_ST_CTX_DATA_TRUNCATED_ERROR_SHIFT     1
+#define USTORM_ISCSI_TASK_ST_CTX_UNDER_RUN_ERROR_MASK           0x1
+#define USTORM_ISCSI_TASK_ST_CTX_UNDER_RUN_ERROR_SHIFT          2
+#define USTORM_ISCSI_TASK_ST_CTX_RESERVED8_MASK                 0x1F
+#define USTORM_ISCSI_TASK_ST_CTX_RESERVED8_SHIFT                3
+        u8 flags;
+#define USTORM_ISCSI_TASK_ST_CTX_CQE_WRITE_MASK                 0x3
+#define USTORM_ISCSI_TASK_ST_CTX_CQE_WRITE_SHIFT                0
+#define USTORM_ISCSI_TASK_ST_CTX_LOCAL_COMP_MASK                0x1
+#define USTORM_ISCSI_TASK_ST_CTX_LOCAL_COMP_SHIFT               2
+#define USTORM_ISCSI_TASK_ST_CTX_Q0_R2TQE_WRITE_MASK            0x1
+#define USTORM_ISCSI_TASK_ST_CTX_Q0_R2TQE_WRITE_SHIFT           3
+#define USTORM_ISCSI_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_MASK     0x1
+#define USTORM_ISCSI_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_SHIFT    4
+#define USTORM_ISCSI_TASK_ST_CTX_HQ_SCANNED_DONE_MASK           0x1
+#define USTORM_ISCSI_TASK_ST_CTX_HQ_SCANNED_DONE_SHIFT          5
+#define USTORM_ISCSI_TASK_ST_CTX_R2T2RECV_DONE_MASK             0x1
+#define USTORM_ISCSI_TASK_ST_CTX_R2T2RECV_DONE_SHIFT            6
+#define USTORM_ISCSI_TASK_ST_CTX_RESERVED0_MASK                 0x1
+#define USTORM_ISCSI_TASK_ST_CTX_RESERVED0_SHIFT                7
+        u8 cq_rss_number;
+};
+
+/* iscsi task context */
+struct e4_iscsi_task_context {
+        struct ystorm_iscsi_task_st_ctx ystorm_st_context;
+        struct e4_ystorm_iscsi_task_ag_ctx ystorm_ag_context;
+        struct regpair ystorm_ag_padding[2];
+        struct tdif_task_context tdif_context;
+        struct e4_mstorm_iscsi_task_ag_ctx mstorm_ag_context;
+        struct regpair mstorm_ag_padding[2];
+        struct e4_ustorm_iscsi_task_ag_ctx ustorm_ag_context;
+        struct mstorm_iscsi_task_st_ctx mstorm_st_context;
+        struct ustorm_iscsi_task_st_ctx ustorm_st_context;
+        struct rdif_task_context rdif_context;
+};
+
+/* iSCSI connection offload params passed by driver to FW in ISCSI offload
+ * ramrod.
+ */
+struct iscsi_conn_offload_params {
+        struct regpair sq_pbl_addr;
+        struct regpair r2tq_pbl_addr;
+        struct regpair xhq_pbl_addr;
+        struct regpair uhq_pbl_addr;
+        __le32 initial_ack;
+        __le16 physical_q0;
+        __le16 physical_q1;
+        u8 flags;
+#define ISCSI_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_MASK   0x1
+#define ISCSI_CONN_OFFLOAD_PARAMS_TCP_ON_CHIP_1B_SHIFT  0
+#define ISCSI_CONN_OFFLOAD_PARAMS_TARGET_MODE_MASK      0x1
+#define ISCSI_CONN_OFFLOAD_PARAMS_TARGET_MODE_SHIFT     1
+#define ISCSI_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_MASK  0x1
+#define ISCSI_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_SHIFT 2
+#define ISCSI_CONN_OFFLOAD_PARAMS_RESERVED1_MASK        0x1F
+#define ISCSI_CONN_OFFLOAD_PARAMS_RESERVED1_SHIFT       3
+        u8 pbl_page_size_log;
+        u8 pbe_page_size_log;
+        u8 default_cq;
+        __le32 stat_sn;
+};
+
+/* iSCSI connection statistics */
+struct iscsi_conn_stats_params {
+        struct regpair iscsi_tcp_tx_packets_cnt;
+        struct regpair iscsi_tcp_tx_bytes_cnt;
+        struct regpair iscsi_tcp_tx_rxmit_cnt;
+        struct regpair iscsi_tcp_rx_packets_cnt;
+        struct regpair iscsi_tcp_rx_bytes_cnt;
+        struct regpair iscsi_tcp_rx_dup_ack_cnt;
+        __le32 iscsi_tcp_rx_chksum_err_cnt;
+        __le32 reserved;
+};
+
+/* spe message header */
+struct iscsi_slow_path_hdr {
+        u8 op_code;
+        u8 flags;
+#define ISCSI_SLOW_PATH_HDR_RESERVED0_MASK      0xF
+#define ISCSI_SLOW_PATH_HDR_RESERVED0_SHIFT     0
+#define ISCSI_SLOW_PATH_HDR_LAYER_CODE_MASK     0x7
+#define ISCSI_SLOW_PATH_HDR_LAYER_CODE_SHIFT    4
+#define ISCSI_SLOW_PATH_HDR_RESERVED1_MASK      0x1
+#define ISCSI_SLOW_PATH_HDR_RESERVED1_SHIFT     7
+};
+
+/* iSCSI connection update params passed by driver to FW in ISCSI update
+ *ramrod.
+ */
+struct iscsi_conn_update_ramrod_params {
+        struct iscsi_slow_path_hdr hdr;
+        __le16 conn_id;
+        __le32 fw_cid;
+        u8 flags;
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN_MASK              0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN_SHIFT             0
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DD_EN_MASK              0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DD_EN_SHIFT             1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_INITIAL_R2T_MASK        0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_INITIAL_R2T_SHIFT       2
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_IMMEDIATE_DATA_MASK     0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_IMMEDIATE_DATA_SHIFT    3
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_BLOCK_SIZE_MASK     0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_BLOCK_SIZE_SHIFT    4
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_ON_HOST_EN_MASK     0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_ON_HOST_EN_SHIFT    5
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_ON_IMM_EN_MASK      0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_ON_IMM_EN_SHIFT     6
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_LUN_MAPPER_EN_MASK      0x1
+#define ISCSI_CONN_UPDATE_RAMROD_PARAMS_LUN_MAPPER_EN_SHIFT     7
+        u8 reserved0[3];
+        __le32 max_seq_size;
+        __le32 max_send_pdu_length;
+        __le32 max_recv_pdu_length;
+        __le32 first_seq_length;
+        __le32 exp_stat_sn;
+        union dif_configuration_params dif_on_imme_params;
+};
+
+/* iSCSI CQ element */
 struct iscsi_cqe_common {
         __le16 conn_id;
         u8 cqe_type;
@@ -669,6 +1083,7 @@ struct iscsi_cqe_common {
         union iscsi_task_hdr iscsi_hdr;
 };
 
+/* iSCSI CQ element */
 struct iscsi_cqe_solicited {
         __le16 conn_id;
         u8 cqe_type;
@@ -678,10 +1093,11 @@ struct iscsi_cqe_solicited {
         u8 fw_dbg_field;
         u8 caused_conn_err;
         u8 reserved0[3];
-        __le32 reserved1[1];
+        __le32 data_truncated_bytes;
         union iscsi_task_hdr iscsi_hdr;
 };
 
+/* iSCSI CQ element */
 struct iscsi_cqe_unsolicited {
         __le16 conn_id;
         u8 cqe_type;
@@ -689,16 +1105,19 @@ struct iscsi_cqe_unsolicited {
         __le16 reserved0;
         u8 reserved1;
         u8 unsol_cqe_type;
-        struct regpair rqe_opaque;
+        __le16 rqe_opaque;
+        __le16 reserved2[3];
         union iscsi_task_hdr iscsi_hdr;
 };
 
+/* iSCSI CQ element */
 union iscsi_cqe {
         struct iscsi_cqe_common cqe_common;
         struct iscsi_cqe_solicited cqe_solicited;
         struct iscsi_cqe_unsolicited cqe_unsolicited;
 };
 
+/* iSCSI CQE type */
 enum iscsi_cqes_type {
         ISCSI_CQE_TYPE_SOLICITED = 1,
         ISCSI_CQE_TYPE_UNSOLICITED,
@@ -708,6 +1127,7 @@ enum iscsi_cqes_type {
         MAX_ISCSI_CQES_TYPE
 };
 
+/* iSCSI CQE type */
 enum iscsi_cqe_unsolicited_type {
         ISCSI_CQE_UNSOLICITED_NONE,
         ISCSI_CQE_UNSOLICITED_SINGLE,
@@ -717,37 +1137,28 @@ enum iscsi_cqe_unsolicited_type {
         MAX_ISCSI_CQE_UNSOLICITED_TYPE
 };
 
-
+/* iscsi debug modes */
 struct iscsi_debug_modes {
         u8 flags;
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RX_CONN_ERROR_MASK         0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RX_CONN_ERROR_SHIFT        0
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_RESET_MASK            0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_RESET_SHIFT           1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_FIN_MASK              0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_FIN_SHIFT             2
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_CLEANUP_MASK          0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_CLEANUP_SHIFT         3
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_REJECT_OR_ASYNC_MASK  0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_REJECT_OR_ASYNC_SHIFT 4
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_NOP_MASK              0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_NOP_SHIFT             5
-#define ISCSI_DEBUG_MODES_ASSERT_IF_DATA_DIGEST_ERROR_MASK     0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_DATA_DIGEST_ERROR_SHIFT    6
-#define ISCSI_DEBUG_MODES_ASSERT_IF_DIF_ERROR_MASK             0x1
-#define ISCSI_DEBUG_MODES_ASSERT_IF_DIF_ERROR_SHIFT            7
-};
-
-struct iscsi_dif_flags {
-        u8 flags;
-#define ISCSI_DIF_FLAGS_PROT_INTERVAL_SIZE_LOG_MASK  0xF
-#define ISCSI_DIF_FLAGS_PROT_INTERVAL_SIZE_LOG_SHIFT 0
-#define ISCSI_DIF_FLAGS_DIF_TO_PEER_MASK             0x1
-#define ISCSI_DIF_FLAGS_DIF_TO_PEER_SHIFT            4
-#define ISCSI_DIF_FLAGS_HOST_INTERFACE_MASK          0x7
-#define ISCSI_DIF_FLAGS_HOST_INTERFACE_SHIFT         5
-};
-
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RX_CONN_ERROR_MASK                  0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RX_CONN_ERROR_SHIFT                 0
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_RESET_MASK                     0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_RESET_SHIFT                    1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_FIN_MASK                       0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_FIN_SHIFT                      2
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_CLEANUP_MASK                   0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_CLEANUP_SHIFT                  3
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_REJECT_OR_ASYNC_MASK           0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_REJECT_OR_ASYNC_SHIFT          4
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_NOP_MASK                       0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_RECV_NOP_SHIFT                      5
+#define ISCSI_DEBUG_MODES_ASSERT_IF_DIF_OR_DATA_DIGEST_ERROR_MASK       0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_DIF_OR_DATA_DIGEST_ERROR_SHIFT      6
+#define ISCSI_DEBUG_MODES_ASSERT_IF_HQ_CORRUPT_MASK                     0x1
+#define ISCSI_DEBUG_MODES_ASSERT_IF_HQ_CORRUPT_SHIFT                    7
+};
+
+/* iSCSI kernel completion queue IDs */
 enum iscsi_eqe_opcode {
         ISCSI_EVENT_TYPE_INIT_FUNC = 0,
         ISCSI_EVENT_TYPE_DESTROY_FUNC,
@@ -756,9 +1167,9 @@ enum iscsi_eqe_opcode {
         ISCSI_EVENT_TYPE_CLEAR_SQ,
         ISCSI_EVENT_TYPE_TERMINATE_CONN,
         ISCSI_EVENT_TYPE_MAC_UPDATE_CONN,
+        ISCSI_EVENT_TYPE_COLLECT_STATS_CONN,
         ISCSI_EVENT_TYPE_ASYN_CONNECT_COMPLETE,
         ISCSI_EVENT_TYPE_ASYN_TERMINATE_DONE,
-        RESERVED9,
         ISCSI_EVENT_TYPE_START_OF_ERROR_TYPES = 10,
         ISCSI_EVENT_TYPE_ASYN_ABORT_RCVD,
         ISCSI_EVENT_TYPE_ASYN_CLOSE_RCVD,
@@ -772,6 +1183,7 @@ enum iscsi_eqe_opcode {
         MAX_ISCSI_EQE_OPCODE
 };
 
+/* iSCSI EQE and CQE completion status */
 enum iscsi_error_types {
         ISCSI_STATUS_NONE = 0,
         ISCSI_CQE_ERROR_UNSOLICITED_RCV_ON_INVALID_CONN = 1,
@@ -823,7 +1235,7 @@ enum iscsi_error_types {
         MAX_ISCSI_ERROR_TYPES
 };
 
-
+/* iSCSI Ramrod Command IDs */
 enum iscsi_ramrod_cmd_id {
         ISCSI_RAMROD_CMD_ID_UNUSED = 0,
         ISCSI_RAMROD_CMD_ID_INIT_FUNC = 1,
@@ -833,22 +1245,11 @@ enum iscsi_ramrod_cmd_id {
         ISCSI_RAMROD_CMD_ID_TERMINATION_CONN = 5,
         ISCSI_RAMROD_CMD_ID_CLEAR_SQ = 6,
         ISCSI_RAMROD_CMD_ID_MAC_UPDATE = 7,
+        ISCSI_RAMROD_CMD_ID_CONN_STATS = 8,
         MAX_ISCSI_RAMROD_CMD_ID
 };
 
-struct iscsi_reg1 {
-        __le32 reg1_map;
-#define ISCSI_REG1_NUM_SGES_MASK   0xF
-#define ISCSI_REG1_NUM_SGES_SHIFT  0
-#define ISCSI_REG1_RESERVED1_MASK  0xFFFFFFF
-#define ISCSI_REG1_RESERVED1_SHIFT 4
-};
-
-union iscsi_seq_num {
-        __le16 data_sn;
-        __le16 r2t_sn;
-};
-
+/* iSCSI connection termination request */
 struct iscsi_spe_conn_mac_update {
         struct iscsi_slow_path_hdr hdr;
         __le16 conn_id;
@@ -859,6 +1260,9 @@ struct iscsi_spe_conn_mac_update {
         u8 reserved0[2];
 };
 
+/* iSCSI and TCP connection (Option 1) offload params passed by driver to FW in
+ * iSCSI offload ramrod.
+ */
 struct iscsi_spe_conn_offload {
         struct iscsi_slow_path_hdr hdr;
         __le16 conn_id;
@@ -867,6 +1271,9 @@ struct iscsi_spe_conn_offload {
         struct tcp_offload_params tcp;
 };
 
+/* iSCSI and TCP connection(Option 2) offload params passed by driver to FW in
+ * iSCSI offload ramrod.
+ */
 struct iscsi_spe_conn_offload_option2 {
         struct iscsi_slow_path_hdr hdr;
         __le16 conn_id;
@@ -875,6 +1282,17 @@ struct iscsi_spe_conn_offload_option2 {
         struct tcp_offload_params_opt2 tcp;
 };
 
+/* iSCSI collect connection statistics request */
+struct iscsi_spe_conn_statistics {
+        struct iscsi_slow_path_hdr hdr;
+        __le16 conn_id;
+        __le32 fw_cid;
+        u8 reset_stats;
+        u8 reserved0[7];
+        struct regpair stats_cnts_addr;
+};
+
+/* iSCSI connection termination request */
 struct iscsi_spe_conn_termination {
         struct iscsi_slow_path_hdr hdr;
         __le16 conn_id;
@@ -885,12 +1303,14 @@ struct iscsi_spe_conn_termination {
         struct regpair query_params_addr;
 };
 
+/* iSCSI firmware function destroy parameters */
 struct iscsi_spe_func_dstry {
         struct iscsi_slow_path_hdr hdr;
         __le16 reserved0;
         __le32 reserved1;
 };
 
+/* iSCSI firmware function init parameters */
 struct iscsi_spe_func_init {
         struct iscsi_slow_path_hdr hdr;
         __le16 half_way_close_timeout;
@@ -898,283 +1318,19 @@ struct iscsi_spe_func_init {
         u8 num_r2tq_pages_in_ring;
         u8 num_uhq_pages_in_ring;
         u8 ll2_rx_queue_id;
-        u8 ooo_enable;
+        u8 flags;
+#define ISCSI_SPE_FUNC_INIT_COUNTERS_EN_MASK    0x1
+#define ISCSI_SPE_FUNC_INIT_COUNTERS_EN_SHIFT   0
+#define ISCSI_SPE_FUNC_INIT_RESERVED0_MASK      0x7F
+#define ISCSI_SPE_FUNC_INIT_RESERVED0_SHIFT     1
         struct iscsi_debug_modes debug_mode;
         __le16 reserved1;
         __le32 reserved2;
-        __le32 reserved3;
-        __le32 reserved4;
         struct scsi_init_func_params func_params;
         struct scsi_init_func_queues q_params;
 };
 
-struct ystorm_iscsi_task_state {
-        struct scsi_cached_sges data_desc;
-        struct scsi_sgl_params sgl_params;
-        __le32 exp_r2t_sn;
-        __le32 buffer_offset;
-        union iscsi_seq_num seq_num;
-        struct iscsi_dif_flags dif_flags;
-        u8 flags;
-#define YSTORM_ISCSI_TASK_STATE_LOCAL_COMP_MASK  0x1
-#define YSTORM_ISCSI_TASK_STATE_LOCAL_COMP_SHIFT 0
-#define YSTORM_ISCSI_TASK_STATE_SLOW_IO_MASK     0x1
-#define YSTORM_ISCSI_TASK_STATE_SLOW_IO_SHIFT    1
-#define YSTORM_ISCSI_TASK_STATE_RESERVED0_MASK   0x3F
-#define YSTORM_ISCSI_TASK_STATE_RESERVED0_SHIFT  2
-};
-
-struct ystorm_iscsi_task_rxmit_opt {
-        __le32 fast_rxmit_sge_offset;
-        __le32 scan_start_buffer_offset;
-        __le32 fast_rxmit_buffer_offset;
-        u8 scan_start_sgl_index;
-        u8 fast_rxmit_sgl_index;
-        __le16 reserved;
-};
-
-struct ystorm_iscsi_task_st_ctx {
-        struct ystorm_iscsi_task_state state;
-        struct ystorm_iscsi_task_rxmit_opt rxmit_opt;
-        union iscsi_task_hdr pdu_hdr;
-};
-
-struct ystorm_iscsi_task_ag_ctx {
-        u8 reserved;
-        u8 byte1;
-        __le16 word0;
-        u8 flags0;
-#define YSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_MASK     0xF
-#define YSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_SHIFT    0
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT0_MASK        0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT0_SHIFT       4
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT1_MASK        0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT       5
-#define YSTORM_ISCSI_TASK_AG_CTX_VALID_MASK       0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_VALID_SHIFT      6
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT3_MASK        0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT3_SHIFT       7
-        u8 flags1;
-#define YSTORM_ISCSI_TASK_AG_CTX_CF0_MASK         0x3
-#define YSTORM_ISCSI_TASK_AG_CTX_CF0_SHIFT        0
-#define YSTORM_ISCSI_TASK_AG_CTX_CF1_MASK         0x3
-#define YSTORM_ISCSI_TASK_AG_CTX_CF1_SHIFT        2
-#define YSTORM_ISCSI_TASK_AG_CTX_CF2SPECIAL_MASK  0x3
-#define YSTORM_ISCSI_TASK_AG_CTX_CF2SPECIAL_SHIFT 4
-#define YSTORM_ISCSI_TASK_AG_CTX_CF0EN_MASK       0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_CF0EN_SHIFT      6
-#define YSTORM_ISCSI_TASK_AG_CTX_CF1EN_MASK       0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_CF1EN_SHIFT      7
-        u8 flags2;
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT4_MASK        0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_BIT4_SHIFT       0
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE0EN_MASK     0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE0EN_SHIFT    1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK     0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT    2
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE2EN_MASK     0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE2EN_SHIFT    3
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK     0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT    4
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK     0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT    5
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK     0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT    6
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE6EN_MASK     0x1
-#define YSTORM_ISCSI_TASK_AG_CTX_RULE6EN_SHIFT    7
-        u8 byte2;
-        __le32 TTT;
-        u8 byte3;
-        u8 byte4;
-        __le16 word1;
-};
-
-struct mstorm_iscsi_task_ag_ctx {
-        u8 cdu_validation;
-        u8 byte1;
-        __le16 task_cid;
-        u8 flags0;
-#define MSTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_MASK     0xF
-#define MSTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_SHIFT    0
-#define MSTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_MASK        0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_SHIFT       4
-#define MSTORM_ISCSI_TASK_AG_CTX_BIT1_MASK                0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT               5
-#define MSTORM_ISCSI_TASK_AG_CTX_VALID_MASK               0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_VALID_SHIFT              6
-#define MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_FLAG_MASK   0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_FLAG_SHIFT  7
-        u8 flags1;
-#define MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_MASK     0x3
-#define MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_SHIFT    0
-#define MSTORM_ISCSI_TASK_AG_CTX_CF1_MASK                 0x3
-#define MSTORM_ISCSI_TASK_AG_CTX_CF1_SHIFT                2
-#define MSTORM_ISCSI_TASK_AG_CTX_CF2_MASK                 0x3
-#define MSTORM_ISCSI_TASK_AG_CTX_CF2_SHIFT                4
-#define MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_EN_MASK  0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_TASK_CLEANUP_CF_EN_SHIFT 6
-#define MSTORM_ISCSI_TASK_AG_CTX_CF1EN_MASK               0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_CF1EN_SHIFT              7
-        u8 flags2;
-#define MSTORM_ISCSI_TASK_AG_CTX_CF2EN_MASK               0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_CF2EN_SHIFT              0
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE0EN_MASK             0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE0EN_SHIFT            1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK             0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT            2
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE2EN_MASK             0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE2EN_SHIFT            3
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK             0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT            4
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK             0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT            5
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK             0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT            6
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE6EN_MASK             0x1
-#define MSTORM_ISCSI_TASK_AG_CTX_RULE6EN_SHIFT            7
-        u8 byte2;
-        __le32 reg0;
-        u8 byte3;
-        u8 byte4;
-        __le16 word1;
-};
-
-struct ustorm_iscsi_task_ag_ctx {
-        u8 reserved;
-        u8 state;
-        __le16 icid;
-        u8 flags0;
-#define USTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_MASK        0xF
-#define USTORM_ISCSI_TASK_AG_CTX_CONNECTION_TYPE_SHIFT       0
-#define USTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_MASK           0x1
-#define USTORM_ISCSI_TASK_AG_CTX_EXIST_IN_QM0_SHIFT          4
-#define USTORM_ISCSI_TASK_AG_CTX_BIT1_MASK                   0x1
-#define USTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT                  5
-#define USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_MASK          0x3
-#define USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_SHIFT         6
-        u8 flags1;
-#define USTORM_ISCSI_TASK_AG_CTX_RESERVED1_MASK              0x3
-#define USTORM_ISCSI_TASK_AG_CTX_RESERVED1_SHIFT             0
-#define USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_MASK               0x3
-#define USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_SHIFT              2
-#define USTORM_ISCSI_TASK_AG_CTX_CF3_MASK                    0x3
-#define USTORM_ISCSI_TASK_AG_CTX_CF3_SHIFT                   4
-#define USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_MASK           0x3
-#define USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_SHIFT          6
-        u8 flags2;
-#define USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_EN_MASK       0x1
-#define USTORM_ISCSI_TASK_AG_CTX_HQ_SCANNED_CF_EN_SHIFT      0
-#define USTORM_ISCSI_TASK_AG_CTX_DISABLE_DATA_ACKED_MASK     0x1
-#define USTORM_ISCSI_TASK_AG_CTX_DISABLE_DATA_ACKED_SHIFT    1
-#define USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_EN_MASK            0x1
-#define USTORM_ISCSI_TASK_AG_CTX_R2T2RECV_EN_SHIFT           2
-#define USTORM_ISCSI_TASK_AG_CTX_CF3EN_MASK                  0x1
-#define USTORM_ISCSI_TASK_AG_CTX_CF3EN_SHIFT                 3
-#define USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_EN_MASK        0x1
-#define USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_CF_EN_SHIFT       4
-#define USTORM_ISCSI_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_MASK  0x1
-#define USTORM_ISCSI_TASK_AG_CTX_CMP_DATA_TOTAL_EXP_EN_SHIFT 5
-#define USTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK                0x1
-#define USTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT               6
-#define USTORM_ISCSI_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_MASK    0x1
-#define USTORM_ISCSI_TASK_AG_CTX_CMP_CONT_RCV_EXP_EN_SHIFT   7
-        u8 flags3;
-#define USTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK                0x1
-#define USTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT               0
-#define USTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK                0x1
-#define USTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT               1
-#define USTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK                0x1
-#define USTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT               2
-#define USTORM_ISCSI_TASK_AG_CTX_RULE6EN_MASK                0x1
-#define USTORM_ISCSI_TASK_AG_CTX_RULE6EN_SHIFT               3
-#define USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_TYPE_MASK         0xF
-#define USTORM_ISCSI_TASK_AG_CTX_DIF_ERROR_TYPE_SHIFT        4
-        __le32 dif_err_intervals;
-        __le32 dif_error_1st_interval;
-        __le32 rcv_cont_len;
-        __le32 exp_cont_len;
-        __le32 total_data_acked;
-        __le32 exp_data_acked;
-        u8 next_tid_valid;
-        u8 byte3;
-        __le16 word1;
-        __le16 next_tid;
-        __le16 word3;
-        __le32 hdr_residual_count;
-        __le32 exp_r2t_sn;
-};
-
-struct mstorm_iscsi_task_st_ctx {
-        struct scsi_cached_sges data_desc;
-        struct scsi_sgl_params sgl_params;
-        __le32 rem_task_size;
-        __le32 data_buffer_offset;
-        u8 task_type;
-        struct iscsi_dif_flags dif_flags;
-        u8 reserved0[2];
-        struct regpair sense_db;
-        __le32 expected_itt;
-        __le32 reserved1;
-};
-
-struct ustorm_iscsi_task_st_ctx {
-        __le32 rem_rcv_len;
-        __le32 exp_data_transfer_len;
-        __le32 exp_data_sn;
-        struct regpair lun;
-        struct iscsi_reg1 reg1;
-        u8 flags2;
-#define USTORM_ISCSI_TASK_ST_CTX_AHS_EXIST_MASK             0x1
-#define USTORM_ISCSI_TASK_ST_CTX_AHS_EXIST_SHIFT            0
-#define USTORM_ISCSI_TASK_ST_CTX_RESERVED1_MASK             0x7F
-#define USTORM_ISCSI_TASK_ST_CTX_RESERVED1_SHIFT            1
-        struct iscsi_dif_flags dif_flags;
-        __le16 reserved3;
-        __le32 reserved4;
-        __le32 reserved5;
-        __le32 reserved6;
-        __le32 reserved7;
-        u8 task_type;
-        u8 error_flags;
-#define USTORM_ISCSI_TASK_ST_CTX_DATA_DIGEST_ERROR_MASK     0x1
-#define USTORM_ISCSI_TASK_ST_CTX_DATA_DIGEST_ERROR_SHIFT    0
-#define USTORM_ISCSI_TASK_ST_CTX_DATA_TRUNCATED_ERROR_MASK  0x1
-#define USTORM_ISCSI_TASK_ST_CTX_DATA_TRUNCATED_ERROR_SHIFT 1
-#define USTORM_ISCSI_TASK_ST_CTX_UNDER_RUN_ERROR_MASK       0x1
-#define USTORM_ISCSI_TASK_ST_CTX_UNDER_RUN_ERROR_SHIFT      2
-#define USTORM_ISCSI_TASK_ST_CTX_RESERVED8_MASK             0x1F
-#define USTORM_ISCSI_TASK_ST_CTX_RESERVED8_SHIFT            3
-        u8 flags;
-#define USTORM_ISCSI_TASK_ST_CTX_CQE_WRITE_MASK             0x3
-#define USTORM_ISCSI_TASK_ST_CTX_CQE_WRITE_SHIFT            0
-#define USTORM_ISCSI_TASK_ST_CTX_LOCAL_COMP_MASK            0x1
-#define USTORM_ISCSI_TASK_ST_CTX_LOCAL_COMP_SHIFT           2
-#define USTORM_ISCSI_TASK_ST_CTX_Q0_R2TQE_WRITE_MASK        0x1
-#define USTORM_ISCSI_TASK_ST_CTX_Q0_R2TQE_WRITE_SHIFT       3
-#define USTORM_ISCSI_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_MASK  0x1
-#define USTORM_ISCSI_TASK_ST_CTX_TOTAL_DATA_ACKED_DONE_SHIFT 4
-#define USTORM_ISCSI_TASK_ST_CTX_HQ_SCANNED_DONE_MASK        0x1
-#define USTORM_ISCSI_TASK_ST_CTX_HQ_SCANNED_DONE_SHIFT       5
-#define USTORM_ISCSI_TASK_ST_CTX_R2T2RECV_DONE_MASK         0x1
-#define USTORM_ISCSI_TASK_ST_CTX_R2T2RECV_DONE_SHIFT        6
-#define USTORM_ISCSI_TASK_ST_CTX_RESERVED0_MASK             0x1
-#define USTORM_ISCSI_TASK_ST_CTX_RESERVED0_SHIFT            7
-        u8 cq_rss_number;
-};
-
-struct iscsi_task_context {
-        struct ystorm_iscsi_task_st_ctx ystorm_st_context;
-        struct ystorm_iscsi_task_ag_ctx ystorm_ag_context;
-        struct regpair ystorm_ag_padding[2];
-        struct tdif_task_context tdif_context;
-        struct mstorm_iscsi_task_ag_ctx mstorm_ag_context;
-        struct regpair mstorm_ag_padding[2];
-        struct ustorm_iscsi_task_ag_ctx ustorm_ag_context;
-        struct mstorm_iscsi_task_st_ctx mstorm_st_context;
-        struct ustorm_iscsi_task_st_ctx ustorm_st_context;
-        struct rdif_task_context rdif_context;
-};
-
+/* iSCSI task type */
 enum iscsi_task_type {
         ISCSI_TASK_TYPE_INITIATOR_WRITE,
         ISCSI_TASK_TYPE_INITIATOR_READ,
@@ -1186,53 +1342,57 @@ enum iscsi_task_type {
         ISCSI_TASK_TYPE_TARGET_READ,
         ISCSI_TASK_TYPE_TARGET_RESPONSE,
         ISCSI_TASK_TYPE_LOGIN_RESPONSE,
+        ISCSI_TASK_TYPE_TARGET_IMM_W_DIF,
         MAX_ISCSI_TASK_TYPE
 };
 
+/* iSCSI DesiredDataTransferLength/ttt union */
 union iscsi_ttt_txlen_union {
         __le32 desired_tx_len;
         __le32 ttt;
 };
 
+/* iSCSI uHQ element */
 struct iscsi_uhqe {
         __le32 reg1;
-#define ISCSI_UHQE_PDU_PAYLOAD_LEN_MASK     0xFFFFF
-#define ISCSI_UHQE_PDU_PAYLOAD_LEN_SHIFT    0
-#define ISCSI_UHQE_LOCAL_COMP_MASK          0x1
-#define ISCSI_UHQE_LOCAL_COMP_SHIFT         20
-#define ISCSI_UHQE_TOGGLE_BIT_MASK          0x1
-#define ISCSI_UHQE_TOGGLE_BIT_SHIFT         21
-#define ISCSI_UHQE_PURE_PAYLOAD_MASK        0x1
-#define ISCSI_UHQE_PURE_PAYLOAD_SHIFT       22
-#define ISCSI_UHQE_LOGIN_RESPONSE_PDU_MASK  0x1
-#define ISCSI_UHQE_LOGIN_RESPONSE_PDU_SHIFT 23
-#define ISCSI_UHQE_TASK_ID_HI_MASK          0xFF
-#define ISCSI_UHQE_TASK_ID_HI_SHIFT         24
+#define ISCSI_UHQE_PDU_PAYLOAD_LEN_MASK         0xFFFFF
+#define ISCSI_UHQE_PDU_PAYLOAD_LEN_SHIFT        0
+#define ISCSI_UHQE_LOCAL_COMP_MASK              0x1
+#define ISCSI_UHQE_LOCAL_COMP_SHIFT             20
+#define ISCSI_UHQE_TOGGLE_BIT_MASK              0x1
+#define ISCSI_UHQE_TOGGLE_BIT_SHIFT             21
+#define ISCSI_UHQE_PURE_PAYLOAD_MASK            0x1
+#define ISCSI_UHQE_PURE_PAYLOAD_SHIFT           22
+#define ISCSI_UHQE_LOGIN_RESPONSE_PDU_MASK      0x1
+#define ISCSI_UHQE_LOGIN_RESPONSE_PDU_SHIFT     23
+#define ISCSI_UHQE_TASK_ID_HI_MASK              0xFF
+#define ISCSI_UHQE_TASK_ID_HI_SHIFT             24
         __le32 reg2;
-#define ISCSI_UHQE_BUFFER_OFFSET_MASK       0xFFFFFF
-#define ISCSI_UHQE_BUFFER_OFFSET_SHIFT      0
-#define ISCSI_UHQE_TASK_ID_LO_MASK          0xFF
-#define ISCSI_UHQE_TASK_ID_LO_SHIFT         24
+#define ISCSI_UHQE_BUFFER_OFFSET_MASK   0xFFFFFF
+#define ISCSI_UHQE_BUFFER_OFFSET_SHIFT  0
+#define ISCSI_UHQE_TASK_ID_LO_MASK      0xFF
+#define ISCSI_UHQE_TASK_ID_LO_SHIFT     24
 };
 
-
+/* iSCSI WQ element */
 struct iscsi_wqe {
         __le16 task_id;
         u8 flags;
-#define ISCSI_WQE_WQE_TYPE_MASK        0x7
-#define ISCSI_WQE_WQE_TYPE_SHIFT       0
-#define ISCSI_WQE_NUM_SGES_MASK  0xF
-#define ISCSI_WQE_NUM_SGES_SHIFT 3
-#define ISCSI_WQE_RESPONSE_MASK        0x1
-#define ISCSI_WQE_RESPONSE_SHIFT       7
+#define ISCSI_WQE_WQE_TYPE_MASK         0x7
+#define ISCSI_WQE_WQE_TYPE_SHIFT        0
+#define ISCSI_WQE_NUM_SGES_MASK         0xF
+#define ISCSI_WQE_NUM_SGES_SHIFT        3
+#define ISCSI_WQE_RESPONSE_MASK         0x1
+#define ISCSI_WQE_RESPONSE_SHIFT        7
         struct iscsi_dif_flags prot_flags;
         __le32 contlen_cdbsize;
-#define ISCSI_WQE_CONT_LEN_MASK  0xFFFFFF
-#define ISCSI_WQE_CONT_LEN_SHIFT 0
-#define ISCSI_WQE_CDB_SIZE_MASK  0xFF
-#define ISCSI_WQE_CDB_SIZE_SHIFT 24
+#define ISCSI_WQE_CONT_LEN_MASK         0xFFFFFF
+#define ISCSI_WQE_CONT_LEN_SHIFT        0
+#define ISCSI_WQE_CDB_SIZE_MASK         0xFF
+#define ISCSI_WQE_CDB_SIZE_SHIFT        24
 };
 
+/* iSCSI wqe type */
 enum iscsi_wqe_type {
         ISCSI_WQE_TYPE_NORMAL,
         ISCSI_WQE_TYPE_TASK_CLEANUP,
@@ -1244,6 +1404,7 @@ enum iscsi_wqe_type {
         MAX_ISCSI_WQE_TYPE
 };
 
+/* iSCSI xHQ element */
 struct iscsi_xhqe {
         union iscsi_ttt_txlen_union ttt_or_txlen;
         __le32 exp_stat_sn;
@@ -1251,120 +1412,134 @@ struct iscsi_xhqe {
         u8 total_ahs_length;
         u8 opcode;
         u8 flags;
-#define ISCSI_XHQE_FINAL_MASK       0x1
-#define ISCSI_XHQE_FINAL_SHIFT      0
-#define ISCSI_XHQE_STATUS_BIT_MASK  0x1
-#define ISCSI_XHQE_STATUS_BIT_SHIFT 1
-#define ISCSI_XHQE_NUM_SGES_MASK    0xF
-#define ISCSI_XHQE_NUM_SGES_SHIFT   2
-#define ISCSI_XHQE_RESERVED0_MASK   0x3
-#define ISCSI_XHQE_RESERVED0_SHIFT  6
+#define ISCSI_XHQE_FINAL_MASK           0x1
+#define ISCSI_XHQE_FINAL_SHIFT          0
+#define ISCSI_XHQE_STATUS_BIT_MASK      0x1
+#define ISCSI_XHQE_STATUS_BIT_SHIFT     1
+#define ISCSI_XHQE_NUM_SGES_MASK        0xF
+#define ISCSI_XHQE_NUM_SGES_SHIFT       2
+#define ISCSI_XHQE_RESERVED0_MASK       0x3
+#define ISCSI_XHQE_RESERVED0_SHIFT      6
         union iscsi_seq_num seq_num;
         __le16 reserved1;
 };
 
+/* Per PF iSCSI receive path statistics - mStorm RAM structure */
 struct mstorm_iscsi_stats_drv {
         struct regpair iscsi_rx_dropped_pdus_task_not_valid;
+        struct regpair iscsi_rx_dup_ack_cnt;
 };
 
+/* Per PF iSCSI transmit path statistics - pStorm RAM structure */
 struct pstorm_iscsi_stats_drv {
         struct regpair iscsi_tx_bytes_cnt;
         struct regpair iscsi_tx_packet_cnt;
 };
 
+/* Per PF iSCSI receive path statistics - tStorm RAM structure */
 struct tstorm_iscsi_stats_drv {
         struct regpair iscsi_rx_bytes_cnt;
         struct regpair iscsi_rx_packet_cnt;
         struct regpair iscsi_rx_new_ooo_isle_events_cnt;
+        struct regpair iscsi_rx_tcp_payload_bytes_cnt;
+        struct regpair iscsi_rx_tcp_pkt_cnt;
+        struct regpair iscsi_rx_pure_ack_cnt;
         __le32 iscsi_cmdq_threshold_cnt;
         __le32 iscsi_rq_threshold_cnt;
         __le32 iscsi_immq_threshold_cnt;
 };
 
+/* Per PF iSCSI receive path statistics - uStorm RAM structure */
 struct ustorm_iscsi_stats_drv {
         struct regpair iscsi_rx_data_pdu_cnt;
         struct regpair iscsi_rx_r2t_pdu_cnt;
         struct regpair iscsi_rx_total_pdu_cnt;
 };
 
+/* Per PF iSCSI transmit path statistics - xStorm RAM structure */
 struct xstorm_iscsi_stats_drv {
         struct regpair iscsi_tx_go_to_slow_start_event_cnt;
         struct regpair iscsi_tx_fast_retransmit_event_cnt;
+        struct regpair iscsi_tx_pure_ack_cnt;
+        struct regpair iscsi_tx_delayed_ack_cnt;
 };
 
+/* Per PF iSCSI transmit path statistics - yStorm RAM structure */
 struct ystorm_iscsi_stats_drv {
         struct regpair iscsi_tx_data_pdu_cnt;
         struct regpair iscsi_tx_r2t_pdu_cnt;
         struct regpair iscsi_tx_total_pdu_cnt;
+        struct regpair iscsi_tx_tcp_payload_bytes_cnt;
+        struct regpair iscsi_tx_tcp_pkt_cnt;
 };
 
-struct tstorm_iscsi_task_ag_ctx {
+struct e4_tstorm_iscsi_task_ag_ctx {
         u8 byte0;
         u8 byte1;
         __le16 word0;
         u8 flags0;
-#define TSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_MASK  0xF
-#define TSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_SHIFT 0
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT0_MASK     0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT0_SHIFT    4
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT1_MASK     0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT    5
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT2_MASK     0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT2_SHIFT    6
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT3_MASK     0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT3_SHIFT    7
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_MASK        0xF
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_NIBBLE0_SHIFT       0
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT0_MASK           0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT0_SHIFT          4
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT1_MASK           0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT1_SHIFT          5
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT2_MASK           0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT2_SHIFT          6
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT3_MASK           0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT3_SHIFT          7
         u8 flags1;
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT4_MASK     0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT4_SHIFT    0
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT5_MASK     0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_BIT5_SHIFT    1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF0_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF0_SHIFT     2
-#define TSTORM_ISCSI_TASK_AG_CTX_CF1_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF1_SHIFT     4
-#define TSTORM_ISCSI_TASK_AG_CTX_CF2_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF2_SHIFT     6
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT4_MASK   0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT4_SHIFT  0
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT5_MASK   0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_BIT5_SHIFT  1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF0_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF0_SHIFT   2
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF1_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF1_SHIFT   4
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF2_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF2_SHIFT   6
         u8 flags2;
-#define TSTORM_ISCSI_TASK_AG_CTX_CF3_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF3_SHIFT     0
-#define TSTORM_ISCSI_TASK_AG_CTX_CF4_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF4_SHIFT     2
-#define TSTORM_ISCSI_TASK_AG_CTX_CF5_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF5_SHIFT     4
-#define TSTORM_ISCSI_TASK_AG_CTX_CF6_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF6_SHIFT     6
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF3_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF3_SHIFT   0
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF4_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF4_SHIFT   2
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF5_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF5_SHIFT   4
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF6_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF6_SHIFT   6
         u8 flags3;
-#define TSTORM_ISCSI_TASK_AG_CTX_CF7_MASK      0x3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF7_SHIFT     0
-#define TSTORM_ISCSI_TASK_AG_CTX_CF0EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF0EN_SHIFT   2
-#define TSTORM_ISCSI_TASK_AG_CTX_CF1EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF1EN_SHIFT   3
-#define TSTORM_ISCSI_TASK_AG_CTX_CF2EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF2EN_SHIFT   4
-#define TSTORM_ISCSI_TASK_AG_CTX_CF3EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF3EN_SHIFT   5
-#define TSTORM_ISCSI_TASK_AG_CTX_CF4EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF4EN_SHIFT   6
-#define TSTORM_ISCSI_TASK_AG_CTX_CF5EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF5EN_SHIFT   7
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF7_MASK    0x3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF7_SHIFT   0
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF0EN_MASK  0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF0EN_SHIFT 2
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF1EN_MASK  0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF1EN_SHIFT 3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF2EN_MASK  0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF2EN_SHIFT 4
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF3EN_MASK  0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF3EN_SHIFT 5
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF4EN_MASK  0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF4EN_SHIFT 6
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF5EN_MASK  0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF5EN_SHIFT 7
         u8 flags4;
-#define TSTORM_ISCSI_TASK_AG_CTX_CF6EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF6EN_SHIFT   0
-#define TSTORM_ISCSI_TASK_AG_CTX_CF7EN_MASK    0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_CF7EN_SHIFT   1
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE0EN_MASK  0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE0EN_SHIFT 2
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK  0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT 3
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE2EN_MASK  0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE2EN_SHIFT 4
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK  0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT 5
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK  0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT 6
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK  0x1
-#define TSTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT 7
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF6EN_MASK          0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF6EN_SHIFT         0
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF7EN_MASK          0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_CF7EN_SHIFT         1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE0EN_MASK        0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE0EN_SHIFT       2
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE1EN_MASK        0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE1EN_SHIFT       3
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE2EN_MASK        0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE2EN_SHIFT       4
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE3EN_MASK        0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE3EN_SHIFT       5
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE4EN_MASK        0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE4EN_SHIFT       6
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE5EN_MASK        0x1
+#define E4_TSTORM_ISCSI_TASK_AG_CTX_RULE5EN_SHIFT       7
         u8 byte2;
         __le16 word1;
         __le32 reg0;
@@ -1376,18 +1551,20 @@ struct tstorm_iscsi_task_ag_ctx {
         __le32 reg1;
         __le32 reg2;
 };
+
+/* iSCSI doorbell data */
 struct iscsi_db_data {
         u8 params;
-#define ISCSI_DB_DATA_DEST_MASK         0x3
-#define ISCSI_DB_DATA_DEST_SHIFT        0
-#define ISCSI_DB_DATA_AGG_CMD_MASK      0x3
-#define ISCSI_DB_DATA_AGG_CMD_SHIFT     2
-#define ISCSI_DB_DATA_BYPASS_EN_MASK    0x1
-#define ISCSI_DB_DATA_BYPASS_EN_SHIFT   4
-#define ISCSI_DB_DATA_RESERVED_MASK     0x1
-#define ISCSI_DB_DATA_RESERVED_SHIFT    5
-#define ISCSI_DB_DATA_AGG_VAL_SEL_MASK  0x3
-#define ISCSI_DB_DATA_AGG_VAL_SEL_SHIFT 6
+#define ISCSI_DB_DATA_DEST_MASK         0x3
+#define ISCSI_DB_DATA_DEST_SHIFT        0
+#define ISCSI_DB_DATA_AGG_CMD_MASK      0x3
+#define ISCSI_DB_DATA_AGG_CMD_SHIFT     2
+#define ISCSI_DB_DATA_BYPASS_EN_MASK    0x1
+#define ISCSI_DB_DATA_BYPASS_EN_SHIFT   4
+#define ISCSI_DB_DATA_RESERVED_MASK     0x1
+#define ISCSI_DB_DATA_RESERVED_SHIFT    5
+#define ISCSI_DB_DATA_AGG_VAL_SEL_MASK  0x3
+#define ISCSI_DB_DATA_AGG_VAL_SEL_SHIFT 6
         u8 agg_flags;
         __le16 sq_prod;
 };
diff --git a/include/linux/qed/iwarp_common.h b/include/linux/qed/iwarp_common.h
index b8b3e1cfae90..c6cfd39cd910 100644
--- a/include/linux/qed/iwarp_common.h
+++ b/include/linux/qed/iwarp_common.h
@@ -29,9 +29,12 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+
 #ifndef __IWARP_COMMON__
 #define __IWARP_COMMON__
+
 #include <linux/qed/rdma_common.h>
+
 /************************/
 /* IWARP FW CONSTANTS   */
 /************************/
@@ -40,14 +43,14 @@
 #define IWARP_PASSIVE_MODE 1
 
 #define IWARP_SHARED_QUEUE_PAGE_SIZE            (0x8000)
-#define IWARP_SHARED_QUEUE_PAGE_RQ_PBL_OFFSET   (0x4000)
-#define IWARP_SHARED_QUEUE_PAGE_RQ_PBL_MAX_SIZE (0x1000)
-#define IWARP_SHARED_QUEUE_PAGE_SQ_PBL_OFFSET   (0x5000)
-#define IWARP_SHARED_QUEUE_PAGE_SQ_PBL_MAX_SIZE (0x3000)
+#define IWARP_SHARED_QUEUE_PAGE_RQ_PBL_OFFSET   (0x4000)
+#define IWARP_SHARED_QUEUE_PAGE_RQ_PBL_MAX_SIZE (0x1000)
+#define IWARP_SHARED_QUEUE_PAGE_SQ_PBL_OFFSET   (0x5000)
+#define IWARP_SHARED_QUEUE_PAGE_SQ_PBL_MAX_SIZE (0x3000)
 
-#define IWARP_REQ_MAX_INLINE_DATA_SIZE          (128)
-#define IWARP_REQ_MAX_SINGLE_SQ_WQE_SIZE        (176)
+#define IWARP_REQ_MAX_INLINE_DATA_SIZE          (128)
+#define IWARP_REQ_MAX_SINGLE_SQ_WQE_SIZE        (176)
 
-#define IWARP_MAX_QPS                           (64 * 1024)
+#define IWARP_MAX_QPS                           (64 * 1024)
 
 #endif /* __IWARP_COMMON__ */
diff --git a/include/linux/qed/qed_eth_if.h b/include/linux/qed/qed_eth_if.h
index d60de4a39810..147d08ccf813 100644
--- a/include/linux/qed/qed_eth_if.h
+++ b/include/linux/qed/qed_eth_if.h
@@ -61,6 +61,35 @@ struct qed_txq_start_ret_params {
         void *p_handle;
 };
 
+enum qed_filter_config_mode {
+        QED_FILTER_CONFIG_MODE_DISABLE,
+        QED_FILTER_CONFIG_MODE_5_TUPLE,
+        QED_FILTER_CONFIG_MODE_L4_PORT,
+        QED_FILTER_CONFIG_MODE_IP_DEST,
+};
+
+struct qed_ntuple_filter_params {
+        /* Physically mapped address containing header of buffer to be used
+         * as filter.
+         */
+        dma_addr_t addr;
+
+        /* Length of header in bytes */
+        u16 length;
+
+        /* Relative queue-id to receive classified packet */
+#define QED_RFS_NTUPLE_QID_RSS ((u16)-1)
+        u16 qid;
+
+        /* Identifier can either be according to vport-id or vfid */
+        bool b_is_vf;
+        u8 vport_id;
+        u8 vf_id;
+
+        /* true iff this filter is to be added. Else to be removed */
+        bool b_is_add;
+};
+
 struct qed_dev_eth_info {
         struct qed_dev_info common;
 
@@ -316,13 +345,12 @@ struct qed_eth_ops {
         int (*tunn_config)(struct qed_dev *cdev,
                            struct qed_tunn_params *params);
 
-        int (*ntuple_filter_config)(struct qed_dev *cdev, void *cookie,
-                                    dma_addr_t mapping, u16 length,
-                                    u16 vport_id, u16 rx_queue_id,
-                                    bool add_filter);
+        int (*ntuple_filter_config)(struct qed_dev *cdev,
+                                    void *cookie,
+                                    struct qed_ntuple_filter_params *params);
 
         int (*configure_arfs_searcher)(struct qed_dev *cdev,
-                                       bool en_searcher);
+                                       enum qed_filter_config_mode mode);
         int (*get_coalesce)(struct qed_dev *cdev, u16 *coal, void *handle);
 };
 
diff --git a/include/linux/qed/qed_if.h b/include/linux/qed/qed_if.h
index cc646ca97974..15e398c7230e 100644
--- a/include/linux/qed/qed_if.h
+++ b/include/linux/qed/qed_if.h
@@ -244,16 +244,11 @@ struct qed_fcoe_pf_params {
 /* Most of the the parameters below are described in the FW iSCSI / TCP HSI */
 struct qed_iscsi_pf_params {
         u64 glbl_q_params_addr;
-        u64 bdq_pbl_base_addr[2];
-        u32 max_cwnd;
+        u64 bdq_pbl_base_addr[3];
         u16 cq_num_entries;
         u16 cmdq_num_entries;
         u32 two_msl_timer;
-        u16 dup_ack_threshold;
         u16 tx_sws_timer;
-        u16 min_rto;
-        u16 min_rto_rt;
-        u16 max_rto;
 
         /* The following parameters are used during HW-init
          * and these parameters need to be passed as arguments
@@ -264,8 +259,8 @@ struct qed_iscsi_pf_params {
 
         /* The following parameters are used during protocol-init */
         u16 half_way_close_timeout;
-        u16 bdq_xoff_threshold[2];
-        u16 bdq_xon_threshold[2];
+        u16 bdq_xoff_threshold[3];
+        u16 bdq_xon_threshold[3];
         u16 cmdq_xoff_threshold;
         u16 cmdq_xon_threshold;
         u16 rq_buffer_size;
@@ -281,10 +276,11 @@ struct qed_iscsi_pf_params {
         u8 gl_cmd_pi;
         u8 debug_mode;
         u8 ll2_ooo_queue_id;
-        u8 ooo_enable;
 
         u8 is_target;
-        u8 bdq_pbl_num_entries[2];
+        u8 is_soc_en;
+        u8 soc_num_of_blocks_log;
+        u8 bdq_pbl_num_entries[3];
 };
 
 struct qed_rdma_pf_params {
@@ -316,16 +312,16 @@ enum qed_int_mode {
 };
 
 struct qed_sb_info {
-        struct status_block     *sb_virt;
-        dma_addr_t              sb_phys;
-        u32                     sb_ack; /* Last given ack */
-        u16                     igu_sb_id;
-        void __iomem            *igu_addr;
-        u8                      flags;
-#define QED_SB_INFO_INIT        0x1
-#define QED_SB_INFO_SETUP       0x2
+        struct status_block_e4 *sb_virt;
+        dma_addr_t sb_phys;
+        u32 sb_ack; /* Last given ack */
+        u16 igu_sb_id;
+        void __iomem *igu_addr;
+        u8 flags;
+#define QED_SB_INFO_INIT        0x1
+#define QED_SB_INFO_SETUP       0x2
 
-        struct qed_dev          *cdev;
+        struct qed_dev *cdev;
 };
 
 enum qed_dev_type {
@@ -939,7 +935,7 @@ static inline u16 qed_sb_update_sb_idx(struct qed_sb_info *sb_info)
         u16 rc = 0;
 
         prod = le32_to_cpu(sb_info->sb_virt->prod_index) &
-               STATUS_BLOCK_PROD_INDEX_MASK;
+               STATUS_BLOCK_E4_PROD_INDEX_MASK;
         if (sb_info->sb_ack != prod) {
                 sb_info->sb_ack = prod;
                 rc |= QED_SB_IDX;
diff --git a/include/linux/qed/qed_iscsi_if.h b/include/linux/qed/qed_iscsi_if.h
index 111e606a74c8..d0df1bec5357 100644
--- a/include/linux/qed/qed_iscsi_if.h
+++ b/include/linux/qed/qed_iscsi_if.h
@@ -102,7 +102,6 @@ struct qed_iscsi_params_offload {
         u32 ss_thresh;
         u16 srtt;
         u16 rtt_var;
-        u32 ts_time;
         u32 ts_recent;
         u32 ts_recent_age;
         u32 total_rt;
@@ -124,7 +123,6 @@ struct qed_iscsi_params_offload {
         u16 mss;
         u8 snd_wnd_scale;
         u8 rcv_wnd_scale;
-        u32 ts_ticks_per_second;
         u16 da_timeout_value;
         u8 ack_frequency;
 };
diff --git a/include/linux/qed/qed_ll2_if.h b/include/linux/qed/qed_ll2_if.h
index e755954d85fd..266c1fb45387 100644
--- a/include/linux/qed/qed_ll2_if.h
+++ b/include/linux/qed/qed_ll2_if.h
@@ -116,7 +116,7 @@ struct qed_ll2_comp_rx_data {
         u32 opaque_data_1;
 
         /* GSI only */
-        u32 gid_dst[4];
+        u32 src_qp;
         u16 qp_id;
 
         union {
diff --git a/include/linux/qed/rdma_common.h b/include/linux/qed/rdma_common.h
index a9b3050f469c..c1a446ebe362 100644
--- a/include/linux/qed/rdma_common.h
+++ b/include/linux/qed/rdma_common.h
@@ -32,28 +32,29 @@
 
 #ifndef __RDMA_COMMON__
 #define __RDMA_COMMON__
+
 /************************/
 /* RDMA FW CONSTANTS */
 /************************/
 
-#define RDMA_RESERVED_LKEY                      (0)
-#define RDMA_RING_PAGE_SIZE                     (0x1000)
+#define RDMA_RESERVED_LKEY              (0)
+#define RDMA_RING_PAGE_SIZE             (0x1000)
 
-#define RDMA_MAX_SGE_PER_SQ_WQE         (4)
-#define RDMA_MAX_SGE_PER_RQ_WQE         (4)
+#define RDMA_MAX_SGE_PER_SQ_WQE         (4)
+#define RDMA_MAX_SGE_PER_RQ_WQE         (4)
 
 #define RDMA_MAX_DATA_SIZE_IN_WQE       (0x80000000)
 
-#define RDMA_REQ_RD_ATOMIC_ELM_SIZE             (0x50)
-#define RDMA_RESP_RD_ATOMIC_ELM_SIZE    (0x20)
+#define RDMA_REQ_RD_ATOMIC_ELM_SIZE     (0x50)
+#define RDMA_RESP_RD_ATOMIC_ELM_SIZE    (0x20)
 
-#define RDMA_MAX_CQS                            (64 * 1024)
-#define RDMA_MAX_TIDS                           (128 * 1024 - 1)
-#define RDMA_MAX_PDS                            (64 * 1024)
+#define RDMA_MAX_CQS                    (64 * 1024)
+#define RDMA_MAX_TIDS                   (128 * 1024 - 1)
+#define RDMA_MAX_PDS                    (64 * 1024)
 
-#define RDMA_NUM_STATISTIC_COUNTERS                     MAX_NUM_VPORTS
-#define RDMA_NUM_STATISTIC_COUNTERS_K2                  MAX_NUM_VPORTS_K2
-#define RDMA_NUM_STATISTIC_COUNTERS_BB                  MAX_NUM_VPORTS_BB
+#define RDMA_NUM_STATISTIC_COUNTERS     MAX_NUM_VPORTS
+#define RDMA_NUM_STATISTIC_COUNTERS_K2  MAX_NUM_VPORTS_K2
+#define RDMA_NUM_STATISTIC_COUNTERS_BB  MAX_NUM_VPORTS_BB
 
 #define RDMA_TASK_TYPE (PROTOCOLID_ROCE)
 
diff --git a/include/linux/qed/roce_common.h b/include/linux/qed/roce_common.h
index fe6a33e45977..e15e0da71240 100644
--- a/include/linux/qed/roce_common.h
+++ b/include/linux/qed/roce_common.h
@@ -33,13 +33,18 @@
 #ifndef __ROCE_COMMON__
 #define __ROCE_COMMON__
 
-#define ROCE_REQ_MAX_INLINE_DATA_SIZE (256)
-#define ROCE_REQ_MAX_SINGLE_SQ_WQE_SIZE (288)
+/************************/
+/* ROCE FW CONSTANTS */
+/************************/
 
-#define ROCE_MAX_QPS    (32 * 1024)
-#define ROCE_DCQCN_NP_MAX_QPS   (64)
-#define ROCE_DCQCN_RP_MAX_QPS   (64)
+#define ROCE_REQ_MAX_INLINE_DATA_SIZE   (256)
+#define ROCE_REQ_MAX_SINGLE_SQ_WQE_SIZE (288)
 
+#define ROCE_MAX_QPS                    (32 * 1024)
+#define ROCE_DCQCN_NP_MAX_QPS           (64)
+#define ROCE_DCQCN_RP_MAX_QPS           (64)
+
+/* Affiliated asynchronous events / errors enumeration */
 enum roce_async_events_type {
         ROCE_ASYNC_EVENT_NONE = 0,
         ROCE_ASYNC_EVENT_COMM_EST = 1,
diff --git a/include/linux/qed/storage_common.h b/include/linux/qed/storage_common.h
index 08df82a096b6..505c0b48a761 100644
--- a/include/linux/qed/storage_common.h
+++ b/include/linux/qed/storage_common.h
@@ -33,43 +33,77 @@
 #ifndef __STORAGE_COMMON__
 #define __STORAGE_COMMON__
 
-#define NUM_OF_CMDQS_CQS (NUM_OF_GLOBAL_QUEUES / 2)
-#define BDQ_NUM_RESOURCES (4)
-
-#define BDQ_ID_RQ                        (0)
-#define BDQ_ID_IMM_DATA          (1)
-#define BDQ_NUM_IDS          (2)
-
-#define SCSI_NUM_SGES_SLOW_SGL_THR      8
+/*********************/
+/* SCSI CONSTANTS */
+/*********************/
+
+#define SCSI_MAX_NUM_OF_CMDQS           (NUM_OF_GLOBAL_QUEUES / 2)
+#define BDQ_NUM_RESOURCES               (4)
+
+#define BDQ_ID_RQ                       (0)
+#define BDQ_ID_IMM_DATA                 (1)
+#define BDQ_ID_TQ                       (2)
+#define BDQ_NUM_IDS                     (3)
+
+#define SCSI_NUM_SGES_SLOW_SGL_THR      8
+
+#define BDQ_MAX_EXTERNAL_RING_SIZE      BIT(15)
+
+/* SCSI op codes */
+#define SCSI_OPCODE_COMPARE_AND_WRITE   (0x89)
+#define SCSI_OPCODE_READ_10             (0x28)
+#define SCSI_OPCODE_WRITE_6             (0x0A)
+#define SCSI_OPCODE_WRITE_10            (0x2A)
+#define SCSI_OPCODE_WRITE_12            (0xAA)
+#define SCSI_OPCODE_WRITE_16            (0x8A)
+#define SCSI_OPCODE_WRITE_AND_VERIFY_10 (0x2E)
+#define SCSI_OPCODE_WRITE_AND_VERIFY_12 (0xAE)
+#define SCSI_OPCODE_WRITE_AND_VERIFY_16 (0x8E)
+
+/* iSCSI Drv opaque */
+struct iscsi_drv_opaque {
+        __le16 reserved_zero[3];
+        __le16 opaque;
+};
 
-#define BDQ_MAX_EXTERNAL_RING_SIZE (1 << 15)
+/* Scsi 2B/8B opaque union */
+union scsi_opaque {
+        struct regpair fcoe_opaque;
+        struct iscsi_drv_opaque iscsi_opaque;
+};
 
+/* SCSI buffer descriptor */
 struct scsi_bd {
         struct regpair address;
-        struct regpair opaque;
+        union scsi_opaque opaque;
 };
 
+/* Scsi Drv BDQ struct */
 struct scsi_bdq_ram_drv_data {
         __le16 external_producer;
         __le16 reserved0[3];
 };
 
+/* SCSI SGE entry */
 struct scsi_sge {
         struct regpair sge_addr;
         __le32 sge_len;
         __le32 reserved;
 };
 
+/* Cached SGEs section */
 struct scsi_cached_sges {
         struct scsi_sge sge[4];
 };
 
+/* Scsi Drv CMDQ struct */
 struct scsi_drv_cmdq {
         __le16 cmdq_cons;
         __le16 reserved0;
         __le32 reserved1;
 };
 
+/* Common SCSI init params passed by driver to FW in function init ramrod */
 struct scsi_init_func_params {
         __le16 num_tasks;
         u8 log_page_size;
@@ -77,6 +111,7 @@ struct scsi_init_func_params {
         u8 reserved2[12];
 };
 
+/* SCSI RQ/CQ/CMDQ firmware function init parameters */
 struct scsi_init_func_queues {
         struct regpair glbl_q_params_addr;
         __le16 rq_buffer_size;
@@ -84,39 +119,45 @@ struct scsi_init_func_queues {
         __le16 cmdq_num_entries;
         u8 bdq_resource_id;
         u8 q_validity;
-#define SCSI_INIT_FUNC_QUEUES_RQ_VALID_MASK        0x1
-#define SCSI_INIT_FUNC_QUEUES_RQ_VALID_SHIFT       0
-#define SCSI_INIT_FUNC_QUEUES_IMM_DATA_VALID_MASK  0x1
-#define SCSI_INIT_FUNC_QUEUES_IMM_DATA_VALID_SHIFT 1
-#define SCSI_INIT_FUNC_QUEUES_CMD_VALID_MASK       0x1
-#define SCSI_INIT_FUNC_QUEUES_CMD_VALID_SHIFT      2
-#define SCSI_INIT_FUNC_QUEUES_RESERVED_VALID_MASK  0x1F
-#define SCSI_INIT_FUNC_QUEUES_RESERVED_VALID_SHIFT 3
+#define SCSI_INIT_FUNC_QUEUES_RQ_VALID_MASK                     0x1
+#define SCSI_INIT_FUNC_QUEUES_RQ_VALID_SHIFT                    0
+#define SCSI_INIT_FUNC_QUEUES_IMM_DATA_VALID_MASK               0x1
+#define SCSI_INIT_FUNC_QUEUES_IMM_DATA_VALID_SHIFT              1
+#define SCSI_INIT_FUNC_QUEUES_CMD_VALID_MASK                    0x1
+#define SCSI_INIT_FUNC_QUEUES_CMD_VALID_SHIFT                   2
+#define SCSI_INIT_FUNC_QUEUES_TQ_VALID_MASK                     0x1
+#define SCSI_INIT_FUNC_QUEUES_TQ_VALID_SHIFT                    3
+#define SCSI_INIT_FUNC_QUEUES_SOC_EN_MASK                       0x1
+#define SCSI_INIT_FUNC_QUEUES_SOC_EN_SHIFT                      4
+#define SCSI_INIT_FUNC_QUEUES_SOC_NUM_OF_BLOCKS_LOG_MASK        0x7
+#define SCSI_INIT_FUNC_QUEUES_SOC_NUM_OF_BLOCKS_LOG_SHIFT       5
+        __le16 cq_cmdq_sb_num_arr[SCSI_MAX_NUM_OF_CMDQS];
         u8 num_queues;
         u8 queue_relative_offset;
         u8 cq_sb_pi;
         u8 cmdq_sb_pi;
-        __le16 cq_cmdq_sb_num_arr[NUM_OF_CMDQS_CQS];
-        __le16 reserved0;
         u8 bdq_pbl_num_entries[BDQ_NUM_IDS];
+        u8 reserved1;
         struct regpair bdq_pbl_base_address[BDQ_NUM_IDS];
         __le16 bdq_xoff_threshold[BDQ_NUM_IDS];
-        __le16 bdq_xon_threshold[BDQ_NUM_IDS];
         __le16 cmdq_xoff_threshold;
+        __le16 bdq_xon_threshold[BDQ_NUM_IDS];
         __le16 cmdq_xon_threshold;
-        __le32 reserved1;
 };
 
+/* Scsi Drv BDQ Data struct (2 BDQ IDs: 0 - RQ, 1 - Immediate Data) */
 struct scsi_ram_per_bdq_resource_drv_data {
         struct scsi_bdq_ram_drv_data drv_data_per_bdq_id[BDQ_NUM_IDS];
 };
 
+/* SCSI SGL types */
 enum scsi_sgl_mode {
         SCSI_TX_SLOW_SGL,
         SCSI_FAST_SGL,
         MAX_SCSI_SGL_MODE
 };
 
+/* SCSI SGL parameters */
 struct scsi_sgl_params {
         struct regpair sgl_addr;
         __le32 sgl_total_length;
@@ -126,10 +167,16 @@ struct scsi_sgl_params {
         u8 reserved;
 };
 
+/* SCSI terminate connection params */
 struct scsi_terminate_extra_params {
         __le16 unsolicited_cq_count;
         __le16 cmdq_count;
         u8 reserved[4];
 };
 
+/* SCSI Task Queue Element */
+struct scsi_tqe {
+        __le16 itid;
+};
+
 #endif /* __STORAGE_COMMON__ */
diff --git a/include/linux/qed/tcp_common.h b/include/linux/qed/tcp_common.h
index dbf7a43c3e1f..4a4845193539 100644
--- a/include/linux/qed/tcp_common.h
+++ b/include/linux/qed/tcp_common.h
@@ -33,8 +33,13 @@
 #ifndef __TCP_COMMON__
 #define __TCP_COMMON__
 
-#define TCP_INVALID_TIMEOUT_VAL -1
+/********************/
+/* TCP FW CONSTANTS */
+/********************/
 
+#define TCP_INVALID_TIMEOUT_VAL -1
+
+/* OOO opaque data received from LL2 */
 struct ooo_opaque {
         __le32 cid;
         u8 drop_isle;
@@ -43,25 +48,29 @@ struct ooo_opaque {
         u8 ooo_isle;
 };
 
+/* tcp connect mode enum */
 enum tcp_connect_mode {
         TCP_CONNECT_ACTIVE,
         TCP_CONNECT_PASSIVE,
         MAX_TCP_CONNECT_MODE
 };
 
+/* tcp function init parameters */
 struct tcp_init_params {
         __le32 two_msl_timer;
         __le16 tx_sws_timer;
-        u8 maxfinrt;
+        u8 max_fin_rt;
         u8 reserved[9];
 };
 
+/* tcp IPv4/IPv6 enum */
 enum tcp_ip_version {
         TCP_IPV4,
         TCP_IPV6,
         MAX_TCP_IP_VERSION
 };
 
+/* tcp offload parameters */
 struct tcp_offload_params {
         __le16 local_mac_addr_lo;
         __le16 local_mac_addr_mid;
@@ -70,24 +79,29 @@ struct tcp_offload_params {
         __le16 remote_mac_addr_mid;
         __le16 remote_mac_addr_hi;
         __le16 vlan_id;
-        u8 flags;
-#define TCP_OFFLOAD_PARAMS_TS_EN_MASK         0x1
-#define TCP_OFFLOAD_PARAMS_TS_EN_SHIFT        0
-#define TCP_OFFLOAD_PARAMS_DA_EN_MASK         0x1
-#define TCP_OFFLOAD_PARAMS_DA_EN_SHIFT        1
-#define TCP_OFFLOAD_PARAMS_KA_EN_MASK         0x1
-#define TCP_OFFLOAD_PARAMS_KA_EN_SHIFT        2
-#define TCP_OFFLOAD_PARAMS_NAGLE_EN_MASK      0x1
-#define TCP_OFFLOAD_PARAMS_NAGLE_EN_SHIFT     3
-#define TCP_OFFLOAD_PARAMS_DA_CNT_EN_MASK     0x1
-#define TCP_OFFLOAD_PARAMS_DA_CNT_EN_SHIFT    4
-#define TCP_OFFLOAD_PARAMS_FIN_SENT_MASK      0x1
-#define TCP_OFFLOAD_PARAMS_FIN_SENT_SHIFT     5
-#define TCP_OFFLOAD_PARAMS_FIN_RECEIVED_MASK  0x1
-#define TCP_OFFLOAD_PARAMS_FIN_RECEIVED_SHIFT 6
-#define TCP_OFFLOAD_PARAMS_RESERVED0_MASK     0x1
-#define TCP_OFFLOAD_PARAMS_RESERVED0_SHIFT    7
+        __le16 flags;
+#define TCP_OFFLOAD_PARAMS_TS_EN_MASK                   0x1
+#define TCP_OFFLOAD_PARAMS_TS_EN_SHIFT                  0
+#define TCP_OFFLOAD_PARAMS_DA_EN_MASK                   0x1
+#define TCP_OFFLOAD_PARAMS_DA_EN_SHIFT                  1
+#define TCP_OFFLOAD_PARAMS_KA_EN_MASK                   0x1
+#define TCP_OFFLOAD_PARAMS_KA_EN_SHIFT                  2
+#define TCP_OFFLOAD_PARAMS_ECN_SENDER_EN_MASK           0x1
+#define TCP_OFFLOAD_PARAMS_ECN_SENDER_EN_SHIFT          3
+#define TCP_OFFLOAD_PARAMS_ECN_RECEIVER_EN_MASK         0x1
+#define TCP_OFFLOAD_PARAMS_ECN_RECEIVER_EN_SHIFT        4
+#define TCP_OFFLOAD_PARAMS_NAGLE_EN_MASK                0x1
+#define TCP_OFFLOAD_PARAMS_NAGLE_EN_SHIFT               5
+#define TCP_OFFLOAD_PARAMS_DA_CNT_EN_MASK               0x1
+#define TCP_OFFLOAD_PARAMS_DA_CNT_EN_SHIFT              6
+#define TCP_OFFLOAD_PARAMS_FIN_SENT_MASK                0x1
+#define TCP_OFFLOAD_PARAMS_FIN_SENT_SHIFT               7
+#define TCP_OFFLOAD_PARAMS_FIN_RECEIVED_MASK            0x1
+#define TCP_OFFLOAD_PARAMS_FIN_RECEIVED_SHIFT           8
+#define TCP_OFFLOAD_PARAMS_RESERVED_MASK                0x7F
+#define TCP_OFFLOAD_PARAMS_RESERVED_SHIFT               9
         u8 ip_version;
+        u8 reserved0[3];
         __le32 remote_ip[4];
         __le32 local_ip[4];
         __le32 flow_label;
@@ -99,17 +113,21 @@ struct tcp_offload_params {
         u8 rcv_wnd_scale;
         u8 connect_mode;
         __le16 srtt;
-        __le32 cwnd;
         __le32 ss_thresh;
-        __le16 reserved1;
+        __le32 rcv_wnd;
+        __le32 cwnd;
         u8 ka_max_probe_cnt;
         u8 dup_ack_theshold;
+        __le16 reserved1;
+        __le32 ka_timeout;
+        __le32 ka_interval;
+        __le32 max_rt_time;
+        __le32 initial_rcv_wnd;
         __le32 rcv_next;
         __le32 snd_una;
         __le32 snd_next;
         __le32 snd_max;
         __le32 snd_wnd;
-        __le32 rcv_wnd;
         __le32 snd_wl1;
         __le32 ts_recent;
         __le32 ts_recent_age;
@@ -122,16 +140,13 @@ struct tcp_offload_params {
         u8 rt_cnt;
         __le16 rtt_var;
         __le16 fw_internal;
-        __le32 ka_timeout;
-        __le32 ka_interval;
-        __le32 max_rt_time;
-        __le32 initial_rcv_wnd;
         u8 snd_wnd_scale;
         u8 ack_frequency;
         __le16 da_timeout_value;
-        __le32 reserved3[2];
+        __le32 reserved3;
 };
 
+/* tcp offload parameters */
 struct tcp_offload_params_opt2 {
         __le16 local_mac_addr_lo;
         __le16 local_mac_addr_mid;
@@ -140,16 +155,19 @@ struct tcp_offload_params_opt2 {
         __le16 remote_mac_addr_mid;
         __le16 remote_mac_addr_hi;
         __le16 vlan_id;
-        u8 flags;
-#define TCP_OFFLOAD_PARAMS_OPT2_TS_EN_MASK      0x1
-#define TCP_OFFLOAD_PARAMS_OPT2_TS_EN_SHIFT     0
-#define TCP_OFFLOAD_PARAMS_OPT2_DA_EN_MASK      0x1
-#define TCP_OFFLOAD_PARAMS_OPT2_DA_EN_SHIFT     1
-#define TCP_OFFLOAD_PARAMS_OPT2_KA_EN_MASK      0x1
-#define TCP_OFFLOAD_PARAMS_OPT2_KA_EN_SHIFT     2
-#define TCP_OFFLOAD_PARAMS_OPT2_RESERVED0_MASK  0x1F
-#define TCP_OFFLOAD_PARAMS_OPT2_RESERVED0_SHIFT 3
+        __le16 flags;
+#define TCP_OFFLOAD_PARAMS_OPT2_TS_EN_MASK      0x1
+#define TCP_OFFLOAD_PARAMS_OPT2_TS_EN_SHIFT     0
+#define TCP_OFFLOAD_PARAMS_OPT2_DA_EN_MASK      0x1
+#define TCP_OFFLOAD_PARAMS_OPT2_DA_EN_SHIFT     1
+#define TCP_OFFLOAD_PARAMS_OPT2_KA_EN_MASK      0x1
+#define TCP_OFFLOAD_PARAMS_OPT2_KA_EN_SHIFT     2
+#define TCP_OFFLOAD_PARAMS_OPT2_ECN_EN_MASK     0x1
+#define TCP_OFFLOAD_PARAMS_OPT2_ECN_EN_SHIFT    3
+#define TCP_OFFLOAD_PARAMS_OPT2_RESERVED0_MASK  0xFFF
+#define TCP_OFFLOAD_PARAMS_OPT2_RESERVED0_SHIFT 4
         u8 ip_version;
+        u8 reserved1[3];
         __le32 remote_ip[4];
         __le32 local_ip[4];
         __le32 flow_label;
@@ -163,9 +181,16 @@ struct tcp_offload_params_opt2 {
         __le16 syn_ip_payload_length;
         __le32 syn_phy_addr_lo;
         __le32 syn_phy_addr_hi;
-        __le32 reserved1[22];
+        __le32 cwnd;
+        u8 ka_max_probe_cnt;
+        u8 reserved2[3];
+        __le32 ka_timeout;
+        __le32 ka_interval;
+        __le32 max_rt_time;
+        __le32 reserved3[16];
 };
 
+/* tcp IPv4/IPv6 enum */
 enum tcp_seg_placement_event {
         TCP_EVENT_ADD_PEN,
         TCP_EVENT_ADD_NEW_ISLE,
@@ -177,40 +202,41 @@ enum tcp_seg_placement_event {
         MAX_TCP_SEG_PLACEMENT_EVENT
 };
 
+/* tcp init parameters */
 struct tcp_update_params {
         __le16 flags;
-#define TCP_UPDATE_PARAMS_REMOTE_MAC_ADDR_CHANGED_MASK   0x1
-#define TCP_UPDATE_PARAMS_REMOTE_MAC_ADDR_CHANGED_SHIFT  0
-#define TCP_UPDATE_PARAMS_MSS_CHANGED_MASK               0x1
-#define TCP_UPDATE_PARAMS_MSS_CHANGED_SHIFT              1
-#define TCP_UPDATE_PARAMS_TTL_CHANGED_MASK               0x1
-#define TCP_UPDATE_PARAMS_TTL_CHANGED_SHIFT              2
-#define TCP_UPDATE_PARAMS_TOS_OR_TC_CHANGED_MASK         0x1
-#define TCP_UPDATE_PARAMS_TOS_OR_TC_CHANGED_SHIFT        3
-#define TCP_UPDATE_PARAMS_KA_TIMEOUT_CHANGED_MASK        0x1
-#define TCP_UPDATE_PARAMS_KA_TIMEOUT_CHANGED_SHIFT       4
-#define TCP_UPDATE_PARAMS_KA_INTERVAL_CHANGED_MASK       0x1
-#define TCP_UPDATE_PARAMS_KA_INTERVAL_CHANGED_SHIFT      5
-#define TCP_UPDATE_PARAMS_MAX_RT_TIME_CHANGED_MASK       0x1
-#define TCP_UPDATE_PARAMS_MAX_RT_TIME_CHANGED_SHIFT      6
-#define TCP_UPDATE_PARAMS_FLOW_LABEL_CHANGED_MASK        0x1
-#define TCP_UPDATE_PARAMS_FLOW_LABEL_CHANGED_SHIFT       7
-#define TCP_UPDATE_PARAMS_INITIAL_RCV_WND_CHANGED_MASK   0x1
-#define TCP_UPDATE_PARAMS_INITIAL_RCV_WND_CHANGED_SHIFT  8
-#define TCP_UPDATE_PARAMS_KA_MAX_PROBE_CNT_CHANGED_MASK  0x1
-#define TCP_UPDATE_PARAMS_KA_MAX_PROBE_CNT_CHANGED_SHIFT 9
-#define TCP_UPDATE_PARAMS_KA_EN_CHANGED_MASK             0x1
-#define TCP_UPDATE_PARAMS_KA_EN_CHANGED_SHIFT            10
-#define TCP_UPDATE_PARAMS_NAGLE_EN_CHANGED_MASK          0x1
-#define TCP_UPDATE_PARAMS_NAGLE_EN_CHANGED_SHIFT         11
-#define TCP_UPDATE_PARAMS_KA_EN_MASK                     0x1
-#define TCP_UPDATE_PARAMS_KA_EN_SHIFT                    12
-#define TCP_UPDATE_PARAMS_NAGLE_EN_MASK                  0x1
-#define TCP_UPDATE_PARAMS_NAGLE_EN_SHIFT                 13
-#define TCP_UPDATE_PARAMS_KA_RESTART_MASK                0x1
-#define TCP_UPDATE_PARAMS_KA_RESTART_SHIFT               14
-#define TCP_UPDATE_PARAMS_RETRANSMIT_RESTART_MASK        0x1
-#define TCP_UPDATE_PARAMS_RETRANSMIT_RESTART_SHIFT       15
+#define TCP_UPDATE_PARAMS_REMOTE_MAC_ADDR_CHANGED_MASK          0x1
+#define TCP_UPDATE_PARAMS_REMOTE_MAC_ADDR_CHANGED_SHIFT         0
+#define TCP_UPDATE_PARAMS_MSS_CHANGED_MASK                      0x1
+#define TCP_UPDATE_PARAMS_MSS_CHANGED_SHIFT                     1
+#define TCP_UPDATE_PARAMS_TTL_CHANGED_MASK                      0x1
+#define TCP_UPDATE_PARAMS_TTL_CHANGED_SHIFT                     2
+#define TCP_UPDATE_PARAMS_TOS_OR_TC_CHANGED_MASK                0x1
+#define TCP_UPDATE_PARAMS_TOS_OR_TC_CHANGED_SHIFT               3
+#define TCP_UPDATE_PARAMS_KA_TIMEOUT_CHANGED_MASK               0x1
+#define TCP_UPDATE_PARAMS_KA_TIMEOUT_CHANGED_SHIFT              4
+#define TCP_UPDATE_PARAMS_KA_INTERVAL_CHANGED_MASK              0x1
+#define TCP_UPDATE_PARAMS_KA_INTERVAL_CHANGED_SHIFT             5
+#define TCP_UPDATE_PARAMS_MAX_RT_TIME_CHANGED_MASK              0x1
+#define TCP_UPDATE_PARAMS_MAX_RT_TIME_CHANGED_SHIFT             6
+#define TCP_UPDATE_PARAMS_FLOW_LABEL_CHANGED_MASK               0x1
+#define TCP_UPDATE_PARAMS_FLOW_LABEL_CHANGED_SHIFT              7
+#define TCP_UPDATE_PARAMS_INITIAL_RCV_WND_CHANGED_MASK          0x1
+#define TCP_UPDATE_PARAMS_INITIAL_RCV_WND_CHANGED_SHIFT         8
+#define TCP_UPDATE_PARAMS_KA_MAX_PROBE_CNT_CHANGED_MASK         0x1
+#define TCP_UPDATE_PARAMS_KA_MAX_PROBE_CNT_CHANGED_SHIFT        9
+#define TCP_UPDATE_PARAMS_KA_EN_CHANGED_MASK                    0x1
+#define TCP_UPDATE_PARAMS_KA_EN_CHANGED_SHIFT                   10
+#define TCP_UPDATE_PARAMS_NAGLE_EN_CHANGED_MASK                 0x1
+#define TCP_UPDATE_PARAMS_NAGLE_EN_CHANGED_SHIFT                11
+#define TCP_UPDATE_PARAMS_KA_EN_MASK                            0x1
+#define TCP_UPDATE_PARAMS_KA_EN_SHIFT                           12
+#define TCP_UPDATE_PARAMS_NAGLE_EN_MASK                         0x1
+#define TCP_UPDATE_PARAMS_NAGLE_EN_SHIFT                        13
+#define TCP_UPDATE_PARAMS_KA_RESTART_MASK                       0x1
+#define TCP_UPDATE_PARAMS_KA_RESTART_SHIFT                      14
+#define TCP_UPDATE_PARAMS_RETRANSMIT_RESTART_MASK               0x1
+#define TCP_UPDATE_PARAMS_RETRANSMIT_RESTART_SHIFT              15
         __le16 remote_mac_addr_lo;
         __le16 remote_mac_addr_mid;
         __le16 remote_mac_addr_hi;
@@ -226,6 +252,7 @@ struct tcp_update_params {
         u8 reserved1[7];
 };
 
+/* toe upload parameters */
 struct tcp_upload_params {
         __le32 rcv_next;
         __le32 snd_una;
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 23a9c89c7ad9..fc55ff31eca7 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -356,24 +356,9 @@ int radix_tree_split(struct radix_tree_root *, unsigned long index,
 int radix_tree_join(struct radix_tree_root *, unsigned long index,
                         unsigned new_order, void *);
 
-void __rcu **idr_get_free_cmn(struct radix_tree_root *root,
+void __rcu **idr_get_free(struct radix_tree_root *root,
                               struct radix_tree_iter *iter, gfp_t gfp,
                               unsigned long max);
-static inline void __rcu **idr_get_free(struct radix_tree_root *root,
-                                        struct radix_tree_iter *iter,
-                                        gfp_t gfp,
-                                        int end)
-{
-        return idr_get_free_cmn(root, iter, gfp, end > 0 ? end - 1 : INT_MAX);
-}
-
-static inline void __rcu **idr_get_free_ext(struct radix_tree_root *root,
-                                            struct radix_tree_iter *iter,
-                                            gfp_t gfp,
-                                            unsigned long end)
-{
-        return idr_get_free_cmn(root, iter, gfp, end - 1);
-}
 
 enum {
         RADIX_TREE_ITER_TAG_MASK = 0x0f,        /* tag index in lower nybble */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index a6ddc42f87a5..043d04784675 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -197,7 +197,7 @@ static inline void exit_tasks_rcu_finish(void) { }
 #define cond_resched_rcu_qs() \
 do { \
         if (!cond_resched()) \
-                rcu_note_voluntary_context_switch(current); \
+                rcu_note_voluntary_context_switch_lite(current); \
 } while (0)
 
 /*
@@ -433,12 +433,12 @@ 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 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
- * update-side locks prevent the value of the pointer from changing, you
- * should instead use rcu_dereference_protected() for this use case.
+ * lockdep checks for being in an RCU read-side critical section.  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 update-side locks prevent the value of the pointer from changing,
+ * you should instead use rcu_dereference_protected() for this use case.
  *
  * It is also permissible to use rcu_access_pointer() when read-side
  * access to the pointer was removed at least one grace period ago, as
@@ -521,12 +521,11 @@ static inline void rcu_preempt_sleep_check(void) { }
  * @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 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
- * with other references, so it should not be used without protection
- * of appropriate locks.
+ * 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 with other references, so it should not be used without
+ * protection of appropriate locks.
  *
  * This function is only for update-side use.  Using this function
  * when protected only by rcu_read_lock() will result in infrequent
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index b3dbf9502fd0..ce9beec35e34 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -111,7 +111,6 @@ 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 bool rcu_irq_enter_disabled(void) { return false; }
 static inline void rcu_irq_exit_irqson(void) { }
 static inline void rcu_irq_enter_irqson(void) { }
 static inline void rcu_irq_exit(void) { }
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 37d6fd3b7ff8..fd996cdf1833 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -85,7 +85,6 @@ void rcu_irq_enter(void);
 void rcu_irq_exit(void);
 void rcu_irq_enter_irqson(void);
 void rcu_irq_exit_irqson(void);
-bool rcu_irq_enter_disabled(void);
 
 void exit_rcu(void);
 
diff --git a/include/linux/refcount.h b/include/linux/refcount.h
index e8286585e149..4193c41e383a 100644
--- a/include/linux/refcount.h
+++ b/include/linux/refcount.h
@@ -8,7 +8,7 @@
 #include <linux/kernel.h>
 
 /**
- * refcount_t - variant of atomic_t specialized for reference counts
+ * struct refcount_t - variant of atomic_t specialized for reference counts
  * @refs: atomic_t counter field
  *
  * The counter saturates at UINT_MAX and will not move once
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 15eddc1353ba..6a3aeba40e9e 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -24,12 +24,14 @@ struct module;
 struct device;
 struct i2c_client;
 struct irq_domain;
+struct slim_device;
 struct spi_device;
 struct spmi_device;
 struct regmap;
 struct regmap_range_cfg;
 struct regmap_field;
 struct snd_ac97;
+struct sdw_slave;
 
 /* An enum of all the supported cache types */
 enum regcache_type {
@@ -264,6 +266,9 @@ typedef void (*regmap_unlock)(void *);
  *                field is NULL but precious_table (see below) is not, the
  *                check is performed on such table (a register is precious if
  *                it belongs to one of the ranges specified by precious_table).
+ * @disable_locking: This regmap is either protected by external means or
+ *                   is guaranteed not be be accessed from multiple threads.
+ *                   Don't use any locking mechanisms.
  * @lock:         Optional lock callback (overrides regmap's default lock
  *                function, based on spinlock or mutex).
  * @unlock:       As above for unlocking.
@@ -296,7 +301,10 @@ typedef void (*regmap_unlock)(void *);
  *                  a read.
  * @write_flag_mask: Mask to be set in the top bytes of the register when doing
  *                   a write. If both read_flag_mask and write_flag_mask are
- *                   empty the regmap_bus default masks are used.
+ *                   empty and zero_flag_mask is not set the regmap_bus default
+ *                   masks are used.
+ * @zero_flag_mask: If set, read_flag_mask and write_flag_mask are used even
+ *                   if they are both empty.
  * @use_single_rw: If set, converts the bulk read and write operations into
  *                  a series of single read and write operations. This is useful
  *                  for device that does not support bulk read and write.
@@ -317,6 +325,7 @@ typedef void (*regmap_unlock)(void *);
  *
  * @ranges: Array of configuration entries for virtual address ranges.
  * @num_ranges: Number of range configuration entries.
+ * @use_hwlock: Indicate if a hardware spinlock should be used.
  * @hwlock_id: Specify the hardware spinlock id.
  * @hwlock_mode: The hardware spinlock mode, should be HWLOCK_IRQSTATE,
  *               HWLOCK_IRQ or 0.
@@ -333,6 +342,8 @@ struct regmap_config {
         bool (*readable_reg)(struct device *dev, unsigned int reg);
         bool (*volatile_reg)(struct device *dev, unsigned int reg);
         bool (*precious_reg)(struct device *dev, unsigned int reg);
+
+        bool disable_locking;
         regmap_lock lock;
         regmap_unlock unlock;
         void *lock_arg;
@@ -355,6 +366,7 @@ struct regmap_config {
 
         unsigned long read_flag_mask;
         unsigned long write_flag_mask;
+        bool zero_flag_mask;
 
         bool use_single_rw;
         bool can_multi_write;
@@ -365,6 +377,7 @@ struct regmap_config {
         const struct regmap_range_cfg *ranges;
         unsigned int num_ranges;
 
+        bool use_hwlock;
         unsigned int hwlock_id;
         unsigned int hwlock_mode;
 };
@@ -499,6 +512,10 @@ struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
                                  const struct regmap_config *config,
                                  struct lock_class_key *lock_key,
                                  const char *lock_name);
+struct regmap *__regmap_init_slimbus(struct slim_device *slimbus,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
 struct regmap *__regmap_init_spi(struct spi_device *dev,
                                  const struct regmap_config *config,
                                  struct lock_class_key *lock_key,
@@ -524,6 +541,10 @@ struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
                                   const struct regmap_config *config,
                                   struct lock_class_key *lock_key,
                                   const char *lock_name);
+struct regmap *__regmap_init_sdw(struct sdw_slave *sdw,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
 
 struct regmap *__devm_regmap_init(struct device *dev,
                                   const struct regmap_bus *bus,
@@ -561,6 +582,10 @@ struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
                                        const struct regmap_config *config,
                                        struct lock_class_key *lock_key,
                                        const char *lock_name);
+struct regmap *__devm_regmap_init_sdw(struct sdw_slave *sdw,
+                                 const struct regmap_config *config,
+                                 struct lock_class_key *lock_key,
+                                 const char *lock_name);
 
 /*
  * Wrapper for regmap_init macros to include a unique lockdep key and name
@@ -616,6 +641,19 @@ int regmap_attach_dev(struct device *dev, struct regmap *map,
                                 i2c, config)
 
 /**
+ * regmap_init_slimbus() - Initialise register map
+ *
+ * @slimbus: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_slimbus(slimbus, config)                            \
+        __regmap_lockdep_wrapper(__regmap_init_slimbus, #config,        \
+                                slimbus, config)
+
+/**
  * regmap_init_spi() - Initialise register map
  *
  * @dev: Device that will be interacted with
@@ -710,6 +748,20 @@ int regmap_attach_dev(struct device *dev, struct regmap *map,
 bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
 
 /**
+ * regmap_init_sdw() - Initialise register map
+ *
+ * @sdw: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+#define regmap_init_sdw(sdw, config)                                    \
+        __regmap_lockdep_wrapper(__regmap_init_sdw, #config,            \
+                                sdw, config)
+
+
+/**
  * devm_regmap_init() - Initialise managed register map
  *
  * @dev: Device that will be interacted with
@@ -839,6 +891,20 @@ bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
         __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config,      \
                                 ac97, config)
 
+/**
+ * devm_regmap_init_sdw() - Initialise managed register map
+ *
+ * @sdw: Device that will be interacted with
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap. The regmap will be automatically freed by the
+ * device management code.
+ */
+#define devm_regmap_init_sdw(sdw, config)                               \
+        __regmap_lockdep_wrapper(__devm_regmap_init_sdw, #config,       \
+                                sdw, config)
+
 void regmap_exit(struct regmap *map);
 int regmap_reinit_cache(struct regmap *map,
                         const struct regmap_config *config);
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 94417b4226bd..4c00486b7a78 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -214,6 +214,8 @@ struct regulator_ops {
         /* set regulator suspend operating mode (defined in consumer.h) */
         int (*set_suspend_mode) (struct regulator_dev *, unsigned int mode);
 
+        int (*resume_early)(struct regulator_dev *rdev);
+
         int (*set_pull_down) (struct regulator_dev *);
 };
 
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index 9cd4fef37203..93a04893c739 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -42,6 +42,16 @@ struct regulator;
 #define REGULATOR_CHANGE_DRMS           0x10
 #define REGULATOR_CHANGE_BYPASS         0x20
 
+/*
+ * operations in suspend mode
+ * DO_NOTHING_IN_SUSPEND - the default value
+ * DISABLE_IN_SUSPEND   - turn off regulator in suspend states
+ * ENABLE_IN_SUSPEND    - keep regulator on in suspend states
+ */
+#define DO_NOTHING_IN_SUSPEND   (-1)
+#define DISABLE_IN_SUSPEND      0
+#define ENABLE_IN_SUSPEND       1
+
 /* Regulator active discharge flags */
 enum regulator_active_discharge {
         REGULATOR_ACTIVE_DISCHARGE_DEFAULT,
@@ -56,16 +66,24 @@ enum regulator_active_discharge {
  * state.  One of enabled or disabled must be set for the
  * configuration to be applied.
  *
- * @uV: Operating voltage during suspend.
+ * @uV: Default operating voltage during suspend, it can be adjusted
+ *      among <min_uV, max_uV>.
+ * @min_uV: Minimum suspend voltage may be set.
+ * @max_uV: Maximum suspend voltage may be set.
  * @mode: Operating mode during suspend.
- * @enabled: Enabled during suspend.
- * @disabled: Disabled during suspend.
+ * @enabled: operations during suspend.
+ *           - DO_NOTHING_IN_SUSPEND
+ *           - DISABLE_IN_SUSPEND
+ *           - ENABLE_IN_SUSPEND
+ * @changeable: Is this state can be switched between enabled/disabled,
  */
 struct regulator_state {
-        int uV; /* suspend voltage */
-        unsigned int mode; /* suspend regulator operating mode */
-        int enabled; /* is regulator enabled in this suspend state */
-        int disabled; /* is the regulator disabled in this suspend state */
+        int uV;
+        int min_uV;
+        int max_uV;
+        unsigned int mode;
+        int enabled;
+        bool changeable;
 };
 
 /**
@@ -225,12 +243,12 @@ struct regulator_init_data {
 
 #ifdef CONFIG_REGULATOR
 void regulator_has_full_constraints(void);
-int regulator_suspend_prepare(suspend_state_t state);
-int regulator_suspend_finish(void);
 #else
 static inline void regulator_has_full_constraints(void)
 {
 }
+#endif
+
 static inline int regulator_suspend_prepare(suspend_state_t state)
 {
         return 0;
@@ -239,6 +257,5 @@ static inline int regulator_suspend_finish(void)
 {
         return 0;
 }
-#endif
 
 #endif
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index 44e630eb3d94..728d421fffe9 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -324,6 +324,7 @@ struct rproc_mem_entry {
 };
 
 struct rproc;
+struct firmware;
 
 /**
  * struct rproc_ops - platform-specific device handlers
@@ -331,12 +332,24 @@ struct rproc;
  * @stop:       power off the device
  * @kick:       kick a virtqueue (virtqueue id given as a parameter)
  * @da_to_va:   optional platform hook to perform address translations
+ * @load_rsc_table:     load resource table from firmware image
+ * @find_loaded_rsc_table: find the loaded resouce table
+ * @load:               load firmeware to memory, where the remote processor
+ *                      expects to find it
+ * @sanity_check:       sanity check the fw image
+ * @get_boot_addr:      get boot address to entry point specified in firmware
  */
 struct rproc_ops {
         int (*start)(struct rproc *rproc);
         int (*stop)(struct rproc *rproc);
         void (*kick)(struct rproc *rproc, int vqid);
         void * (*da_to_va)(struct rproc *rproc, u64 da, int len);
+        int (*load_rsc_table)(struct rproc *rproc, const struct firmware *fw);
+        struct resource_table *(*find_loaded_rsc_table)(
+                                struct rproc *rproc, const struct firmware *fw);
+        int (*load)(struct rproc *rproc, const struct firmware *fw);
+        int (*sanity_check)(struct rproc *rproc, const struct firmware *fw);
+        u32 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw);
 };
 
 /**
@@ -390,7 +403,6 @@ enum rproc_crash_type {
  * @priv: private data which belongs to the platform-specific rproc module
  * @ops: platform-specific start/stop rproc handlers
  * @dev: virtual device for refcounting and common remoteproc behavior
- * @fw_ops: firmware-specific handlers
  * @power: refcount of users who need this rproc powered up
  * @state: state of the device
  * @lock: lock which protects concurrent manipulations of the rproc
@@ -406,11 +418,11 @@ enum rproc_crash_type {
  * @index: index of this rproc device
  * @crash_handler: workqueue for handling a crash
  * @crash_cnt: crash counter
- * @crash_comp: completion used to sync crash handler and the rproc reload
  * @recovery_disabled: flag that state if recovery was disabled
  * @max_notifyid: largest allocated notify id.
  * @table_ptr: pointer to the resource table in effect
  * @cached_table: copy of the resource table
+ * @table_sz: size of @cached_table
  * @has_iommu: flag to indicate if remote processor is behind an MMU
  */
 struct rproc {
@@ -419,9 +431,8 @@ struct rproc {
         const char *name;
         char *firmware;
         void *priv;
-        const struct rproc_ops *ops;
+        struct rproc_ops *ops;
         struct device dev;
-        const struct rproc_fw_ops *fw_ops;
         atomic_t power;
         unsigned int state;
         struct mutex lock;
@@ -437,11 +448,11 @@ struct rproc {
         int index;
         struct work_struct crash_handler;
         unsigned int crash_cnt;
-        struct completion crash_comp;
         bool recovery_disabled;
         int max_notifyid;
         struct resource_table *table_ptr;
         struct resource_table *cached_table;
+        size_t table_sz;
         bool has_iommu;
         bool auto_boot;
 };
diff --git a/include/linux/reservation.h b/include/linux/reservation.h
index 21fc84d82d41..02166e815afb 100644
--- a/include/linux/reservation.h
+++ b/include/linux/reservation.h
@@ -167,6 +167,29 @@ reservation_object_lock(struct reservation_object *obj,
 }
 
 /**
+ * reservation_object_lock_interruptible - lock the reservation object
+ * @obj: the reservation object
+ * @ctx: the locking context
+ *
+ * Locks the reservation object interruptible for exclusive access and
+ * modification. Note, that the lock is only against other writers, readers
+ * will run concurrently with a writer under RCU. The seqlock is used to
+ * notify readers if they overlap with a writer.
+ *
+ * As the reservation object may be locked by multiple parties in an
+ * undefined order, a #ww_acquire_ctx is passed to unwind if a cycle
+ * is detected. See ww_mutex_lock() and ww_acquire_init(). A reservation
+ * object may be locked by itself by passing NULL as @ctx.
+ */
+static inline int
+reservation_object_lock_interruptible(struct reservation_object *obj,
+                                      struct ww_acquire_ctx *ctx)
+{
+        return ww_mutex_lock_interruptible(&obj->lock, ctx);
+}
+
+
+/**
  * reservation_object_trylock - trylock the reservation object
  * @obj: the reservation object
  *
diff --git a/include/linux/reset.h b/include/linux/reset.h
index 4c7871ddf3c6..09732c36f351 100644
--- a/include/linux/reset.h
+++ b/include/linux/reset.h
@@ -2,8 +2,10 @@
 #ifndef _LINUX_RESET_H_
 #define _LINUX_RESET_H_
 
-#include <linux/device.h>
+#include <linux/types.h>
 
+struct device;
+struct device_node;
 struct reset_control;
 
 #ifdef CONFIG_RESET_CONTROLLER
@@ -20,22 +22,16 @@ struct reset_control *__reset_control_get(struct device *dev, const char *id,
                                           int index, bool shared,
                                           bool optional);
 void reset_control_put(struct reset_control *rstc);
+int __device_reset(struct device *dev, bool optional);
 struct reset_control *__devm_reset_control_get(struct device *dev,
                                      const char *id, int index, bool shared,
                                      bool optional);
 
-int __must_check device_reset(struct device *dev);
-
 struct reset_control *devm_reset_control_array_get(struct device *dev,
                                                    bool shared, bool optional);
 struct reset_control *of_reset_control_array_get(struct device_node *np,
                                                  bool shared, bool optional);
 
-static inline int device_reset_optional(struct device *dev)
-{
-        return device_reset(dev);
-}
-
 #else
 
 static inline int reset_control_reset(struct reset_control *rstc)
@@ -62,15 +58,9 @@ static inline void reset_control_put(struct reset_control *rstc)
 {
 }
 
-static inline int __must_check device_reset(struct device *dev)
-{
-        WARN_ON(1);
-        return -ENOTSUPP;
-}
-
-static inline int device_reset_optional(struct device *dev)
+static inline int __device_reset(struct device *dev, bool optional)
 {
-        return -ENOTSUPP;
+        return optional ? 0 : -ENOTSUPP;
 }
 
 static inline struct reset_control *__of_reset_control_get(
@@ -109,6 +99,16 @@ of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
 
 #endif /* CONFIG_RESET_CONTROLLER */
 
+static inline int __must_check device_reset(struct device *dev)
+{
+        return __device_reset(dev, false);
+}
+
+static inline int device_reset_optional(struct device *dev)
+{
+        return __device_reset(dev, true);
+}
+
 /**
  * reset_control_get_exclusive - Lookup and obtain an exclusive reference
  *                               to a reset controller.
@@ -127,9 +127,6 @@ of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
 static inline struct reset_control *
 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
 {
-#ifndef CONFIG_RESET_CONTROLLER
-        WARN_ON(1);
-#endif
         return __reset_control_get(dev, id, 0, false, false);
 }
 
@@ -275,9 +272,6 @@ static inline struct reset_control *
 __must_check devm_reset_control_get_exclusive(struct device *dev,
                                               const char *id)
 {
-#ifndef CONFIG_RESET_CONTROLLER
-        WARN_ON(1);
-#endif
         return __devm_reset_control_get(dev, id, 0, false, false);
 }
 
@@ -350,18 +344,6 @@ devm_reset_control_get_shared_by_index(struct device *dev, int index)
  * These inline function calls will be removed once all consumers
  * have been moved over to the new explicit API.
  */
-static inline struct reset_control *reset_control_get(
-                                struct device *dev, const char *id)
-{
-        return reset_control_get_exclusive(dev, id);
-}
-
-static inline struct reset_control *reset_control_get_optional(
-                                        struct device *dev, const char *id)
-{
-        return reset_control_get_optional_exclusive(dev, id);
-}
-
 static inline struct reset_control *of_reset_control_get(
                                 struct device_node *node, const char *id)
 {
diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h
index 361c08e35dbc..c9df2527e0cd 100644
--- a/include/linux/rhashtable.h
+++ b/include/linux/rhashtable.h
@@ -207,6 +207,7 @@ struct rhashtable_iter {
         struct rhashtable_walker walker;
         unsigned int slot;
         unsigned int skip;
+        bool end_of_table;
 };
 
 static inline unsigned long rht_marker(const struct rhashtable *ht, u32 hash)
@@ -239,34 +240,42 @@ static inline unsigned int rht_bucket_index(const struct bucket_table *tbl,
         return (hash >> RHT_HASH_RESERVED_SPACE) & (tbl->size - 1);
 }
 
-static inline unsigned int rht_key_hashfn(
-        struct rhashtable *ht, const struct bucket_table *tbl,
-        const void *key, const struct rhashtable_params params)
+static inline unsigned int rht_key_get_hash(struct rhashtable *ht,
+        const void *key, const struct rhashtable_params params,
+        unsigned int hash_rnd)
 {
         unsigned int hash;
 
         /* params must be equal to ht->p if it isn't constant. */
         if (!__builtin_constant_p(params.key_len))
-                hash = ht->p.hashfn(key, ht->key_len, tbl->hash_rnd);
+                hash = ht->p.hashfn(key, ht->key_len, hash_rnd);
         else if (params.key_len) {
                 unsigned int key_len = params.key_len;
 
                 if (params.hashfn)
-                        hash = params.hashfn(key, key_len, tbl->hash_rnd);
+                        hash = params.hashfn(key, key_len, hash_rnd);
                 else if (key_len & (sizeof(u32) - 1))
-                        hash = jhash(key, key_len, tbl->hash_rnd);
+                        hash = jhash(key, key_len, hash_rnd);
                 else
-                        hash = jhash2(key, key_len / sizeof(u32),
-                                      tbl->hash_rnd);
+                        hash = jhash2(key, key_len / sizeof(u32), hash_rnd);
         } else {
                 unsigned int key_len = ht->p.key_len;
 
                 if (params.hashfn)
-                        hash = params.hashfn(key, key_len, tbl->hash_rnd);
+                        hash = params.hashfn(key, key_len, hash_rnd);
                 else
-                        hash = jhash(key, key_len, tbl->hash_rnd);
+                        hash = jhash(key, key_len, hash_rnd);
         }
 
+        return hash;
+}
+
+static inline unsigned int rht_key_hashfn(
+        struct rhashtable *ht, const struct bucket_table *tbl,
+        const void *key, const struct rhashtable_params params)
+{
+        unsigned int hash = rht_key_get_hash(ht, key, params, tbl->hash_rnd);
+
         return rht_bucket_index(tbl, hash);
 }
 
@@ -378,8 +387,15 @@ void *rhashtable_insert_slow(struct rhashtable *ht, const void *key,
 void rhashtable_walk_enter(struct rhashtable *ht,
                            struct rhashtable_iter *iter);
 void rhashtable_walk_exit(struct rhashtable_iter *iter);
-int rhashtable_walk_start(struct rhashtable_iter *iter) __acquires(RCU);
+int rhashtable_walk_start_check(struct rhashtable_iter *iter) __acquires(RCU);
+
+static inline void rhashtable_walk_start(struct rhashtable_iter *iter)
+{
+        (void)rhashtable_walk_start_check(iter);
+}
+
 void *rhashtable_walk_next(struct rhashtable_iter *iter);
+void *rhashtable_walk_peek(struct rhashtable_iter *iter);
 void rhashtable_walk_stop(struct rhashtable_iter *iter) __releases(RCU);
 
 void rhashtable_free_and_destroy(struct rhashtable *ht,
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index 289e4d54e3e0..7d9eb39fa76a 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -96,7 +96,7 @@ __ring_buffer_alloc(unsigned long size, unsigned flags, struct lock_class_key *k
 })
 
 int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full);
-int ring_buffer_poll_wait(struct ring_buffer *buffer, int cpu,
+__poll_t ring_buffer_poll_wait(struct ring_buffer *buffer, int cpu,
                           struct file *filp, poll_table *poll_table);
 
 
diff --git a/include/linux/rpmsg.h b/include/linux/rpmsg.h
index 10d6ae8bbb7d..ca07366c4c33 100644
--- a/include/linux/rpmsg.h
+++ b/include/linux/rpmsg.h
@@ -157,7 +157,7 @@ int rpmsg_trysendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst);
 int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,
                              void *data, int len);
 
-unsigned int rpmsg_poll(struct rpmsg_endpoint *ept, struct file *filp,
+__poll_t rpmsg_poll(struct rpmsg_endpoint *ept, struct file *filp,
                         poll_table *wait);
 
 #else
@@ -258,7 +258,7 @@ static inline int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src,
         return -ENXIO;
 }
 
-static inline unsigned int rpmsg_poll(struct rpmsg_endpoint *ept,
+static inline __poll_t rpmsg_poll(struct rpmsg_endpoint *ept,
                                       struct file *filp, poll_table *wait)
 {
         /* This shouldn't be possible */
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 41319a2e409b..fc6c90b57be0 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -87,7 +87,6 @@ struct rtc_class_ops {
         int (*set_offset)(struct device *, long offset);
 };
 
-#define RTC_DEVICE_NAME_SIZE 20
 typedef struct rtc_task {
         void (*func)(void *private_data);
         void *private_data;
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 2032ce2eb20b..1fdcde96eb65 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -19,10 +19,11 @@ extern int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst,
 
 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change, gfp_t flags);
 void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change,
-                         gfp_t flags, int *new_nsid);
+                         gfp_t flags, int *new_nsid, int new_ifindex);
 struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
                                        unsigned change, u32 event,
-                                       gfp_t flags, int *new_nsid);
+                                       gfp_t flags, int *new_nsid,
+                                       int new_ifindex);
 void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev,
                        gfp_t flags);
 
@@ -70,8 +71,7 @@ static inline bool lockdep_rtnl_is_held(void)
  * @p: The pointer to read, prior to dereferencing
  *
  * Return the value of the specified RCU-protected pointer, but omit
- * both the smp_read_barrier_depends() and the READ_ONCE(), because
- * caller holds RTNL.
+ * the READ_ONCE(), because caller holds RTNL.
  */
 #define rtnl_dereference(p)                                     \
         rcu_dereference_protected(p, lockdep_rtnl_is_held())
@@ -97,13 +97,9 @@ void rtnetlink_init(void);
 void __rtnl_unlock(void);
 void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail);
 
-#define ASSERT_RTNL() do { \
-        if (unlikely(!rtnl_is_locked())) { \
-                printk(KERN_ERR "RTNL: assertion failed at %s (%d)\n", \
-                       __FILE__,  __LINE__); \
-                dump_stack(); \
-        } \
-} while(0)
+#define ASSERT_RTNL() \
+        WARN_ONCE(!rtnl_is_locked(), \
+                  "RTNL: assertion failed at %s (%d)\n", __FILE__,  __LINE__)
 
 extern int ndo_dflt_fdb_dump(struct sk_buff *skb,
                              struct netlink_callback *cb,
diff --git a/include/linux/mfd/rtsx_common.h b/include/linux/rtsx_common.h
index 443176ee1ab0..443176ee1ab0 100644
--- a/include/linux/mfd/rtsx_common.h
+++ b/include/linux/rtsx_common.h
diff --git a/include/linux/mfd/rtsx_pci.h b/include/linux/rtsx_pci.h
index c3d3f04d8cc6..478acf6efac6 100644
--- a/include/linux/mfd/rtsx_pci.h
+++ b/include/linux/rtsx_pci.h
@@ -24,7 +24,7 @@
 
 #include <linux/sched.h>
 #include <linux/pci.h>
-#include <linux/mfd/rtsx_common.h>
+#include <linux/rtsx_common.h>
 
 #define MAX_RW_REG_CNT                  1024
 
@@ -203,6 +203,7 @@
 #define   SD_DDR_MODE                   0x04
 #define   SD_30_MODE                    0x08
 #define   SD_CLK_DIVIDE_MASK            0xC0
+#define   SD_MODE_SELECT_MASK           0x0C
 #define SD_CFG2                         0xFDA1
 #define   SD_CALCULATE_CRC7             0x00
 #define   SD_NO_CALCULATE_CRC7          0x80
@@ -226,6 +227,7 @@
 #define   SD_RSP_TYPE_R6                0x01
 #define   SD_RSP_TYPE_R7                0x01
 #define SD_CFG3                         0xFDA2
+#define   SD30_CLK_END_EN               0x10
 #define   SD_RSP_80CLK_TIMEOUT_EN       0x01
 
 #define SD_STAT1                        0xFDA3
@@ -309,6 +311,12 @@
 
 #define SD_DATA_STATE                   0xFDB6
 #define   SD_DATA_IDLE                  0x80
+#define REG_SD_STOP_SDCLK_CFG           0xFDB8
+#define   SD30_CLK_STOP_CFG_EN          0x04
+#define   SD30_CLK_STOP_CFG1            0x02
+#define   SD30_CLK_STOP_CFG0            0x01
+#define REG_PRE_RW_MODE                 0xFD70
+#define EN_INFINITE_MODE                0x01
 
 #define SRCTL                           0xFC13
 
@@ -434,6 +442,7 @@
 #define CARD_CLK_EN                     0xFD69
 #define   SD_CLK_EN                     0x04
 #define   MS_CLK_EN                     0x08
+#define   SD40_CLK_EN           0x10
 #define SDIO_CTRL                       0xFD6B
 #define CD_PAD_CTL                      0xFD73
 #define   CD_DISABLE_MASK               0x07
@@ -453,8 +462,8 @@
 #define FPDCTL                          0xFC00
 #define   SSC_POWER_DOWN                0x01
 #define   SD_OC_POWER_DOWN              0x02
-#define   ALL_POWER_DOWN                0x07
-#define   OC_POWER_DOWN                 0x06
+#define   ALL_POWER_DOWN                0x03
+#define   OC_POWER_DOWN                 0x02
 #define PDINFO                          0xFC01
 
 #define CLK_CTL                         0xFC02
@@ -490,6 +499,9 @@
 
 #define FPGA_PULL_CTL                   0xFC1D
 #define OLT_LED_CTL                     0xFC1E
+#define   LED_SHINE_MASK                0x08
+#define   LED_SHINE_EN                  0x08
+#define   LED_SHINE_DISABLE             0x00
 #define GPIO_CTL                        0xFC1F
 
 #define LDO_CTL                         0xFC1E
@@ -511,7 +523,11 @@
 #define   BPP_LDO_ON                    0x00
 #define   BPP_LDO_SUSPEND               0x02
 #define   BPP_LDO_OFF                   0x03
+#define EFUSE_CTL                       0xFC30
+#define EFUSE_ADD                       0xFC31
 #define SYS_VER                         0xFC32
+#define EFUSE_DATAL                     0xFC34
+#define EFUSE_DATAH                     0xFC35
 
 #define CARD_PULL_CTL1                  0xFD60
 #define CARD_PULL_CTL2                  0xFD61
@@ -553,6 +569,9 @@
 #define RBBC1                           0xFE2F
 #define RBDAT                           0xFE30
 #define RBCTL                           0xFE34
+#define   U_AUTO_DMA_EN_MASK            0x20
+#define   U_AUTO_DMA_DISABLE            0x00
+#define   RB_FLUSH                      0x80
 #define CFGADDR0                        0xFE35
 #define CFGADDR1                        0xFE36
 #define CFGDATA0                        0xFE37
@@ -581,6 +600,8 @@
 #define LTR_LATENCY_MODE_HW             0
 #define LTR_LATENCY_MODE_SW             BIT(6)
 #define OBFF_CFG                        0xFE4C
+#define   OBFF_EN_MASK                  0x03
+#define   OBFF_DISABLE                  0x00
 
 #define CDRESUMECTL                     0xFE52
 #define WAKE_SEL_CTL                    0xFE54
@@ -595,6 +616,7 @@
 #define   FORCE_ASPM_L0_EN              0x01
 #define   FORCE_ASPM_NO_ASPM            0x00
 #define PM_CLK_FORCE_CTL                0xFE58
+#define   CLK_PM_EN                     0x01
 #define FUNC_FORCE_CTL                  0xFE59
 #define   FUNC_FORCE_UPME_XMT_DBG       0x02
 #define PERST_GLITCH_WIDTH              0xFE5C
@@ -620,14 +642,23 @@
 #define LDO_PWR_SEL                     0xFE78
 
 #define L1SUB_CONFIG1                   0xFE8D
+#define   AUX_CLK_ACTIVE_SEL_MASK       0x01
+#define   MAC_CKSW_DONE                 0x00
 #define L1SUB_CONFIG2                   0xFE8E
 #define   L1SUB_AUTO_CFG                0x02
 #define L1SUB_CONFIG3                   0xFE8F
 #define   L1OFF_MBIAS2_EN_5250          BIT(7)
 
 #define DUMMY_REG_RESET_0               0xFE90
+#define   IC_VERSION_MASK               0x0F
 
+#define REG_VREF                        0xFE97
+#define   PWD_SUSPND_EN                 0x10
+#define RTS5260_DMA_RST_CTL_0           0xFEBF
+#define   RTS5260_DMA_RST               0x80
+#define   RTS5260_ADMA3_RST             0x40
 #define AUTOLOAD_CFG_BASE               0xFF00
+#define RELINK_TIME_MASK                0x01
 #define PETXCFG                         0xFF03
 #define FORCE_CLKREQ_DELINK_MASK        BIT(7)
 #define FORCE_CLKREQ_LOW        0x80
@@ -667,15 +698,24 @@
 #define LDO_DV18_CFG                    0xFF70
 #define   LDO_DV18_SR_MASK              0xC0
 #define   LDO_DV18_SR_DF                0x40
+#define   DV331812_MASK                 0x70
+#define   DV331812_33                   0x70
+#define   DV331812_17                   0x30
 
 #define LDO_CONFIG2                     0xFF71
 #define   LDO_D3318_MASK                0x07
 #define   LDO_D3318_33V                 0x07
 #define   LDO_D3318_18V                 0x02
+#define   DV331812_VDD1                 0x04
+#define   DV331812_POWERON              0x08
+#define   DV331812_POWEROFF             0x00
 
 #define LDO_VCC_CFG0                    0xFF72
 #define   LDO_VCC_LMTVTH_MASK           0x30
 #define   LDO_VCC_LMTVTH_2A             0x10
+/*RTS5260*/
+#define   RTS5260_DVCC_TUNE_MASK        0x70
+#define   RTS5260_DVCC_33               0x70
 
 #define LDO_VCC_CFG1                    0xFF73
 #define   LDO_VCC_REF_TUNE_MASK         0x30
@@ -684,6 +724,10 @@
 #define   LDO_VCC_1V8                   0x04
 #define   LDO_VCC_3V3                   0x07
 #define   LDO_VCC_LMT_EN                0x08
+/*RTS5260*/
+#define   LDO_POW_SDVDD1_MASK           0x08
+#define   LDO_POW_SDVDD1_ON             0x08
+#define   LDO_POW_SDVDD1_OFF            0x00
 
 #define LDO_VIO_CFG                     0xFF75
 #define   LDO_VIO_SR_MASK               0xC0
@@ -711,6 +755,160 @@
 #define   SD_VIO_LDO_1V8                0x40
 #define   SD_VIO_LDO_3V3                0x70
 
+#define RTS5260_AUTOLOAD_CFG4           0xFF7F
+#define   RTS5260_MIMO_DISABLE          0x8A
+
+#define RTS5260_REG_GPIO_CTL0           0xFC1A
+#define   RTS5260_REG_GPIO_MASK         0x01
+#define   RTS5260_REG_GPIO_ON           0x01
+#define   RTS5260_REG_GPIO_OFF          0x00
+
+#define PWR_GLOBAL_CTRL                 0xF200
+#define PCIE_L1_2_EN                    0x0C
+#define PCIE_L1_1_EN                    0x0A
+#define PCIE_L1_0_EN                    0x09
+#define PWR_FE_CTL                      0xF201
+#define PCIE_L1_2_PD_FE_EN              0x0C
+#define PCIE_L1_1_PD_FE_EN              0x0A
+#define PCIE_L1_0_PD_FE_EN              0x09
+#define CFG_PCIE_APHY_OFF_0             0xF204
+#define CFG_PCIE_APHY_OFF_0_DEFAULT     0xBF
+#define CFG_PCIE_APHY_OFF_1             0xF205
+#define CFG_PCIE_APHY_OFF_1_DEFAULT     0xFF
+#define CFG_PCIE_APHY_OFF_2             0xF206
+#define CFG_PCIE_APHY_OFF_2_DEFAULT     0x01
+#define CFG_PCIE_APHY_OFF_3             0xF207
+#define CFG_PCIE_APHY_OFF_3_DEFAULT     0x00
+#define CFG_L1_0_PCIE_MAC_RET_VALUE     0xF20C
+#define CFG_L1_0_PCIE_DPHY_RET_VALUE    0xF20E
+#define CFG_L1_0_SYS_RET_VALUE          0xF210
+#define CFG_L1_0_CRC_MISC_RET_VALUE     0xF212
+#define CFG_L1_0_CRC_SD30_RET_VALUE     0xF214
+#define CFG_L1_0_CRC_SD40_RET_VALUE     0xF216
+#define CFG_LP_FPWM_VALUE               0xF219
+#define CFG_LP_FPWM_VALUE_DEFAULT       0x18
+#define PWC_CDR                         0xF253
+#define PWC_CDR_DEFAULT                 0x03
+#define CFG_L1_0_RET_VALUE_DEFAULT      0x1B
+#define CFG_L1_0_CRC_MISC_RET_VALUE_DEFAULT     0x0C
+
+/* OCPCTL */
+#define SD_DETECT_EN                    0x08
+#define SD_OCP_INT_EN                   0x04
+#define SD_OCP_INT_CLR                  0x02
+#define SD_OC_CLR                       0x01
+
+#define SDVIO_DETECT_EN                 (1 << 7)
+#define SDVIO_OCP_INT_EN                (1 << 6)
+#define SDVIO_OCP_INT_CLR               (1 << 5)
+#define SDVIO_OC_CLR                    (1 << 4)
+
+/* OCPSTAT */
+#define SD_OCP_DETECT                   0x08
+#define SD_OC_NOW                       0x04
+#define SD_OC_EVER                      0x02
+
+#define SDVIO_OC_NOW                    (1 << 6)
+#define SDVIO_OC_EVER                   (1 << 5)
+
+#define REG_OCPCTL                      0xFD6A
+#define REG_OCPSTAT                     0xFD6E
+#define REG_OCPGLITCH                   0xFD6C
+#define REG_OCPPARA1                    0xFD6B
+#define REG_OCPPARA2                    0xFD6D
+
+/* rts5260 DV3318 OCP-related registers */
+#define REG_DV3318_OCPCTL               0xFD89
+#define DV3318_OCP_TIME_MASK    0xF0
+#define DV3318_DETECT_EN                0x08
+#define DV3318_OCP_INT_EN               0x04
+#define DV3318_OCP_INT_CLR              0x02
+#define DV3318_OCP_CLR                  0x01
+
+#define REG_DV3318_OCPSTAT              0xFD8A
+#define DV3318_OCP_GlITCH_TIME_MASK     0xF0
+#define DV3318_OCP_DETECT               0x08
+#define DV3318_OCP_NOW                  0x04
+#define DV3318_OCP_EVER                 0x02
+
+#define SD_OCP_GLITCH_MASK              0x0F
+
+/* OCPPARA1 */
+#define SDVIO_OCP_TIME_60               0x00
+#define SDVIO_OCP_TIME_100              0x10
+#define SDVIO_OCP_TIME_200              0x20
+#define SDVIO_OCP_TIME_400              0x30
+#define SDVIO_OCP_TIME_600              0x40
+#define SDVIO_OCP_TIME_800              0x50
+#define SDVIO_OCP_TIME_1100             0x60
+#define SDVIO_OCP_TIME_MASK             0x70
+
+#define SD_OCP_TIME_60                  0x00
+#define SD_OCP_TIME_100                 0x01
+#define SD_OCP_TIME_200                 0x02
+#define SD_OCP_TIME_400                 0x03
+#define SD_OCP_TIME_600                 0x04
+#define SD_OCP_TIME_800                 0x05
+#define SD_OCP_TIME_1100                0x06
+#define SD_OCP_TIME_MASK                0x07
+
+/* OCPPARA2 */
+#define SDVIO_OCP_THD_190               0x00
+#define SDVIO_OCP_THD_250               0x10
+#define SDVIO_OCP_THD_320               0x20
+#define SDVIO_OCP_THD_380               0x30
+#define SDVIO_OCP_THD_440               0x40
+#define SDVIO_OCP_THD_500               0x50
+#define SDVIO_OCP_THD_570               0x60
+#define SDVIO_OCP_THD_630               0x70
+#define SDVIO_OCP_THD_MASK              0x70
+
+#define SD_OCP_THD_450                  0x00
+#define SD_OCP_THD_550                  0x01
+#define SD_OCP_THD_650                  0x02
+#define SD_OCP_THD_750                  0x03
+#define SD_OCP_THD_850                  0x04
+#define SD_OCP_THD_950                  0x05
+#define SD_OCP_THD_1050                 0x06
+#define SD_OCP_THD_1150                 0x07
+#define SD_OCP_THD_MASK                 0x07
+
+#define SDVIO_OCP_GLITCH_MASK           0xF0
+#define SDVIO_OCP_GLITCH_NONE           0x00
+#define SDVIO_OCP_GLITCH_50U            0x10
+#define SDVIO_OCP_GLITCH_100U           0x20
+#define SDVIO_OCP_GLITCH_200U           0x30
+#define SDVIO_OCP_GLITCH_600U           0x40
+#define SDVIO_OCP_GLITCH_800U           0x50
+#define SDVIO_OCP_GLITCH_1M             0x60
+#define SDVIO_OCP_GLITCH_2M             0x70
+#define SDVIO_OCP_GLITCH_3M             0x80
+#define SDVIO_OCP_GLITCH_4M             0x90
+#define SDVIO_OCP_GLIVCH_5M             0xA0
+#define SDVIO_OCP_GLITCH_6M             0xB0
+#define SDVIO_OCP_GLITCH_7M             0xC0
+#define SDVIO_OCP_GLITCH_8M             0xD0
+#define SDVIO_OCP_GLITCH_9M             0xE0
+#define SDVIO_OCP_GLITCH_10M            0xF0
+
+#define SD_OCP_GLITCH_MASK              0x0F
+#define SD_OCP_GLITCH_NONE              0x00
+#define SD_OCP_GLITCH_50U               0x01
+#define SD_OCP_GLITCH_100U              0x02
+#define SD_OCP_GLITCH_200U              0x03
+#define SD_OCP_GLITCH_600U              0x04
+#define SD_OCP_GLITCH_800U              0x05
+#define SD_OCP_GLITCH_1M                0x06
+#define SD_OCP_GLITCH_2M                0x07
+#define SD_OCP_GLITCH_3M                0x08
+#define SD_OCP_GLITCH_4M                0x09
+#define SD_OCP_GLIVCH_5M                0x0A
+#define SD_OCP_GLITCH_6M                0x0B
+#define SD_OCP_GLITCH_7M                0x0C
+#define SD_OCP_GLITCH_8M                0x0D
+#define SD_OCP_GLITCH_9M                0x0E
+#define SD_OCP_GLITCH_10M               0x0F
+
 /* Phy register */
 #define PHY_PCR                         0x00
 #define   PHY_PCR_FORCE_CODE            0xB000
@@ -857,6 +1055,7 @@
 
 #define PCR_ASPM_SETTING_REG1           0x160
 #define PCR_ASPM_SETTING_REG2           0x168
+#define PCR_ASPM_SETTING_5260           0x178
 
 #define PCR_SETTING_REG1                0x724
 #define PCR_SETTING_REG2                0x814
@@ -890,6 +1089,7 @@ struct pcr_ops {
         int             (*conv_clk_and_div_n)(int clk, int dir);
         void            (*fetch_vendor_settings)(struct rtsx_pcr *pcr);
         void            (*force_power_down)(struct rtsx_pcr *pcr, u8 pm_state);
+        void            (*stop_cmd)(struct rtsx_pcr *pcr);
 
         void (*set_aspm)(struct rtsx_pcr *pcr, bool enable);
         int (*set_ltr_latency)(struct rtsx_pcr *pcr, u32 latency);
@@ -897,6 +1097,12 @@ struct pcr_ops {
         void (*set_l1off_cfg_sub_d0)(struct rtsx_pcr *pcr, int active);
         void (*full_on)(struct rtsx_pcr *pcr);
         void (*power_saving)(struct rtsx_pcr *pcr);
+        void (*enable_ocp)(struct rtsx_pcr *pcr);
+        void (*disable_ocp)(struct rtsx_pcr *pcr);
+        void (*init_ocp)(struct rtsx_pcr *pcr);
+        void (*process_ocp)(struct rtsx_pcr *pcr);
+        int (*get_ocpstat)(struct rtsx_pcr *pcr, u8 *val);
+        void (*clear_ocpstat)(struct rtsx_pcr *pcr);
 };
 
 enum PDEV_STAT  {PDEV_STAT_IDLE, PDEV_STAT_RUN};
@@ -935,6 +1141,9 @@ enum dev_aspm_mode {
  * @l1_snooze_delay: l1 snooze delay
  * @ltr_l1off_sspwrgate: ltr l1off sspwrgate
  * @ltr_l1off_snooze_sspwrgate: ltr l1off snooze sspwrgate
+ * @ocp_en: enable ocp flag
+ * @sd_400mA_ocp_thd: 400mA ocp thd
+ * @sd_800mA_ocp_thd: 800mA ocp thd
  */
 struct rtsx_cr_option {
         u32 dev_flags;
@@ -949,6 +1158,19 @@ struct rtsx_cr_option {
         u32 l1_snooze_delay;
         u8 ltr_l1off_sspwrgate;
         u8 ltr_l1off_snooze_sspwrgate;
+        bool ocp_en;
+        u8 sd_400mA_ocp_thd;
+        u8 sd_800mA_ocp_thd;
+};
+
+/*
+ * struct rtsx_hw_param  - card reader hardware param
+ * @interrupt_en: indicate which interrutp enable
+ * @ocp_glitch: ocp glitch time
+ */
+struct rtsx_hw_param {
+        u32 interrupt_en;
+        u8 ocp_glitch;
 };
 
 #define rtsx_set_dev_flag(cr, flag) \
@@ -963,6 +1185,7 @@ struct rtsx_pcr {
         unsigned int                    id;
         int                             pcie_cap;
         struct rtsx_cr_option   option;
+        struct rtsx_hw_param hw_param;
 
         /* pci resources */
         unsigned long                   addr;
@@ -1042,12 +1265,15 @@ struct rtsx_pcr {
         struct rtsx_slot                *slots;
 
         u8                              dma_error_count;
+        u8                      ocp_stat;
+        u8                      ocp_stat2;
 };
 
 #define PID_524A        0x524A
-#define PID_5249                0x5249
-#define PID_5250                0x5250
+#define PID_5249        0x5249
+#define PID_5250        0x5250
 #define PID_525A        0x525A
+#define PID_5260        0x5260
 
 #define CHK_PCI_PID(pcr, pid)           ((pcr)->pci->device == (pid))
 #define PCI_VID(pcr)                    ((pcr)->pci->vendor)
diff --git a/include/linux/mfd/rtsx_usb.h b/include/linux/rtsx_usb.h
index c446e4fd6b5c..c446e4fd6b5c 100644
--- a/include/linux/mfd/rtsx_usb.h
+++ b/include/linux/rtsx_usb.h
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index b7c83254c566..22b2131bcdcd 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -276,6 +276,17 @@ int sg_alloc_table_from_pages(struct sg_table *sgt, struct page **pages,
                               unsigned int n_pages, unsigned int offset,
                               unsigned long size, gfp_t gfp_mask);
 
+#ifdef CONFIG_SGL_ALLOC
+struct scatterlist *sgl_alloc_order(unsigned long long length,
+                                    unsigned int order, bool chainable,
+                                    gfp_t gfp, unsigned int *nent_p);
+struct scatterlist *sgl_alloc(unsigned long long length, gfp_t gfp,
+                              unsigned int *nent_p);
+void sgl_free_n_order(struct scatterlist *sgl, int nents, int order);
+void sgl_free_order(struct scatterlist *sgl, int order);
+void sgl_free(struct scatterlist *sgl);
+#endif /* CONFIG_SGL_ALLOC */
+
 size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents, void *buf,
                       size_t buflen, off_t skip, bool to_buffer);
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 68a504f6e474..b161ef8a902e 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -472,11 +472,15 @@ struct sched_dl_entity {
          * has not been executed yet. This flag is useful to avoid race
          * conditions between the inactive timer handler and the wakeup
          * code.
+         *
+         * @dl_overrun tells if the task asked to be informed about runtime
+         * overruns.
          */
         unsigned int                    dl_throttled      : 1;
         unsigned int                    dl_boosted        : 1;
         unsigned int                    dl_yielded        : 1;
         unsigned int                    dl_non_contending : 1;
+        unsigned int                    dl_overrun        : 1;
 
         /*
          * Bandwidth enforcement timer. Each -deadline task has its
@@ -551,6 +555,14 @@ struct task_struct {
         unsigned long                   wakee_flip_decay_ts;
         struct task_struct              *last_wakee;
 
+        /*
+         * recent_used_cpu is initially set as the last CPU used by a task
+         * that wakes affine another task. Waker/wakee relationships can
+         * push tasks around a CPU where each wakeup moves to the next one.
+         * Tracking a recently used CPU allows a quick search for a recently
+         * used CPU that may be idle.
+         */
+        int                             recent_used_cpu;
         int                             wake_cpu;
 #endif
         int                             on_rq;
@@ -1427,6 +1439,7 @@ extern int idle_cpu(int cpu);
 extern int sched_setscheduler(struct task_struct *, int, const struct sched_param *);
 extern int sched_setscheduler_nocheck(struct task_struct *, int, const struct sched_param *);
 extern int sched_setattr(struct task_struct *, const struct sched_attr *);
+extern int sched_setattr_nocheck(struct task_struct *, const struct sched_attr *);
 extern struct task_struct *idle_task(int cpu);
 
 /**
@@ -1484,6 +1497,11 @@ static inline struct thread_info *task_thread_info(struct task_struct *task)
 extern struct task_struct *find_task_by_vpid(pid_t nr);
 extern struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns);
 
+/*
+ * find a task by its virtual pid and get the task struct
+ */
+extern struct task_struct *find_get_task_by_vpid(pid_t nr);
+
 extern int wake_up_state(struct task_struct *tsk, unsigned int state);
 extern int wake_up_process(struct task_struct *tsk);
 extern void wake_up_new_task(struct task_struct *tsk);
diff --git a/include/linux/sched/cpufreq.h b/include/linux/sched/cpufreq.h
index d1ad3d825561..0b55834efd46 100644
--- a/include/linux/sched/cpufreq.h
+++ b/include/linux/sched/cpufreq.h
@@ -12,8 +12,6 @@
 #define SCHED_CPUFREQ_DL        (1U << 1)
 #define SCHED_CPUFREQ_IOWAIT    (1U << 2)
 
-#define SCHED_CPUFREQ_RT_DL     (SCHED_CPUFREQ_RT | SCHED_CPUFREQ_DL)
-
 #ifdef CONFIG_CPU_FREQ
 struct update_util_data {
        void (*func)(struct update_util_data *data, u64 time, unsigned int flags);
diff --git a/include/linux/sched/mm.h b/include/linux/sched/mm.h
index 3d49b91b674d..1149533aa2fa 100644
--- a/include/linux/sched/mm.h
+++ b/include/linux/sched/mm.h
@@ -7,11 +7,12 @@
 #include <linux/sched.h>
 #include <linux/mm_types.h>
 #include <linux/gfp.h>
+#include <linux/sync_core.h>
 
 /*
  * Routines for handling mm_structs
  */
-extern struct mm_struct * mm_alloc(void);
+extern struct mm_struct *mm_alloc(void);
 
 /**
  * mmgrab() - Pin a &struct mm_struct.
@@ -35,27 +36,7 @@ static inline void mmgrab(struct mm_struct *mm)
         atomic_inc(&mm->mm_count);
 }
 
-/* mmdrop drops the mm and the page tables */
-extern void __mmdrop(struct mm_struct *);
-static inline void mmdrop(struct mm_struct *mm)
-{
-        if (unlikely(atomic_dec_and_test(&mm->mm_count)))
-                __mmdrop(mm);
-}
-
-static inline void mmdrop_async_fn(struct work_struct *work)
-{
-        struct mm_struct *mm = container_of(work, struct mm_struct, async_put_work);
-        __mmdrop(mm);
-}
-
-static inline void mmdrop_async(struct mm_struct *mm)
-{
-        if (unlikely(atomic_dec_and_test(&mm->mm_count))) {
-                INIT_WORK(&mm->async_put_work, mmdrop_async_fn);
-                schedule_work(&mm->async_put_work);
-        }
-}
+extern void mmdrop(struct mm_struct *mm);
 
 /**
  * mmget() - Pin the address space associated with a &struct mm_struct.
@@ -214,18 +195,48 @@ static inline void memalloc_noreclaim_restore(unsigned int flags)
 
 #ifdef CONFIG_MEMBARRIER
 enum {
-        MEMBARRIER_STATE_PRIVATE_EXPEDITED_READY        = (1U << 0),
-        MEMBARRIER_STATE_SWITCH_MM                      = (1U << 1),
+        MEMBARRIER_STATE_PRIVATE_EXPEDITED_READY                = (1U << 0),
+        MEMBARRIER_STATE_PRIVATE_EXPEDITED                      = (1U << 1),
+        MEMBARRIER_STATE_GLOBAL_EXPEDITED_READY                 = (1U << 2),
+        MEMBARRIER_STATE_GLOBAL_EXPEDITED                       = (1U << 3),
+        MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE_READY      = (1U << 4),
+        MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE            = (1U << 5),
+};
+
+enum {
+        MEMBARRIER_FLAG_SYNC_CORE       = (1U << 0),
 };
 
+#ifdef CONFIG_ARCH_HAS_MEMBARRIER_CALLBACKS
+#include <asm/membarrier.h>
+#endif
+
+static inline void membarrier_mm_sync_core_before_usermode(struct mm_struct *mm)
+{
+        if (likely(!(atomic_read(&mm->membarrier_state) &
+                     MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE)))
+                return;
+        sync_core_before_usermode();
+}
+
 static inline void membarrier_execve(struct task_struct *t)
 {
         atomic_set(&t->mm->membarrier_state, 0);
 }
 #else
+#ifdef CONFIG_ARCH_HAS_MEMBARRIER_CALLBACKS
+static inline void membarrier_arch_switch_mm(struct mm_struct *prev,
+                                             struct mm_struct *next,
+                                             struct task_struct *tsk)
+{
+}
+#endif
 static inline void membarrier_execve(struct task_struct *t)
 {
 }
+static inline void membarrier_mm_sync_core_before_usermode(struct mm_struct *mm)
+{
+}
 #endif
 
 #endif /* _LINUX_SCHED_MM_H */
diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h
index 0aa4548fb492..23b4f9cb82db 100644
--- a/include/linux/sched/signal.h
+++ b/include/linux/sched/signal.h
@@ -285,6 +285,34 @@ static inline void kernel_signal_stop(void)
 
         schedule();
 }
+#ifdef __ARCH_SI_TRAPNO
+# define ___ARCH_SI_TRAPNO(_a1) , _a1
+#else
+# define ___ARCH_SI_TRAPNO(_a1)
+#endif
+#ifdef __ia64__
+# define ___ARCH_SI_IA64(_a1, _a2, _a3) , _a1, _a2, _a3
+#else
+# define ___ARCH_SI_IA64(_a1, _a2, _a3)
+#endif
+
+int force_sig_fault(int sig, int code, void __user *addr
+        ___ARCH_SI_TRAPNO(int trapno)
+        ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
+        , struct task_struct *t);
+int send_sig_fault(int sig, int code, void __user *addr
+        ___ARCH_SI_TRAPNO(int trapno)
+        ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
+        , struct task_struct *t);
+
+int force_sig_mceerr(int code, void __user *, short, struct task_struct *);
+int send_sig_mceerr(int code, void __user *, short, struct task_struct *);
+
+int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper);
+int force_sig_pkuerr(void __user *addr, u32 pkey);
+
+int force_sig_ptrace_errno_trap(int errno, void __user *addr);
+
 extern int send_sig_info(int, struct siginfo *, struct task_struct *);
 extern int force_sigsegv(int, struct task_struct *);
 extern int force_sig_info(int, struct siginfo *, struct task_struct *);
diff --git a/include/linux/sched/task.h b/include/linux/sched/task.h
index 05b8650f06f5..5be31eb7b266 100644
--- a/include/linux/sched/task.h
+++ b/include/linux/sched/task.h
@@ -104,6 +104,20 @@ extern int arch_task_struct_size __read_mostly;
 # define arch_task_struct_size (sizeof(struct task_struct))
 #endif
 
+#ifndef CONFIG_HAVE_ARCH_THREAD_STRUCT_WHITELIST
+/*
+ * If an architecture has not declared a thread_struct whitelist we
+ * must assume something there may need to be copied to userspace.
+ */
+static inline void arch_thread_struct_whitelist(unsigned long *offset,
+                                                unsigned long *size)
+{
+        *offset = 0;
+        /* Handle dynamically sized thread_struct. */
+        *size = arch_task_struct_size - offsetof(struct task_struct, thread);
+}
+#endif
+
 #ifdef CONFIG_VMAP_STACK
 static inline struct vm_struct *task_stack_vm_area(const struct task_struct *t)
 {
diff --git a/include/linux/sched/task_stack.h b/include/linux/sched/task_stack.h
index cb4828aaa34f..6a841929073f 100644
--- a/include/linux/sched/task_stack.h
+++ b/include/linux/sched/task_stack.h
@@ -78,7 +78,7 @@ static inline void put_task_stack(struct task_struct *tsk) {}
 #define task_stack_end_corrupted(task) \
                 (*(end_of_stack(task)) != STACK_END_MAGIC)
 
-static inline int object_is_on_stack(void *obj)
+static inline int object_is_on_stack(const void *obj)
 {
         void *stack = task_stack_page(current);
 
diff --git a/include/linux/sched/topology.h b/include/linux/sched/topology.h
index cf257c2e728d..26347741ba50 100644
--- a/include/linux/sched/topology.h
+++ b/include/linux/sched/topology.h
@@ -7,6 +7,12 @@
 #include <linux/sched/idle.h>
 
 /*
+ * Increase resolution of cpu_capacity calculations
+ */
+#define SCHED_CAPACITY_SHIFT    SCHED_FIXEDPOINT_SHIFT
+#define SCHED_CAPACITY_SCALE    (1L << SCHED_CAPACITY_SHIFT)
+
+/*
  * sched-domains (multiprocessor balancing) declarations:
  */
 #ifdef CONFIG_SMP
@@ -27,12 +33,6 @@
 #define SD_OVERLAP              0x2000  /* sched_domains of this level overlap */
 #define SD_NUMA                 0x4000  /* cross-node balancing */
 
-/*
- * Increase resolution of cpu_capacity calculations
- */
-#define SCHED_CAPACITY_SHIFT    SCHED_FIXEDPOINT_SHIFT
-#define SCHED_CAPACITY_SCALE    (1L << SCHED_CAPACITY_SHIFT)
-
 #ifdef CONFIG_SCHED_SMT
 static inline int cpu_smt_flags(void)
 {
diff --git a/include/linux/scif.h b/include/linux/scif.h
index 49a35d6edc94..7046111b8d0a 100644
--- a/include/linux/scif.h
+++ b/include/linux/scif.h
@@ -123,8 +123,8 @@ struct scif_range {
  */
 struct scif_pollepd {
         scif_epd_t epd;
-        short events;
-        short revents;
+        __poll_t events;
+        __poll_t revents;
 };
 
 /**
diff --git a/include/linux/sctp.h b/include/linux/sctp.h
index da803dfc7a39..b36c76635f18 100644
--- a/include/linux/sctp.h
+++ b/include/linux/sctp.h
@@ -102,11 +102,15 @@ enum sctp_cid {
         /* AUTH Extension Section 4.1 */
         SCTP_CID_AUTH                   = 0x0F,
 
+        /* sctp ndata 5.1. I-DATA */
+        SCTP_CID_I_DATA                 = 0x40,
+
         /* PR-SCTP Sec 3.2 */
         SCTP_CID_FWD_TSN                = 0xC0,
 
         /* Use hex, as defined in ADDIP sec. 3.1 */
         SCTP_CID_ASCONF                 = 0xC1,
+        SCTP_CID_I_FWD_TSN              = 0xC2,
         SCTP_CID_ASCONF_ACK             = 0x80,
         SCTP_CID_RECONF                 = 0x82,
 }; /* enum */
@@ -240,6 +244,23 @@ struct sctp_data_chunk {
         struct sctp_datahdr data_hdr;
 };
 
+struct sctp_idatahdr {
+        __be32 tsn;
+        __be16 stream;
+        __be16 reserved;
+        __be32 mid;
+        union {
+                __u32 ppid;
+                __be32 fsn;
+        };
+        __u8 payload[0];
+};
+
+struct sctp_idata_chunk {
+        struct sctp_chunkhdr chunk_hdr;
+        struct sctp_idatahdr data_hdr;
+};
+
 /* DATA Chuck Specific Flags */
 enum {
         SCTP_DATA_MIDDLE_FRAG   = 0x00,
@@ -596,6 +617,22 @@ struct sctp_fwdtsn_chunk {
         struct sctp_fwdtsn_hdr fwdtsn_hdr;
 };
 
+struct sctp_ifwdtsn_skip {
+        __be16 stream;
+        __u8 reserved;
+        __u8 flags;
+        __be32 mid;
+};
+
+struct sctp_ifwdtsn_hdr {
+        __be32 new_cum_tsn;
+        struct sctp_ifwdtsn_skip skip[0];
+};
+
+struct sctp_ifwdtsn_chunk {
+        struct sctp_chunkhdr chunk_hdr;
+        struct sctp_ifwdtsn_hdr fwdtsn_hdr;
+};
 
 /* ADDIP
  * Section 3.1.1 Address Configuration Change Chunk (ASCONF)
diff --git a/include/linux/seccomp.h b/include/linux/seccomp.h
index 10f25f7e4304..c723a5c4e3ff 100644
--- a/include/linux/seccomp.h
+++ b/include/linux/seccomp.h
@@ -95,11 +95,19 @@ static inline void get_seccomp_filter(struct task_struct *tsk)
 #if defined(CONFIG_SECCOMP_FILTER) && defined(CONFIG_CHECKPOINT_RESTORE)
 extern long seccomp_get_filter(struct task_struct *task,
                                unsigned long filter_off, void __user *data);
+extern long seccomp_get_metadata(struct task_struct *task,
+                                 unsigned long filter_off, void __user *data);
 #else
 static inline long seccomp_get_filter(struct task_struct *task,
                                       unsigned long n, void __user *data)
 {
         return -EINVAL;
 }
+static inline long seccomp_get_metadata(struct task_struct *task,
+                                        unsigned long filter_off,
+                                        void __user *data)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_SECCOMP_FILTER && CONFIG_CHECKPOINT_RESTORE */
 #endif /* _LINUX_SECCOMP_H */
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 09c6e28746f9..ab437dd2e3b9 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -140,6 +140,20 @@ void *__seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_open_private(struct file *, const struct seq_operations *, int);
 int seq_release_private(struct inode *, struct file *);
 
+#define DEFINE_SHOW_ATTRIBUTE(__name)                                   \
+static int __name ## _open(struct inode *inode, struct file *file)      \
+{                                                                       \
+        return single_open(file, __name ## _show, inode->i_private);    \
+}                                                                       \
+                                                                        \
+static const struct file_operations __name ## _fops = {                 \
+        .owner          = THIS_MODULE,                                  \
+        .open           = __name ## _open,                              \
+        .read           = seq_read,                                     \
+        .llseek         = seq_lseek,                                    \
+        .release        = single_release,                               \
+}
+
 static inline struct user_namespace *seq_user_ns(struct seq_file *seq)
 {
 #ifdef CONFIG_USER_NS
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index f189a8a3bbb8..bcf4cf26b8c8 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -278,9 +278,8 @@ static inline void raw_write_seqcount_barrier(seqcount_t *s)
 
 static inline int raw_read_seqcount_latch(seqcount_t *s)
 {
-        int seq = READ_ONCE(s->sequence);
         /* Pairs with the first smp_wmb() in raw_write_seqcount_latch() */
-        smp_read_barrier_depends();
+        int seq = READ_ONCE(s->sequence); /* ^^^ */
         return seq;
 }
 
diff --git a/include/linux/serdev.h b/include/linux/serdev.h
index d609e6dc5bad..f153b2c7f0cd 100644
--- a/include/linux/serdev.h
+++ b/include/linux/serdev.h
@@ -27,8 +27,10 @@ struct serdev_device;
 
 /**
  * struct serdev_device_ops - Callback operations for a serdev device
- * @receive_buf:        Function called with data received from device.
- * @write_wakeup:       Function called when ready to transmit more data.
+ * @receive_buf:        Function called with data received from device;
+ *                      returns number of bytes accepted; may sleep.
+ * @write_wakeup:       Function called when ready to transmit more data; must
+ *                      not sleep.
  */
 struct serdev_device_ops {
         int (*receive_buf)(struct serdev_device *, const unsigned char *, size_t);
@@ -76,6 +78,12 @@ static inline struct serdev_device_driver *to_serdev_device_driver(struct device
         return container_of(d, struct serdev_device_driver, driver);
 }
 
+enum serdev_parity {
+        SERDEV_PARITY_NONE,
+        SERDEV_PARITY_EVEN,
+        SERDEV_PARITY_ODD,
+};
+
 /*
  * serdev controller structures
  */
@@ -86,6 +94,7 @@ struct serdev_controller_ops {
         int (*open)(struct serdev_controller *);
         void (*close)(struct serdev_controller *);
         void (*set_flow_control)(struct serdev_controller *, bool);
+        int (*set_parity)(struct serdev_controller *, enum serdev_parity);
         unsigned int (*set_baudrate)(struct serdev_controller *, unsigned int);
         void (*wait_until_sent)(struct serdev_controller *, long);
         int (*get_tiocm)(struct serdev_controller *);
@@ -193,6 +202,7 @@ static inline int serdev_controller_receive_buf(struct serdev_controller *ctrl,
 
 int serdev_device_open(struct serdev_device *);
 void serdev_device_close(struct serdev_device *);
+int devm_serdev_device_open(struct device *, struct serdev_device *);
 unsigned int serdev_device_set_baudrate(struct serdev_device *, unsigned int);
 void serdev_device_set_flow_control(struct serdev_device *, bool);
 int serdev_device_write_buf(struct serdev_device *, const unsigned char *, size_t);
@@ -298,6 +308,9 @@ static inline int serdev_device_set_rts(struct serdev_device *serdev, bool enabl
                 return serdev_device_set_tiocm(serdev, 0, TIOCM_RTS);
 }
 
+int serdev_device_set_parity(struct serdev_device *serdev,
+                             enum serdev_parity parity);
+
 /*
  * serdev hooks into TTY core
  */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index aefd0e5115da..b32df49a3bd5 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -387,7 +387,7 @@ struct uart_port *uart_get_console(struct uart_port *ports, int nr,
                                    struct console *c);
 int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr,
                         char **options);
-void uart_parse_options(char *options, int *baud, int *parity, int *bits,
+void uart_parse_options(const char *options, int *baud, int *parity, int *bits,
                         int *flow);
 int uart_set_options(struct uart_port *port, struct console *co, int baud,
                      int parity, int bits, int flow);
@@ -501,9 +501,5 @@ static inline int uart_handle_break(struct uart_port *port)
                                          (cflag) & CRTSCTS || \
                                          !((cflag) & CLOCAL))
 
-/*
- * Common device tree parsing helpers
- */
-void of_get_rs485_mode(struct device_node *np, struct serial_rs485 *rs485conf);
-
+void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf);
 #endif /* LINUX_SERIAL_CORE_H */
diff --git a/include/linux/sfp.h b/include/linux/sfp.h
index 4a906f560817..e724d5a3dd80 100644
--- a/include/linux/sfp.h
+++ b/include/linux/sfp.h
@@ -3,7 +3,7 @@
 
 #include <linux/phy.h>
 
-struct __packed sfp_eeprom_base {
+struct sfp_eeprom_base {
         u8 phys_id;
         u8 phys_ext_id;
         u8 connector;
@@ -165,13 +165,47 @@ struct __packed sfp_eeprom_base {
         char vendor_rev[4];
         union {
                 __be16 optical_wavelength;
-                u8 cable_spec;
-        };
+                __be16 cable_compliance;
+                struct {
+#if defined __BIG_ENDIAN_BITFIELD
+                        u8 reserved60_2:6;
+                        u8 fc_pi_4_app_h:1;
+                        u8 sff8431_app_e:1;
+                        u8 reserved61:8;
+#elif defined __LITTLE_ENDIAN_BITFIELD
+                        u8 sff8431_app_e:1;
+                        u8 fc_pi_4_app_h:1;
+                        u8 reserved60_2:6;
+                        u8 reserved61:8;
+#else
+#error Unknown Endian
+#endif
+                } __packed passive;
+                struct {
+#if defined __BIG_ENDIAN_BITFIELD
+                        u8 reserved60_4:4;
+                        u8 fc_pi_4_lim:1;
+                        u8 sff8431_lim:1;
+                        u8 fc_pi_4_app_h:1;
+                        u8 sff8431_app_e:1;
+                        u8 reserved61:8;
+#elif defined __LITTLE_ENDIAN_BITFIELD
+                        u8 sff8431_app_e:1;
+                        u8 fc_pi_4_app_h:1;
+                        u8 sff8431_lim:1;
+                        u8 fc_pi_4_lim:1;
+                        u8 reserved60_4:4;
+                        u8 reserved61:8;
+#else
+#error Unknown Endian
+#endif
+                } __packed active;
+        } __packed;
         u8 reserved62;
         u8 cc_base;
-};
+} __packed;
 
-struct __packed sfp_eeprom_ext {
+struct sfp_eeprom_ext {
         __be16 options;
         u8 br_max;
         u8 br_min;
@@ -181,12 +215,21 @@ struct __packed sfp_eeprom_ext {
         u8 enhopts;
         u8 sff8472_compliance;
         u8 cc_ext;
-};
-
-struct __packed sfp_eeprom_id {
+} __packed;
+
+/**
+ * struct sfp_eeprom_id - raw SFP module identification information
+ * @base: base SFP module identification structure
+ * @ext: extended SFP module identification structure
+ *
+ * See the SFF-8472 specification and related documents for the definition
+ * of these structure members. This can be obtained from
+ * ftp://ftp.seagate.com/sff
+ */
+struct sfp_eeprom_id {
         struct sfp_eeprom_base base;
         struct sfp_eeprom_ext ext;
-};
+} __packed;
 
 /* SFP EEPROM registers */
 enum {
@@ -222,6 +265,7 @@ enum {
         SFP_SFF8472_COMPLIANCE          = 0x5e,
         SFP_CC_EXT                      = 0x5f,
 
+        SFP_PHYS_ID_SFF                 = 0x02,
         SFP_PHYS_ID_SFP                 = 0x03,
         SFP_PHYS_EXT_ID_SFP             = 0x04,
         SFP_CONNECTOR_UNSPEC            = 0x00,
@@ -347,19 +391,32 @@ enum {
         SFP_PAGE                        = 0x7f,
 };
 
-struct device_node;
+struct fwnode_handle;
 struct ethtool_eeprom;
 struct ethtool_modinfo;
 struct net_device;
 struct sfp_bus;
 
+/**
+ * struct sfp_upstream_ops - upstream operations structure
+ * @module_insert: called after a module has been detected to determine
+ *   whether the module is supported for the upstream device.
+ * @module_remove: called after the module has been removed.
+ * @link_down: called when the link is non-operational for whatever
+ *   reason.
+ * @link_up: called when the link is operational.
+ * @connect_phy: called when an I2C accessible PHY has been detected
+ *   on the module.
+ * @disconnect_phy: called when a module with an I2C accessible PHY has
+ *   been removed.
+ */
 struct sfp_upstream_ops {
-        int (*module_insert)(void *, const struct sfp_eeprom_id *id);
-        void (*module_remove)(void *);
-        void (*link_down)(void *);
-        void (*link_up)(void *);
-        int (*connect_phy)(void *, struct phy_device *);
-        void (*disconnect_phy)(void *);
+        int (*module_insert)(void *priv, const struct sfp_eeprom_id *id);
+        void (*module_remove)(void *priv);
+        void (*link_down)(void *priv);
+        void (*link_up)(void *priv);
+        int (*connect_phy)(void *priv, struct phy_device *);
+        void (*disconnect_phy)(void *priv);
 };
 
 #if IS_ENABLED(CONFIG_SFP)
@@ -375,7 +432,7 @@ int sfp_get_module_eeprom(struct sfp_bus *bus, struct ethtool_eeprom *ee,
                           u8 *data);
 void sfp_upstream_start(struct sfp_bus *bus);
 void sfp_upstream_stop(struct sfp_bus *bus);
-struct sfp_bus *sfp_register_upstream(struct device_node *np,
+struct sfp_bus *sfp_register_upstream(struct fwnode_handle *fwnode,
                                       struct net_device *ndev, void *upstream,
                                       const struct sfp_upstream_ops *ops);
 void sfp_unregister_upstream(struct sfp_bus *bus);
@@ -419,7 +476,8 @@ static inline void sfp_upstream_stop(struct sfp_bus *bus)
 {
 }
 
-static inline struct sfp_bus *sfp_register_upstream(struct device_node *np,
+static inline struct sfp_bus *sfp_register_upstream(
+        struct fwnode_handle *fwnode,
         struct net_device *ndev, void *upstream,
         const struct sfp_upstream_ops *ops)
 {
diff --git a/include/linux/sh_eth.h b/include/linux/sh_eth.h
index 94081e9a5010..6dfda97a6c1a 100644
--- a/include/linux/sh_eth.h
+++ b/include/linux/sh_eth.h
@@ -5,12 +5,9 @@
 #include <linux/phy.h>
 #include <linux/if_ether.h>
 
-enum {EDMAC_LITTLE_ENDIAN};
-
 struct sh_eth_plat_data {
         int phy;
         int phy_irq;
-        int edmac_endian;
         phy_interface_t phy_interface;
         void (*set_mdio_gate)(void *addr);
 
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index 06b295bec00d..73b5e655a76e 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -112,13 +112,11 @@ extern void shmem_uncharge(struct inode *inode, long pages);
 
 #ifdef CONFIG_TMPFS
 
-extern int shmem_add_seals(struct file *file, unsigned int seals);
-extern int shmem_get_seals(struct file *file);
-extern long shmem_fcntl(struct file *file, unsigned int cmd, unsigned long arg);
+extern long memfd_fcntl(struct file *file, unsigned int cmd, unsigned long arg);
 
 #else
 
-static inline long shmem_fcntl(struct file *f, unsigned int c, unsigned long a)
+static inline long memfd_fcntl(struct file *f, unsigned int c, unsigned long a)
 {
         return -EINVAL;
 }
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 042968dd98f0..a9bc7e1b077e 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -11,13 +11,14 @@ struct task_struct;
 /* for sysctl */
 extern int print_fatal_signals;
 
-static inline void copy_siginfo(struct siginfo *to, struct siginfo *from)
+static inline void copy_siginfo(struct siginfo *to, const struct siginfo *from)
 {
-        if (from->si_code < 0)
-                memcpy(to, from, sizeof(*to));
-        else
-                /* _sigchld is currently the largest know union member */
-                memcpy(to, from, __ARCH_SI_PREAMBLE_SIZE + sizeof(from->_sifields._sigchld));
+        memcpy(to, from, sizeof(*to));
+}
+
+static inline void clear_siginfo(struct siginfo *info)
+{
+        memset(info, 0, sizeof(*info));
 }
 
 int copy_siginfo_to_user(struct siginfo __user *to, const struct siginfo *from);
@@ -29,9 +30,7 @@ enum siginfo_layout {
         SIL_FAULT,
         SIL_CHLD,
         SIL_RT,
-#ifdef __ARCH_SIGSYS
         SIL_SYS,
-#endif
 };
 
 enum siginfo_layout siginfo_layout(int sig, int si_code);
diff --git a/include/linux/siox.h b/include/linux/siox.h
new file mode 100644
index 000000000000..d79624e83134
--- /dev/null
+++ b/include/linux/siox.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2015 Pengutronix, Uwe Kleine-König <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 2 as published by the
+ * Free Software Foundation.
+ */
+
+#include <linux/device.h>
+
+#define to_siox_device(_dev)    container_of((_dev), struct siox_device, dev)
+struct siox_device {
+        struct list_head node; /* node in smaster->devices */
+        struct siox_master *smaster;
+        struct device dev;
+
+        const char *type;
+        size_t inbytes;
+        size_t outbytes;
+        u8 statustype;
+
+        u8 status_read_clean;
+        u8 status_written;
+        u8 status_written_lastcycle;
+        bool connected;
+
+        /* statistics */
+        unsigned int watchdog_errors;
+        unsigned int status_errors;
+
+        struct kernfs_node *status_errors_kn;
+        struct kernfs_node *watchdog_kn;
+        struct kernfs_node *watchdog_errors_kn;
+        struct kernfs_node *connected_kn;
+};
+
+bool siox_device_synced(struct siox_device *sdevice);
+bool siox_device_connected(struct siox_device *sdevice);
+
+struct siox_driver {
+        int (*probe)(struct siox_device *sdevice);
+        int (*remove)(struct siox_device *sdevice);
+        void (*shutdown)(struct siox_device *sdevice);
+
+        /*
+         * buf is big enough to hold sdev->inbytes - 1 bytes, the status byte
+         * is in the scope of the framework.
+         */
+        int (*set_data)(struct siox_device *sdevice, u8 status, u8 buf[]);
+        /*
+         * buf is big enough to hold sdev->outbytes - 1 bytes, the status byte
+         * is in the scope of the framework
+         */
+        int (*get_data)(struct siox_device *sdevice, const u8 buf[]);
+
+        struct device_driver driver;
+};
+
+static inline struct siox_driver *to_siox_driver(struct device_driver *driver)
+{
+        if (driver)
+                return container_of(driver, struct siox_driver, driver);
+        else
+                return NULL;
+}
+
+int __siox_driver_register(struct siox_driver *sdriver, struct module *owner);
+
+static inline int siox_driver_register(struct siox_driver *sdriver)
+{
+        return __siox_driver_register(sdriver, THIS_MODULE);
+}
+
+static inline void siox_driver_unregister(struct siox_driver *sdriver)
+{
+        return driver_unregister(&sdriver->driver);
+}
diff --git a/include/linux/skb_array.h b/include/linux/skb_array.h
index 8621ffdeecbf..a6b6e8bb3d7b 100644
--- a/include/linux/skb_array.h
+++ b/include/linux/skb_array.h
@@ -69,7 +69,12 @@ static inline int skb_array_produce_any(struct skb_array *a, struct sk_buff *skb
  */
 static inline bool __skb_array_empty(struct skb_array *a)
 {
-        return !__ptr_ring_peek(&a->ring);
+        return __ptr_ring_empty(&a->ring);
+}
+
+static inline struct sk_buff *__skb_array_peek(struct skb_array *a)
+{
+        return __ptr_ring_peek(&a->ring);
 }
 
 static inline bool skb_array_empty(struct skb_array *a)
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index a38c80e9f91e..5ebc0f869720 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1211,6 +1211,11 @@ static inline bool skb_flow_dissect_flow_keys_buf(struct flow_keys *flow,
                                   data, proto, nhoff, hlen, flags);
 }
 
+void
+skb_flow_dissect_tunnel_info(const struct sk_buff *skb,
+                             struct flow_dissector *flow_dissector,
+                             void *target_container);
+
 static inline __u32 skb_get_hash(struct sk_buff *skb)
 {
         if (!skb->l4_hash && !skb->sw_hash)
@@ -3241,7 +3246,7 @@ struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
                                     int *peeked, int *off, int *err);
 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock,
                                   int *err);
-unsigned int datagram_poll(struct file *file, struct socket *sock,
+__poll_t datagram_poll(struct file *file, struct socket *sock,
                            struct poll_table_struct *wait);
 int skb_copy_datagram_iter(const struct sk_buff *from, int offset,
                            struct iov_iter *to, int size);
@@ -3282,6 +3287,7 @@ int skb_shift(struct sk_buff *tgt, struct sk_buff *skb, int shiftlen);
 void skb_scrub_packet(struct sk_buff *skb, bool xnet);
 unsigned int skb_gso_transport_seglen(const struct sk_buff *skb);
 bool skb_gso_validate_mtu(const struct sk_buff *skb, unsigned int mtu);
+bool skb_gso_validate_mac_len(const struct sk_buff *skb, unsigned int len);
 struct sk_buff *skb_segment(struct sk_buff *skb, netdev_features_t features);
 struct sk_buff *skb_vlan_untag(struct sk_buff *skb);
 int skb_ensure_writable(struct sk_buff *skb, int write_len);
@@ -4115,6 +4121,21 @@ static inline unsigned int skb_gso_network_seglen(const struct sk_buff *skb)
         return hdr_len + skb_gso_transport_seglen(skb);
 }
 
+/**
+ * skb_gso_mac_seglen - Return length of individual segments of a gso packet
+ *
+ * @skb: GSO skb
+ *
+ * skb_gso_mac_seglen is used to determine the real size of the
+ * individual segments, including MAC/L2, Layer3 (IP, IPv6) and L4
+ * headers (TCP/UDP).
+ */
+static inline unsigned int skb_gso_mac_seglen(const struct sk_buff *skb)
+{
+        unsigned int hdr_len = skb_transport_header(skb) - skb_mac_header(skb);
+        return hdr_len + skb_gso_transport_seglen(skb);
+}
+
 /* Local Checksum Offload.
  * Compute outer checksum based on the assumption that the
  * inner checksum will be offloaded later.
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 50697a1d6621..231abc8976c5 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -135,9 +135,15 @@ struct mem_cgroup;
 void __init kmem_cache_init(void);
 bool slab_is_available(void);
 
-struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
-                        slab_flags_t,
-                        void (*)(void *));
+extern bool usercopy_fallback;
+
+struct kmem_cache *kmem_cache_create(const char *name, size_t size,
+                        size_t align, slab_flags_t flags,
+                        void (*ctor)(void *));
+struct kmem_cache *kmem_cache_create_usercopy(const char *name,
+                        size_t size, size_t align, slab_flags_t flags,
+                        size_t useroffset, size_t usersize,
+                        void (*ctor)(void *));
 void kmem_cache_destroy(struct kmem_cache *);
 int kmem_cache_shrink(struct kmem_cache *);
 
@@ -153,9 +159,20 @@ void memcg_destroy_kmem_caches(struct mem_cgroup *);
  * f.e. add ____cacheline_aligned_in_smp to the struct declaration
  * then the objects will be properly aligned in SMP configurations.
  */
-#define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
-                sizeof(struct __struct), __alignof__(struct __struct),\
-                (__flags), NULL)
+#define KMEM_CACHE(__struct, __flags)                                   \
+                kmem_cache_create(#__struct, sizeof(struct __struct),   \
+                        __alignof__(struct __struct), (__flags), NULL)
+
+/*
+ * To whitelist a single field for copying to/from usercopy, use this
+ * macro instead for KMEM_CACHE() above.
+ */
+#define KMEM_CACHE_USERCOPY(__struct, __flags, __field)                 \
+                kmem_cache_create_usercopy(#__struct,                   \
+                        sizeof(struct __struct),                        \
+                        __alignof__(struct __struct), (__flags),        \
+                        offsetof(struct __struct, __field),             \
+                        sizeof_field(struct __struct, __field), NULL)
 
 /*
  * Common kmalloc functions provided by all allocators
@@ -167,15 +184,11 @@ void kzfree(const void *);
 size_t ksize(const void *);
 
 #ifdef CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR
-const char *__check_heap_object(const void *ptr, unsigned long n,
-                                struct page *page);
+void __check_heap_object(const void *ptr, unsigned long n, struct page *page,
+                        bool to_user);
 #else
-static inline const char *__check_heap_object(const void *ptr,
-                                              unsigned long n,
-                                              struct page *page)
-{
-        return NULL;
-}
+static inline void __check_heap_object(const void *ptr, unsigned long n,
+                                       struct page *page, bool to_user) { }
 #endif
 
 /*
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 072e46e9e1d5..7385547c04b1 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -85,6 +85,9 @@ struct kmem_cache {
         unsigned int *random_seq;
 #endif
 
+        size_t useroffset;              /* Usercopy region offset */
+        size_t usersize;                /* Usercopy region size */
+
         struct kmem_cache_node *node[MAX_NUMNODES];
 };
 
diff --git a/include/linux/slimbus.h b/include/linux/slimbus.h
new file mode 100644
index 000000000000..c36cf121d2cd
--- /dev/null
+++ b/include/linux/slimbus.h
@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2011-2017, The Linux Foundation
+ */
+
+#ifndef _LINUX_SLIMBUS_H
+#define _LINUX_SLIMBUS_H
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/completion.h>
+#include <linux/mod_devicetable.h>
+
+extern struct bus_type slimbus_bus;
+
+/**
+ * struct slim_eaddr - Enumeration address for a SLIMbus device
+ * @manf_id: Manufacturer Id for the device
+ * @prod_code: Product code
+ * @dev_index: Device index
+ * @instance: Instance value
+ */
+struct slim_eaddr {
+        u16 manf_id;
+        u16 prod_code;
+        u8 dev_index;
+        u8 instance;
+} __packed;
+
+/**
+ * enum slim_device_status - slim device status
+ * @SLIM_DEVICE_STATUS_DOWN: Slim device is absent or not reported yet.
+ * @SLIM_DEVICE_STATUS_UP: Slim device is announced on the bus.
+ * @SLIM_DEVICE_STATUS_RESERVED: Reserved for future use.
+ */
+enum slim_device_status {
+        SLIM_DEVICE_STATUS_DOWN = 0,
+        SLIM_DEVICE_STATUS_UP,
+        SLIM_DEVICE_STATUS_RESERVED,
+};
+
+struct slim_controller;
+
+/**
+ * struct slim_device - Slim device handle.
+ * @dev: Driver model representation of the device.
+ * @e_addr: Enumeration address of this device.
+ * @status: slim device status
+ * @ctrl: slim controller instance.
+ * @laddr: 1-byte Logical address of this device.
+ * @is_laddr_valid: indicates if the laddr is valid or not
+ *
+ * This is the client/device handle returned when a SLIMbus
+ * device is registered with a controller.
+ * Pointer to this structure is used by client-driver as a handle.
+ */
+struct slim_device {
+        struct device           dev;
+        struct slim_eaddr       e_addr;
+        struct slim_controller  *ctrl;
+        enum slim_device_status status;
+        u8                      laddr;
+        bool                    is_laddr_valid;
+};
+
+#define to_slim_device(d) container_of(d, struct slim_device, dev)
+
+/**
+ * struct slim_driver - SLIMbus 'generic device' (slave) device driver
+ *                              (similar to 'spi_device' on SPI)
+ * @probe: Binds this driver to a SLIMbus device.
+ * @remove: Unbinds this driver from the SLIMbus device.
+ * @shutdown: Standard shutdown callback used during powerdown/halt.
+ * @device_status: This callback is called when
+ *      - The device reports present and gets a laddr assigned
+ *      - The device reports absent, or the bus goes down.
+ * @driver: SLIMbus device drivers should initialize name and owner field of
+ *          this structure
+ * @id_table: List of SLIMbus devices supported by this driver
+ */
+
+struct slim_driver {
+        int     (*probe)(struct slim_device *sl);
+        void    (*remove)(struct slim_device *sl);
+        void    (*shutdown)(struct slim_device *sl);
+        int     (*device_status)(struct slim_device *sl,
+                                 enum slim_device_status s);
+        struct device_driver            driver;
+        const struct slim_device_id     *id_table;
+};
+#define to_slim_driver(d) container_of(d, struct slim_driver, driver)
+
+/**
+ * struct slim_val_inf - Slimbus value or information element
+ * @start_offset: Specifies starting offset in information/value element map
+ * @rbuf: buffer to read the values
+ * @wbuf: buffer to write
+ * @num_bytes: upto 16. This ensures that the message will fit the slicesize
+ *              per SLIMbus spec
+ * @comp: completion for asynchronous operations, valid only if TID is
+ *        required for transaction, like REQUEST operations.
+ *        Rest of the transactions are synchronous anyway.
+ */
+struct slim_val_inf {
+        u16                     start_offset;
+        u8                      num_bytes;
+        u8                      *rbuf;
+        const u8                *wbuf;
+        struct  completion      *comp;
+};
+
+/*
+ * use a macro to avoid include chaining to get THIS_MODULE
+ */
+#define slim_driver_register(drv) \
+        __slim_driver_register(drv, THIS_MODULE)
+int __slim_driver_register(struct slim_driver *drv, struct module *owner);
+void slim_driver_unregister(struct slim_driver *drv);
+
+/**
+ * module_slim_driver() - Helper macro for registering a SLIMbus driver
+ * @__slim_driver: slimbus_driver struct
+ *
+ * Helper macro for SLIMbus drivers which do not 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_slim_driver(__slim_driver) \
+        module_driver(__slim_driver, slim_driver_register, \
+                        slim_driver_unregister)
+
+static inline void *slim_get_devicedata(const struct slim_device *dev)
+{
+        return dev_get_drvdata(&dev->dev);
+}
+
+static inline void slim_set_devicedata(struct slim_device *dev, void *data)
+{
+        dev_set_drvdata(&dev->dev, data);
+}
+
+struct slim_device *slim_get_device(struct slim_controller *ctrl,
+                                    struct slim_eaddr *e_addr);
+int slim_get_logical_addr(struct slim_device *sbdev);
+
+/* Information Element management messages */
+#define SLIM_MSG_MC_REQUEST_INFORMATION          0x20
+#define SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION    0x21
+#define SLIM_MSG_MC_REPLY_INFORMATION            0x24
+#define SLIM_MSG_MC_CLEAR_INFORMATION            0x28
+#define SLIM_MSG_MC_REPORT_INFORMATION           0x29
+
+/* Value Element management messages */
+#define SLIM_MSG_MC_REQUEST_VALUE                0x60
+#define SLIM_MSG_MC_REQUEST_CHANGE_VALUE         0x61
+#define SLIM_MSG_MC_REPLY_VALUE                  0x64
+#define SLIM_MSG_MC_CHANGE_VALUE                 0x68
+
+int slim_xfer_msg(struct slim_device *sbdev, struct slim_val_inf *msg,
+                  u8 mc);
+int slim_readb(struct slim_device *sdev, u32 addr);
+int slim_writeb(struct slim_device *sdev, u32 addr, u8 value);
+int slim_read(struct slim_device *sdev, u32 addr, size_t count, u8 *val);
+int slim_write(struct slim_device *sdev, u32 addr, size_t count, u8 *val);
+#endif /* _LINUX_SLIMBUS_H */
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 0adae162dc8f..8ad99c47b19c 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -135,6 +135,9 @@ struct kmem_cache {
         struct kasan_cache kasan_info;
 #endif
 
+        size_t useroffset;              /* Usercopy region offset */
+        size_t usersize;                /* Usercopy region size */
+
         struct kmem_cache_node *node[MAX_NUMNODES];
 };
 
diff --git a/include/linux/soc/brcmstb/brcmstb.h b/include/linux/soc/brcmstb/brcmstb.h
index 12e548938bbb..8e884e0dda0a 100644
--- a/include/linux/soc/brcmstb/brcmstb.h
+++ b/include/linux/soc/brcmstb/brcmstb.h
@@ -13,12 +13,6 @@ static inline u32 BRCM_REV(u32 reg)
 }
 
 /*
- * Bus Interface Unit control register setup, must happen early during boot,
- * before SMP is brought up, called by machine entry point.
- */
-void brcmstb_biuctrl_init(void);
-
-/*
  * Helper functions for getting family or product id from the
  * SoC driver.
  */
diff --git a/include/linux/soc/mediatek/infracfg.h b/include/linux/soc/mediatek/infracfg.h
index e8d9f0d52933..b0a507d356ef 100644
--- a/include/linux/soc/mediatek/infracfg.h
+++ b/include/linux/soc/mediatek/infracfg.h
@@ -28,7 +28,8 @@
 #define MT7622_TOP_AXI_PROT_EN_WB               (BIT(2) | BIT(6) | \
                                                  BIT(7) | BIT(8))
 
-int mtk_infracfg_set_bus_protection(struct regmap *infracfg, u32 mask);
-int mtk_infracfg_clear_bus_protection(struct regmap *infracfg, u32 mask);
-
+int mtk_infracfg_set_bus_protection(struct regmap *infracfg, u32 mask,
+                bool reg_update);
+int mtk_infracfg_clear_bus_protection(struct regmap *infracfg, u32 mask,
+                bool reg_update);
 #endif /* __SOC_MEDIATEK_INFRACFG_H */
diff --git a/include/linux/soc/qcom/qmi.h b/include/linux/soc/qcom/qmi.h
new file mode 100644
index 000000000000..f4de33654a60
--- /dev/null
+++ b/include/linux/soc/qcom/qmi.h
@@ -0,0 +1,271 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017, Linaro Ltd.
+ */
+#ifndef __QMI_HELPERS_H__
+#define __QMI_HELPERS_H__
+
+#include <linux/completion.h>
+#include <linux/idr.h>
+#include <linux/list.h>
+#include <linux/qrtr.h>
+#include <linux/types.h>
+#include <linux/workqueue.h>
+
+struct socket;
+
+/**
+ * qmi_header - wireformat header of QMI messages
+ * @type:       type of message
+ * @txn_id:     transaction id
+ * @msg_id:     message id
+ * @msg_len:    length of message payload following header
+ */
+struct qmi_header {
+        u8 type;
+        u16 txn_id;
+        u16 msg_id;
+        u16 msg_len;
+} __packed;
+
+#define QMI_REQUEST     0
+#define QMI_RESPONSE    2
+#define QMI_INDICATION  4
+
+#define QMI_COMMON_TLV_TYPE 0
+
+enum qmi_elem_type {
+        QMI_EOTI,
+        QMI_OPT_FLAG,
+        QMI_DATA_LEN,
+        QMI_UNSIGNED_1_BYTE,
+        QMI_UNSIGNED_2_BYTE,
+        QMI_UNSIGNED_4_BYTE,
+        QMI_UNSIGNED_8_BYTE,
+        QMI_SIGNED_2_BYTE_ENUM,
+        QMI_SIGNED_4_BYTE_ENUM,
+        QMI_STRUCT,
+        QMI_STRING,
+};
+
+enum qmi_array_type {
+        NO_ARRAY,
+        STATIC_ARRAY,
+        VAR_LEN_ARRAY,
+};
+
+/**
+ * struct qmi_elem_info - describes how to encode a single QMI element
+ * @data_type:  Data type of this element.
+ * @elem_len:   Array length of this element, if an array.
+ * @elem_size:  Size of a single instance of this data type.
+ * @array_type: Array type of this element.
+ * @tlv_type:   QMI message specific type to identify which element
+ *              is present in an incoming message.
+ * @offset:     Specifies the offset of the first instance of this
+ *              element in the data structure.
+ * @ei_array:   Null-terminated array of @qmi_elem_info to describe nested
+ *              structures.
+ */
+struct qmi_elem_info {
+        enum qmi_elem_type data_type;
+        u32 elem_len;
+        u32 elem_size;
+        enum qmi_array_type array_type;
+        u8 tlv_type;
+        u32 offset;
+        struct qmi_elem_info *ei_array;
+};
+
+#define QMI_RESULT_SUCCESS_V01                  0
+#define QMI_RESULT_FAILURE_V01                  1
+
+#define QMI_ERR_NONE_V01                        0
+#define QMI_ERR_MALFORMED_MSG_V01               1
+#define QMI_ERR_NO_MEMORY_V01                   2
+#define QMI_ERR_INTERNAL_V01                    3
+#define QMI_ERR_CLIENT_IDS_EXHAUSTED_V01        5
+#define QMI_ERR_INVALID_ID_V01                  41
+#define QMI_ERR_ENCODING_V01                    58
+#define QMI_ERR_INCOMPATIBLE_STATE_V01          90
+#define QMI_ERR_NOT_SUPPORTED_V01               94
+
+/**
+ * qmi_response_type_v01 - common response header (decoded)
+ * @result:     result of the transaction
+ * @error:      error value, when @result is QMI_RESULT_FAILURE_V01
+ */
+struct qmi_response_type_v01 {
+        u16 result;
+        u16 error;
+};
+
+extern struct qmi_elem_info qmi_response_type_v01_ei[];
+
+/**
+ * struct qmi_service - context to track lookup-results
+ * @service:    service type
+ * @version:    version of the @service
+ * @instance:   instance id of the @service
+ * @node:       node of the service
+ * @port:       port of the service
+ * @priv:       handle for client's use
+ * @list_node:  list_head for house keeping
+ */
+struct qmi_service {
+        unsigned int service;
+        unsigned int version;
+        unsigned int instance;
+
+        unsigned int node;
+        unsigned int port;
+
+        void *priv;
+        struct list_head list_node;
+};
+
+struct qmi_handle;
+
+/**
+ * struct qmi_ops - callbacks for qmi_handle
+ * @new_server:         inform client of a new_server lookup-result, returning
+ *                      successfully from this call causes the library to call
+ *                      @del_server as the service is removed from the
+ *                      lookup-result. @priv of the qmi_service can be used by
+ *                      the client
+ * @del_server:         inform client of a del_server lookup-result
+ * @net_reset:          inform client that the name service was restarted and
+ *                      that and any state needs to be released
+ * @msg_handler:        invoked for incoming messages, allows a client to
+ *                      override the usual QMI message handler
+ * @bye:                inform a client that all clients from a node are gone
+ * @del_client:         inform a client that a particular client is gone
+ */
+struct qmi_ops {
+        int (*new_server)(struct qmi_handle *qmi, struct qmi_service *svc);
+        void (*del_server)(struct qmi_handle *qmi, struct qmi_service *svc);
+        void (*net_reset)(struct qmi_handle *qmi);
+        void (*msg_handler)(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
+                            const void *data, size_t count);
+        void (*bye)(struct qmi_handle *qmi, unsigned int node);
+        void (*del_client)(struct qmi_handle *qmi,
+                           unsigned int node, unsigned int port);
+};
+
+/**
+ * struct qmi_txn - transaction context
+ * @qmi:        QMI handle this transaction is associated with
+ * @id:         transaction id
+ * @lock:       for synchronization between handler and waiter of messages
+ * @completion: completion object as the transaction receives a response
+ * @result:     result code for the completed transaction
+ * @ei:         description of the QMI encoded response (optional)
+ * @dest:       destination buffer to decode message into (optional)
+ */
+struct qmi_txn {
+        struct qmi_handle *qmi;
+
+        int id;
+
+        struct mutex lock;
+        struct completion completion;
+        int result;
+
+        struct qmi_elem_info *ei;
+        void *dest;
+};
+
+/**
+ * struct qmi_msg_handler - description of QMI message handler
+ * @type:       type of message
+ * @msg_id:     message id
+ * @ei:         description of the QMI encoded message
+ * @decoded_size:       size of the decoded object
+ * @fn:         function to invoke as the message is decoded
+ */
+struct qmi_msg_handler {
+        unsigned int type;
+        unsigned int msg_id;
+
+        struct qmi_elem_info *ei;
+
+        size_t decoded_size;
+        void (*fn)(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
+                   struct qmi_txn *txn, const void *decoded);
+};
+
+/**
+ * struct qmi_handle - QMI context
+ * @sock:       socket handle
+ * @sock_lock:  synchronization of @sock modifications
+ * @sq:         sockaddr of @sock
+ * @work:       work for handling incoming messages
+ * @wq:         workqueue to post @work on
+ * @recv_buf:   scratch buffer for handling incoming messages
+ * @recv_buf_size:      size of @recv_buf
+ * @lookups:            list of registered lookup requests
+ * @lookup_results:     list of lookup-results advertised to the client
+ * @services:           list of registered services (by this client)
+ * @ops:        reference to callbacks
+ * @txns:       outstanding transactions
+ * @txn_lock:   lock for modifications of @txns
+ * @handlers:   list of handlers for incoming messages
+ */
+struct qmi_handle {
+        struct socket *sock;
+        struct mutex sock_lock;
+
+        struct sockaddr_qrtr sq;
+
+        struct work_struct work;
+        struct workqueue_struct *wq;
+
+        void *recv_buf;
+        size_t recv_buf_size;
+
+        struct list_head lookups;
+        struct list_head lookup_results;
+        struct list_head services;
+
+        struct qmi_ops ops;
+
+        struct idr txns;
+        struct mutex txn_lock;
+
+        const struct qmi_msg_handler *handlers;
+};
+
+int qmi_add_lookup(struct qmi_handle *qmi, unsigned int service,
+                   unsigned int version, unsigned int instance);
+int qmi_add_server(struct qmi_handle *qmi, unsigned int service,
+                   unsigned int version, unsigned int instance);
+
+int qmi_handle_init(struct qmi_handle *qmi, size_t max_msg_len,
+                    const struct qmi_ops *ops,
+                    const struct qmi_msg_handler *handlers);
+void qmi_handle_release(struct qmi_handle *qmi);
+
+ssize_t qmi_send_request(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
+                         struct qmi_txn *txn, int msg_id, size_t len,
+                         struct qmi_elem_info *ei, const void *c_struct);
+ssize_t qmi_send_response(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
+                          struct qmi_txn *txn, int msg_id, size_t len,
+                          struct qmi_elem_info *ei, const void *c_struct);
+ssize_t qmi_send_indication(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
+                            int msg_id, size_t len, struct qmi_elem_info *ei,
+                            const void *c_struct);
+
+void *qmi_encode_message(int type, unsigned int msg_id, size_t *len,
+                         unsigned int txn_id, struct qmi_elem_info *ei,
+                         const void *c_struct);
+
+int qmi_decode_message(const void *buf, size_t len,
+                       struct qmi_elem_info *ei, void *c_struct);
+
+int qmi_txn_init(struct qmi_handle *qmi, struct qmi_txn *txn,
+                 struct qmi_elem_info *ei, void *c_struct);
+int qmi_txn_wait(struct qmi_txn *txn, unsigned long timeout);
+void qmi_txn_cancel(struct qmi_txn *txn);
+
+#endif
diff --git a/include/linux/soundwire/sdw.h b/include/linux/soundwire/sdw.h
new file mode 100644
index 000000000000..e91fdcf41049
--- /dev/null
+++ b/include/linux/soundwire/sdw.h
@@ -0,0 +1,479 @@
+// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
+// Copyright(c) 2015-17 Intel Corporation.
+
+#ifndef __SOUNDWIRE_H
+#define __SOUNDWIRE_H
+
+struct sdw_bus;
+struct sdw_slave;
+
+/* SDW spec defines and enums, as defined by MIPI 1.1. Spec */
+
+/* SDW Broadcast Device Number */
+#define SDW_BROADCAST_DEV_NUM           15
+
+/* SDW Enumeration Device Number */
+#define SDW_ENUM_DEV_NUM                0
+
+/* SDW Group Device Numbers */
+#define SDW_GROUP12_DEV_NUM             12
+#define SDW_GROUP13_DEV_NUM             13
+
+/* SDW Master Device Number, not supported yet */
+#define SDW_MASTER_DEV_NUM              14
+
+#define SDW_NUM_DEV_ID_REGISTERS        6
+
+#define SDW_MAX_DEVICES                 11
+
+/**
+ * enum sdw_slave_status - Slave status
+ * @SDW_SLAVE_UNATTACHED: Slave is not attached with the bus.
+ * @SDW_SLAVE_ATTACHED: Slave is attached with bus.
+ * @SDW_SLAVE_ALERT: Some alert condition on the Slave
+ * @SDW_SLAVE_RESERVED: Reserved for future use
+ */
+enum sdw_slave_status {
+        SDW_SLAVE_UNATTACHED = 0,
+        SDW_SLAVE_ATTACHED = 1,
+        SDW_SLAVE_ALERT = 2,
+        SDW_SLAVE_RESERVED = 3,
+};
+
+/**
+ * enum sdw_command_response - Command response as defined by SDW spec
+ * @SDW_CMD_OK: cmd was successful
+ * @SDW_CMD_IGNORED: cmd was ignored
+ * @SDW_CMD_FAIL: cmd was NACKed
+ * @SDW_CMD_TIMEOUT: cmd timedout
+ * @SDW_CMD_FAIL_OTHER: cmd failed due to other reason than above
+ *
+ * NOTE: The enum is different than actual Spec as response in the Spec is
+ * combination of ACK/NAK bits
+ *
+ * SDW_CMD_TIMEOUT/FAIL_OTHER is defined for SW use, not in spec
+ */
+enum sdw_command_response {
+        SDW_CMD_OK = 0,
+        SDW_CMD_IGNORED = 1,
+        SDW_CMD_FAIL = 2,
+        SDW_CMD_TIMEOUT = 3,
+        SDW_CMD_FAIL_OTHER = 4,
+};
+
+/*
+ * SDW properties, defined in MIPI DisCo spec v1.0
+ */
+enum sdw_clk_stop_reset_behave {
+        SDW_CLK_STOP_KEEP_STATUS = 1,
+};
+
+/**
+ * enum sdw_p15_behave - Slave Port 15 behaviour when the Master attempts a
+ * read
+ * @SDW_P15_READ_IGNORED: Read is ignored
+ * @SDW_P15_CMD_OK: Command is ok
+ */
+enum sdw_p15_behave {
+        SDW_P15_READ_IGNORED = 0,
+        SDW_P15_CMD_OK = 1,
+};
+
+/**
+ * enum sdw_dpn_type - Data port types
+ * @SDW_DPN_FULL: Full Data Port is supported
+ * @SDW_DPN_SIMPLE: Simplified Data Port as defined in spec.
+ * DPN_SampleCtrl2, DPN_OffsetCtrl2, DPN_HCtrl and DPN_BlockCtrl3
+ * are not implemented.
+ * @SDW_DPN_REDUCED: Reduced Data Port as defined in spec.
+ * DPN_SampleCtrl2, DPN_HCtrl are not implemented.
+ */
+enum sdw_dpn_type {
+        SDW_DPN_FULL = 0,
+        SDW_DPN_SIMPLE = 1,
+        SDW_DPN_REDUCED = 2,
+};
+
+/**
+ * enum sdw_clk_stop_mode - Clock Stop modes
+ * @SDW_CLK_STOP_MODE0: Slave can continue operation seamlessly on clock
+ * restart
+ * @SDW_CLK_STOP_MODE1: Slave may have entered a deeper power-saving mode,
+ * not capable of continuing operation seamlessly when the clock restarts
+ */
+enum sdw_clk_stop_mode {
+        SDW_CLK_STOP_MODE0 = 0,
+        SDW_CLK_STOP_MODE1 = 1,
+};
+
+/**
+ * struct sdw_dp0_prop - DP0 properties
+ * @max_word: Maximum number of bits in a Payload Channel Sample, 1 to 64
+ * (inclusive)
+ * @min_word: Minimum number of bits in a Payload Channel Sample, 1 to 64
+ * (inclusive)
+ * @num_words: number of wordlengths supported
+ * @words: wordlengths supported
+ * @flow_controlled: Slave implementation results in an OK_NotReady
+ * response
+ * @simple_ch_prep_sm: If channel prepare sequence is required
+ * @device_interrupts: If implementation-defined interrupts are supported
+ *
+ * The wordlengths are specified by Spec as max, min AND number of
+ * discrete values, implementation can define based on the wordlengths they
+ * support
+ */
+struct sdw_dp0_prop {
+        u32 max_word;
+        u32 min_word;
+        u32 num_words;
+        u32 *words;
+        bool flow_controlled;
+        bool simple_ch_prep_sm;
+        bool device_interrupts;
+};
+
+/**
+ * struct sdw_dpn_audio_mode - Audio mode properties for DPn
+ * @bus_min_freq: Minimum bus frequency, in Hz
+ * @bus_max_freq: Maximum bus frequency, in Hz
+ * @bus_num_freq: Number of discrete frequencies supported
+ * @bus_freq: Discrete bus frequencies, in Hz
+ * @min_freq: Minimum sampling frequency, in Hz
+ * @max_freq: Maximum sampling bus frequency, in Hz
+ * @num_freq: Number of discrete sampling frequency supported
+ * @freq: Discrete sampling frequencies, in Hz
+ * @prep_ch_behave: Specifies the dependencies between Channel Prepare
+ * sequence and bus clock configuration
+ * If 0, Channel Prepare can happen at any Bus clock rate
+ * If 1, Channel Prepare sequence shall happen only after Bus clock is
+ * changed to a frequency supported by this mode or compatible modes
+ * described by the next field
+ * @glitchless: Bitmap describing possible glitchless transitions from this
+ * Audio Mode to other Audio Modes
+ */
+struct sdw_dpn_audio_mode {
+        u32 bus_min_freq;
+        u32 bus_max_freq;
+        u32 bus_num_freq;
+        u32 *bus_freq;
+        u32 max_freq;
+        u32 min_freq;
+        u32 num_freq;
+        u32 *freq;
+        u32 prep_ch_behave;
+        u32 glitchless;
+};
+
+/**
+ * struct sdw_dpn_prop - Data Port DPn properties
+ * @num: port number
+ * @max_word: Maximum number of bits in a Payload Channel Sample, 1 to 64
+ * (inclusive)
+ * @min_word: Minimum number of bits in a Payload Channel Sample, 1 to 64
+ * (inclusive)
+ * @num_words: Number of discrete supported wordlengths
+ * @words: Discrete supported wordlength
+ * @type: Data port type. Full, Simplified or Reduced
+ * @max_grouping: Maximum number of samples that can be grouped together for
+ * a full data port
+ * @simple_ch_prep_sm: If the port supports simplified channel prepare state
+ * machine
+ * @ch_prep_timeout: Port-specific timeout value, in milliseconds
+ * @device_interrupts: If set, each bit corresponds to support for
+ * implementation-defined interrupts
+ * @max_ch: Maximum channels supported
+ * @min_ch: Minimum channels supported
+ * @num_ch: Number of discrete channels supported
+ * @ch: Discrete channels supported
+ * @num_ch_combinations: Number of channel combinations supported
+ * @ch_combinations: Channel combinations supported
+ * @modes: SDW mode supported
+ * @max_async_buffer: Number of samples that this port can buffer in
+ * asynchronous modes
+ * @block_pack_mode: Type of block port mode supported
+ * @port_encoding: Payload Channel Sample encoding schemes supported
+ * @audio_modes: Audio modes supported
+ */
+struct sdw_dpn_prop {
+        u32 num;
+        u32 max_word;
+        u32 min_word;
+        u32 num_words;
+        u32 *words;
+        enum sdw_dpn_type type;
+        u32 max_grouping;
+        bool simple_ch_prep_sm;
+        u32 ch_prep_timeout;
+        u32 device_interrupts;
+        u32 max_ch;
+        u32 min_ch;
+        u32 num_ch;
+        u32 *ch;
+        u32 num_ch_combinations;
+        u32 *ch_combinations;
+        u32 modes;
+        u32 max_async_buffer;
+        bool block_pack_mode;
+        u32 port_encoding;
+        struct sdw_dpn_audio_mode *audio_modes;
+};
+
+/**
+ * struct sdw_slave_prop - SoundWire Slave properties
+ * @mipi_revision: Spec version of the implementation
+ * @wake_capable: Wake-up events are supported
+ * @test_mode_capable: If test mode is supported
+ * @clk_stop_mode1: Clock-Stop Mode 1 is supported
+ * @simple_clk_stop_capable: Simple clock mode is supported
+ * @clk_stop_timeout: Worst-case latency of the Clock Stop Prepare State
+ * Machine transitions, in milliseconds
+ * @ch_prep_timeout: Worst-case latency of the Channel Prepare State Machine
+ * transitions, in milliseconds
+ * @reset_behave: Slave keeps the status of the SlaveStopClockPrepare
+ * state machine (P=1 SCSP_SM) after exit from clock-stop mode1
+ * @high_PHY_capable: Slave is HighPHY capable
+ * @paging_support: Slave implements paging registers SCP_AddrPage1 and
+ * SCP_AddrPage2
+ * @bank_delay_support: Slave implements bank delay/bridge support registers
+ * SCP_BankDelay and SCP_NextFrame
+ * @p15_behave: Slave behavior when the Master attempts a read to the Port15
+ * alias
+ * @lane_control_support: Slave supports lane control
+ * @master_count: Number of Masters present on this Slave
+ * @source_ports: Bitmap identifying source ports
+ * @sink_ports: Bitmap identifying sink ports
+ * @dp0_prop: Data Port 0 properties
+ * @src_dpn_prop: Source Data Port N properties
+ * @sink_dpn_prop: Sink Data Port N properties
+ */
+struct sdw_slave_prop {
+        u32 mipi_revision;
+        bool wake_capable;
+        bool test_mode_capable;
+        bool clk_stop_mode1;
+        bool simple_clk_stop_capable;
+        u32 clk_stop_timeout;
+        u32 ch_prep_timeout;
+        enum sdw_clk_stop_reset_behave reset_behave;
+        bool high_PHY_capable;
+        bool paging_support;
+        bool bank_delay_support;
+        enum sdw_p15_behave p15_behave;
+        bool lane_control_support;
+        u32 master_count;
+        u32 source_ports;
+        u32 sink_ports;
+        struct sdw_dp0_prop *dp0_prop;
+        struct sdw_dpn_prop *src_dpn_prop;
+        struct sdw_dpn_prop *sink_dpn_prop;
+};
+
+/**
+ * struct sdw_master_prop - Master properties
+ * @revision: MIPI spec version of the implementation
+ * @master_count: Number of masters
+ * @clk_stop_mode: Bitmap for Clock Stop modes supported
+ * @max_freq: Maximum Bus clock frequency, in Hz
+ * @num_clk_gears: Number of clock gears supported
+ * @clk_gears: Clock gears supported
+ * @num_freq: Number of clock frequencies supported, in Hz
+ * @freq: Clock frequencies supported, in Hz
+ * @default_frame_rate: Controller default Frame rate, in Hz
+ * @default_row: Number of rows
+ * @default_col: Number of columns
+ * @dynamic_frame: Dynamic frame supported
+ * @err_threshold: Number of times that software may retry sending a single
+ * command
+ * @dpn_prop: Data Port N properties
+ */
+struct sdw_master_prop {
+        u32 revision;
+        u32 master_count;
+        enum sdw_clk_stop_mode clk_stop_mode;
+        u32 max_freq;
+        u32 num_clk_gears;
+        u32 *clk_gears;
+        u32 num_freq;
+        u32 *freq;
+        u32 default_frame_rate;
+        u32 default_row;
+        u32 default_col;
+        bool dynamic_frame;
+        u32 err_threshold;
+        struct sdw_dpn_prop *dpn_prop;
+};
+
+int sdw_master_read_prop(struct sdw_bus *bus);
+int sdw_slave_read_prop(struct sdw_slave *slave);
+
+/*
+ * SDW Slave Structures and APIs
+ */
+
+/**
+ * struct sdw_slave_id - Slave ID
+ * @mfg_id: MIPI Manufacturer ID
+ * @part_id: Device Part ID
+ * @class_id: MIPI Class ID, unused now.
+ * Currently a placeholder in MIPI SoundWire Spec
+ * @unique_id: Device unique ID
+ * @sdw_version: SDW version implemented
+ *
+ * The order of the IDs here does not follow the DisCo spec definitions
+ */
+struct sdw_slave_id {
+        __u16 mfg_id;
+        __u16 part_id;
+        __u8 class_id;
+        __u8 unique_id:4;
+        __u8 sdw_version:4;
+};
+
+/**
+ * struct sdw_slave_intr_status - Slave interrupt status
+ * @control_port: control port status
+ * @port: data port status
+ */
+struct sdw_slave_intr_status {
+        u8 control_port;
+        u8 port[15];
+};
+
+/**
+ * struct sdw_slave_ops - Slave driver callback ops
+ * @read_prop: Read Slave properties
+ * @interrupt_callback: Device interrupt notification (invoked in thread
+ * context)
+ * @update_status: Update Slave status
+ */
+struct sdw_slave_ops {
+        int (*read_prop)(struct sdw_slave *sdw);
+        int (*interrupt_callback)(struct sdw_slave *slave,
+                        struct sdw_slave_intr_status *status);
+        int (*update_status)(struct sdw_slave *slave,
+                        enum sdw_slave_status status);
+};
+
+/**
+ * struct sdw_slave - SoundWire Slave
+ * @id: MIPI device ID
+ * @dev: Linux device
+ * @status: Status reported by the Slave
+ * @bus: Bus handle
+ * @ops: Slave callback ops
+ * @prop: Slave properties
+ * @node: node for bus list
+ * @port_ready: Port ready completion flag for each Slave port
+ * @dev_num: Device Number assigned by Bus
+ */
+struct sdw_slave {
+        struct sdw_slave_id id;
+        struct device dev;
+        enum sdw_slave_status status;
+        struct sdw_bus *bus;
+        const struct sdw_slave_ops *ops;
+        struct sdw_slave_prop prop;
+        struct list_head node;
+        struct completion *port_ready;
+        u16 dev_num;
+};
+
+#define dev_to_sdw_dev(_dev) container_of(_dev, struct sdw_slave, dev)
+
+struct sdw_driver {
+        const char *name;
+
+        int (*probe)(struct sdw_slave *sdw,
+                        const struct sdw_device_id *id);
+        int (*remove)(struct sdw_slave *sdw);
+        void (*shutdown)(struct sdw_slave *sdw);
+
+        const struct sdw_device_id *id_table;
+        const struct sdw_slave_ops *ops;
+
+        struct device_driver driver;
+};
+
+#define SDW_SLAVE_ENTRY(_mfg_id, _part_id, _drv_data) \
+        { .mfg_id = (_mfg_id), .part_id = (_part_id), \
+          .driver_data = (unsigned long)(_drv_data) }
+
+int sdw_handle_slave_status(struct sdw_bus *bus,
+                        enum sdw_slave_status status[]);
+
+/*
+ * SDW master structures and APIs
+ */
+
+struct sdw_msg;
+
+/**
+ * struct sdw_defer - SDW deffered message
+ * @length: message length
+ * @complete: message completion
+ * @msg: SDW message
+ */
+struct sdw_defer {
+        int length;
+        struct completion complete;
+        struct sdw_msg *msg;
+};
+
+/**
+ * struct sdw_master_ops - Master driver ops
+ * @read_prop: Read Master properties
+ * @xfer_msg: Transfer message callback
+ * @xfer_msg_defer: Defer version of transfer message callback
+ * @reset_page_addr: Reset the SCP page address registers
+ */
+struct sdw_master_ops {
+        int (*read_prop)(struct sdw_bus *bus);
+
+        enum sdw_command_response (*xfer_msg)
+                        (struct sdw_bus *bus, struct sdw_msg *msg);
+        enum sdw_command_response (*xfer_msg_defer)
+                        (struct sdw_bus *bus, struct sdw_msg *msg,
+                        struct sdw_defer *defer);
+        enum sdw_command_response (*reset_page_addr)
+                        (struct sdw_bus *bus, unsigned int dev_num);
+};
+
+/**
+ * struct sdw_bus - SoundWire bus
+ * @dev: Master linux device
+ * @link_id: Link id number, can be 0 to N, unique for each Master
+ * @slaves: list of Slaves on this bus
+ * @assigned: Bitmap for Slave device numbers.
+ * Bit set implies used number, bit clear implies unused number.
+ * @bus_lock: bus lock
+ * @msg_lock: message lock
+ * @ops: Master callback ops
+ * @prop: Master properties
+ * @defer_msg: Defer message
+ * @clk_stop_timeout: Clock stop timeout computed
+ */
+struct sdw_bus {
+        struct device *dev;
+        unsigned int link_id;
+        struct list_head slaves;
+        DECLARE_BITMAP(assigned, SDW_MAX_DEVICES);
+        struct mutex bus_lock;
+        struct mutex msg_lock;
+        const struct sdw_master_ops *ops;
+        struct sdw_master_prop prop;
+        struct sdw_defer defer_msg;
+        unsigned int clk_stop_timeout;
+};
+
+int sdw_add_bus_master(struct sdw_bus *bus);
+void sdw_delete_bus_master(struct sdw_bus *bus);
+
+/* messaging and data APIs */
+
+int sdw_read(struct sdw_slave *slave, u32 addr);
+int sdw_write(struct sdw_slave *slave, u32 addr, u8 value);
+int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val);
+int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, u8 *val);
+
+#endif /* __SOUNDWIRE_H */
diff --git a/include/linux/soundwire/sdw_intel.h b/include/linux/soundwire/sdw_intel.h
new file mode 100644
index 000000000000..4b37528f592d
--- /dev/null
+++ b/include/linux/soundwire/sdw_intel.h
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
+// Copyright(c) 2015-17 Intel Corporation.
+
+#ifndef __SDW_INTEL_H
+#define __SDW_INTEL_H
+
+/**
+ * struct sdw_intel_res - Soundwire Intel resource structure
+ * @mmio_base: mmio base of SoundWire registers
+ * @irq: interrupt number
+ * @handle: ACPI parent handle
+ * @parent: parent device
+ */
+struct sdw_intel_res {
+        void __iomem *mmio_base;
+        int irq;
+        acpi_handle handle;
+        struct device *parent;
+};
+
+void *sdw_intel_init(acpi_handle *parent_handle, struct sdw_intel_res *res);
+void sdw_intel_exit(void *arg);
+
+#endif
diff --git a/include/linux/soundwire/sdw_registers.h b/include/linux/soundwire/sdw_registers.h
new file mode 100644
index 000000000000..df472b1ab410
--- /dev/null
+++ b/include/linux/soundwire/sdw_registers.h
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
+// Copyright(c) 2015-17 Intel Corporation.
+
+#ifndef __SDW_REGISTERS_H
+#define __SDW_REGISTERS_H
+
+/*
+ * typically we define register and shifts but if one observes carefully,
+ * the shift can be generated from MASKS using few bit primitaives like ffs
+ * etc, so we use that and avoid defining shifts
+ */
+#define SDW_REG_SHIFT(n)                        (ffs(n) - 1)
+
+/*
+ * SDW registers as defined by MIPI 1.1 Spec
+ */
+#define SDW_REGADDR                             GENMASK(14, 0)
+#define SDW_SCP_ADDRPAGE2_MASK                  GENMASK(22, 15)
+#define SDW_SCP_ADDRPAGE1_MASK                  GENMASK(30, 23)
+
+#define SDW_REG_NO_PAGE                         0x00008000
+#define SDW_REG_OPTIONAL_PAGE                   0x00010000
+#define SDW_REG_MAX                             0x80000000
+
+#define SDW_DPN_SIZE                            0x100
+#define SDW_BANK1_OFFSET                        0x10
+
+/*
+ * DP0 Interrupt register & bits
+ *
+ * Spec treats Status (RO) and Clear (WC) as separate but they are same
+ * address, so treat as same register with WC.
+ */
+
+/* both INT and STATUS register are same */
+#define SDW_DP0_INT                             0x0
+#define SDW_DP0_INTMASK                         0x1
+#define SDW_DP0_PORTCTRL                        0x2
+#define SDW_DP0_BLOCKCTRL1                      0x3
+#define SDW_DP0_PREPARESTATUS                   0x4
+#define SDW_DP0_PREPARECTRL                     0x5
+
+#define SDW_DP0_INT_TEST_FAIL                   BIT(0)
+#define SDW_DP0_INT_PORT_READY                  BIT(1)
+#define SDW_DP0_INT_BRA_FAILURE                 BIT(2)
+#define SDW_DP0_INT_IMPDEF1                     BIT(5)
+#define SDW_DP0_INT_IMPDEF2                     BIT(6)
+#define SDW_DP0_INT_IMPDEF3                     BIT(7)
+
+#define SDW_DP0_PORTCTRL_DATAMODE               GENMASK(3, 2)
+#define SDW_DP0_PORTCTRL_NXTINVBANK             BIT(4)
+#define SDW_DP0_PORTCTRL_BPT_PAYLD              GENMASK(7, 6)
+
+#define SDW_DP0_CHANNELEN                       0x20
+#define SDW_DP0_SAMPLECTRL1                     0x22
+#define SDW_DP0_SAMPLECTRL2                     0x23
+#define SDW_DP0_OFFSETCTRL1                     0x24
+#define SDW_DP0_OFFSETCTRL2                     0x25
+#define SDW_DP0_HCTRL                           0x26
+#define SDW_DP0_LANECTRL                        0x28
+
+/* Both INT and STATUS register are same */
+#define SDW_SCP_INT1                            0x40
+#define SDW_SCP_INTMASK1                        0x41
+
+#define SDW_SCP_INT1_PARITY                     BIT(0)
+#define SDW_SCP_INT1_BUS_CLASH                  BIT(1)
+#define SDW_SCP_INT1_IMPL_DEF                   BIT(2)
+#define SDW_SCP_INT1_SCP2_CASCADE               BIT(7)
+#define SDW_SCP_INT1_PORT0_3                    GENMASK(6, 3)
+
+#define SDW_SCP_INTSTAT2                        0x42
+#define SDW_SCP_INTSTAT2_SCP3_CASCADE           BIT(7)
+#define SDW_SCP_INTSTAT2_PORT4_10               GENMASK(6, 0)
+
+
+#define SDW_SCP_INTSTAT3                        0x43
+#define SDW_SCP_INTSTAT3_PORT11_14              GENMASK(3, 0)
+
+/* Number of interrupt status registers */
+#define SDW_NUM_INT_STAT_REGISTERS              3
+
+/* Number of interrupt clear registers */
+#define SDW_NUM_INT_CLEAR_REGISTERS             1
+
+#define SDW_SCP_CTRL                            0x44
+#define SDW_SCP_CTRL_CLK_STP_NOW                BIT(1)
+#define SDW_SCP_CTRL_FORCE_RESET                BIT(7)
+
+#define SDW_SCP_STAT                            0x44
+#define SDW_SCP_STAT_CLK_STP_NF                 BIT(0)
+#define SDW_SCP_STAT_HPHY_NOK                   BIT(5)
+#define SDW_SCP_STAT_CURR_BANK                  BIT(6)
+
+#define SDW_SCP_SYSTEMCTRL                      0x45
+#define SDW_SCP_SYSTEMCTRL_CLK_STP_PREP         BIT(0)
+#define SDW_SCP_SYSTEMCTRL_CLK_STP_MODE         BIT(2)
+#define SDW_SCP_SYSTEMCTRL_WAKE_UP_EN           BIT(3)
+#define SDW_SCP_SYSTEMCTRL_HIGH_PHY             BIT(4)
+
+#define SDW_SCP_SYSTEMCTRL_CLK_STP_MODE0        0
+#define SDW_SCP_SYSTEMCTRL_CLK_STP_MODE1        BIT(2)
+
+#define SDW_SCP_DEVNUMBER                       0x46
+#define SDW_SCP_HIGH_PHY_CHECK                  0x47
+#define SDW_SCP_ADDRPAGE1                       0x48
+#define SDW_SCP_ADDRPAGE2                       0x49
+#define SDW_SCP_KEEPEREN                        0x4A
+#define SDW_SCP_BANKDELAY                       0x4B
+#define SDW_SCP_TESTMODE                        0x4F
+#define SDW_SCP_DEVID_0                         0x50
+#define SDW_SCP_DEVID_1                         0x51
+#define SDW_SCP_DEVID_2                         0x52
+#define SDW_SCP_DEVID_3                         0x53
+#define SDW_SCP_DEVID_4                         0x54
+#define SDW_SCP_DEVID_5                         0x55
+
+/* Banked Registers */
+#define SDW_SCP_FRAMECTRL_B0                    0x60
+#define SDW_SCP_FRAMECTRL_B1                    (0x60 + SDW_BANK1_OFFSET)
+#define SDW_SCP_NEXTFRAME_B0                    0x61
+#define SDW_SCP_NEXTFRAME_B1                    (0x61 + SDW_BANK1_OFFSET)
+
+/* Both INT and STATUS register is same */
+#define SDW_DPN_INT(n)                          (0x0 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_INTMASK(n)                      (0x1 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_PORTCTRL(n)                     (0x2 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_BLOCKCTRL1(n)                   (0x3 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_PREPARESTATUS(n)                (0x4 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_PREPARECTRL(n)                  (0x5 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_INT_TEST_FAIL                   BIT(0)
+#define SDW_DPN_INT_PORT_READY                  BIT(1)
+#define SDW_DPN_INT_IMPDEF1                     BIT(5)
+#define SDW_DPN_INT_IMPDEF2                     BIT(6)
+#define SDW_DPN_INT_IMPDEF3                     BIT(7)
+
+#define SDW_DPN_PORTCTRL_FLOWMODE               GENMASK(1, 0)
+#define SDW_DPN_PORTCTRL_DATAMODE               GENMASK(3, 2)
+#define SDW_DPN_PORTCTRL_NXTINVBANK             BIT(4)
+
+#define SDW_DPN_BLOCKCTRL1_WDLEN                GENMASK(5, 0)
+
+#define SDW_DPN_PREPARECTRL_CH_PREP             GENMASK(7, 0)
+
+#define SDW_DPN_CHANNELEN_B0(n)                 (0x20 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_CHANNELEN_B1(n)                 (0x30 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_BLOCKCTRL2_B0(n)                (0x21 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_BLOCKCTRL2_B1(n)                (0x31 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_SAMPLECTRL1_B0(n)               (0x22 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_SAMPLECTRL1_B1(n)               (0x32 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_SAMPLECTRL2_B0(n)               (0x23 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_SAMPLECTRL2_B1(n)               (0x33 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_OFFSETCTRL1_B0(n)               (0x24 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_OFFSETCTRL1_B1(n)               (0x34 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_OFFSETCTRL2_B0(n)               (0x25 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_OFFSETCTRL2_B1(n)               (0x35 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_HCTRL_B0(n)                     (0x26 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_HCTRL_B1(n)                     (0x36 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_BLOCKCTRL3_B0(n)                (0x27 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_BLOCKCTRL3_B1(n)                (0x37 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_LANECTRL_B0(n)                  (0x28 + SDW_DPN_SIZE * (n))
+#define SDW_DPN_LANECTRL_B1(n)                  (0x38 + SDW_DPN_SIZE * (n))
+
+#define SDW_DPN_SAMPLECTRL_LOW                  GENMASK(7, 0)
+#define SDW_DPN_SAMPLECTRL_HIGH                 GENMASK(15, 8)
+
+#define SDW_DPN_HCTRL_HSTART                    GENMASK(7, 4)
+#define SDW_DPN_HCTRL_HSTOP                     GENMASK(3, 0)
+
+#define SDW_NUM_CASC_PORT_INTSTAT1              4
+#define SDW_CASC_PORT_START_INTSTAT1            0
+#define SDW_CASC_PORT_MASK_INTSTAT1             0x8
+#define SDW_CASC_PORT_REG_OFFSET_INTSTAT1       0x0
+
+#define SDW_NUM_CASC_PORT_INTSTAT2              7
+#define SDW_CASC_PORT_START_INTSTAT2            4
+#define SDW_CASC_PORT_MASK_INTSTAT2             1
+#define SDW_CASC_PORT_REG_OFFSET_INTSTAT2       1
+
+#define SDW_NUM_CASC_PORT_INTSTAT3              4
+#define SDW_CASC_PORT_START_INTSTAT3            11
+#define SDW_CASC_PORT_MASK_INTSTAT3             1
+#define SDW_CASC_PORT_REG_OFFSET_INTSTAT3       2
+
+#endif /* __SDW_REGISTERS_H */
diff --git a/include/linux/soundwire/sdw_type.h b/include/linux/soundwire/sdw_type.h
new file mode 100644
index 000000000000..9fd553e553e9
--- /dev/null
+++ b/include/linux/soundwire/sdw_type.h
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright(c) 2015-17 Intel Corporation.
+
+#ifndef __SOUNDWIRE_TYPES_H
+#define __SOUNDWIRE_TYPES_H
+
+extern struct bus_type sdw_bus_type;
+
+#define drv_to_sdw_driver(_drv) container_of(_drv, struct sdw_driver, driver)
+
+#define sdw_register_driver(drv) \
+        __sdw_register_driver(drv, THIS_MODULE)
+
+int __sdw_register_driver(struct sdw_driver *drv, struct module *);
+void sdw_unregister_driver(struct sdw_driver *drv);
+
+int sdw_slave_modalias(const struct sdw_slave *slave, char *buf, size_t size);
+
+#endif /* __SOUNDWIRE_TYPES_H */
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 3bf273538840..4894d322d258 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -409,4 +409,10 @@ extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
 #define atomic_dec_and_lock(atomic, lock) \
                 __cond_lock(lock, _atomic_dec_and_lock(atomic, lock))
 
+int alloc_bucket_spinlocks(spinlock_t **locks, unsigned int *lock_mask,
+                           size_t max_size, unsigned int cpu_mult,
+                           gfp_t gfp);
+
+void free_bucket_spinlocks(spinlock_t *locks);
+
 #endif /* __LINUX_SPINLOCK_H */
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 62be8966e837..33c1c698df09 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -92,7 +92,7 @@ void synchronize_srcu(struct srcu_struct *sp);
  * relies on normal RCU, it can be called from the CPU which
  * is in the idle loop from an RCU point of view or offline.
  */
-static inline int srcu_read_lock_held(struct srcu_struct *sp)
+static inline int srcu_read_lock_held(const struct srcu_struct *sp)
 {
         if (!debug_lockdep_rcu_enabled())
                 return 1;
@@ -101,7 +101,7 @@ static inline int srcu_read_lock_held(struct srcu_struct *sp)
 
 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
-static inline int srcu_read_lock_held(struct srcu_struct *sp)
+static inline int srcu_read_lock_held(const struct srcu_struct *sp)
 {
         return 1;
 }
diff --git a/include/linux/srcutree.h b/include/linux/srcutree.h
index a949f4f9e4d7..4eda108abee0 100644
--- a/include/linux/srcutree.h
+++ b/include/linux/srcutree.h
@@ -40,7 +40,7 @@ struct srcu_data {
         unsigned long srcu_unlock_count[2];     /* Unlocks per CPU. */
 
         /* Update-side state. */
-        raw_spinlock_t __private lock ____cacheline_internodealigned_in_smp;
+        spinlock_t __private lock ____cacheline_internodealigned_in_smp;
         struct rcu_segcblist srcu_cblist;       /* List of callbacks.*/
         unsigned long srcu_gp_seq_needed;       /* Furthest future GP needed. */
         unsigned long srcu_gp_seq_needed_exp;   /* Furthest future exp GP. */
@@ -58,7 +58,7 @@ struct srcu_data {
  * Node in SRCU combining tree, similar in function to rcu_data.
  */
 struct srcu_node {
-        raw_spinlock_t __private lock;
+        spinlock_t __private lock;
         unsigned long srcu_have_cbs[4];         /* GP seq for children */
                                                 /*  having CBs, but only */
                                                 /*  is > ->srcu_gq_seq. */
@@ -78,7 +78,7 @@ struct srcu_struct {
         struct srcu_node *level[RCU_NUM_LVLS + 1];
                                                 /* First node at each level. */
         struct mutex srcu_cb_mutex;             /* Serialize CB preparation. */
-        raw_spinlock_t __private lock;          /* Protect counters */
+        spinlock_t __private lock;              /* Protect counters */
         struct mutex srcu_gp_mutex;             /* Serialize GP work. */
         unsigned int srcu_idx;                  /* Current rdr array element. */
         unsigned long srcu_gp_seq;              /* Grace-period seq #. */
@@ -107,7 +107,7 @@ struct srcu_struct {
 #define __SRCU_STRUCT_INIT(name)                                        \
         {                                                               \
                 .sda = &name##_srcu_data,                               \
-                .lock = __RAW_SPIN_LOCK_UNLOCKED(name.lock),            \
+                .lock = __SPIN_LOCK_UNLOCKED(name.lock),                \
                 .srcu_gp_seq_needed = 0 - 1,                            \
                 __SRCU_DEP_MAP_INIT(name)                               \
         }
diff --git a/include/linux/stddef.h b/include/linux/stddef.h
index 2181719fd907..998a4ba28eba 100644
--- a/include/linux/stddef.h
+++ b/include/linux/stddef.h
@@ -20,12 +20,20 @@ enum {
 #endif
 
 /**
+ * sizeof_field(TYPE, MEMBER)
+ *
+ * @TYPE: The structure containing the field of interest
+ * @MEMBER: The field to return the size of
+ */
+#define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER))
+
+/**
  * offsetofend(TYPE, MEMBER)
  *
  * @TYPE: The type of the structure
  * @MEMBER: The member within the structure to get the end offset of
  */
 #define offsetofend(TYPE, MEMBER) \
-        (offsetof(TYPE, MEMBER) + sizeof(((TYPE *)0)->MEMBER))
+        (offsetof(TYPE, MEMBER) + sizeof_field(TYPE, MEMBER))
 
 #endif
diff --git a/include/linux/string.h b/include/linux/string.h
index cfd83eb2f926..dd39a690c841 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -11,6 +11,7 @@
 
 extern char *strndup_user(const char __user *, long);
 extern void *memdup_user(const void __user *, size_t);
+extern void *vmemdup_user(const void __user *, size_t);
 extern void *memdup_user_nul(const void __user *, size_t);
 
 /*
@@ -28,7 +29,7 @@ extern char * strncpy(char *,const char *, __kernel_size_t);
 size_t strlcpy(char *, const char *, size_t);
 #endif
 #ifndef __HAVE_ARCH_STRSCPY
-ssize_t __must_check strscpy(char *, const char *, size_t);
+ssize_t strscpy(char *, const char *, size_t);
 #endif
 #ifndef __HAVE_ARCH_STRCAT
 extern char * strcat(char *, const char *);
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 71c237e8240e..ed761f751ecb 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -179,7 +179,6 @@ struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred,
 int             rpc_restart_call_prepare(struct rpc_task *);
 int             rpc_restart_call(struct rpc_task *);
 void            rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
-int             rpc_protocol(struct rpc_clnt *);
 struct net *    rpc_net_ns(struct rpc_clnt *);
 size_t          rpc_max_payload(struct rpc_clnt *);
 size_t          rpc_max_bc_payload(struct rpc_clnt *);
diff --git a/include/linux/sunrpc/svc_rdma.h b/include/linux/sunrpc/svc_rdma.h
index 995c6fe9ee90..4b731b046bcd 100644
--- a/include/linux/sunrpc/svc_rdma.h
+++ b/include/linux/sunrpc/svc_rdma.h
@@ -185,8 +185,6 @@ extern void svc_rdma_wc_reg(struct ib_cq *, struct ib_wc *);
 extern void svc_rdma_wc_read(struct ib_cq *, struct ib_wc *);
 extern void svc_rdma_wc_inv(struct ib_cq *, struct ib_wc *);
 extern int svc_rdma_send(struct svcxprt_rdma *, struct ib_send_wr *);
-extern int svc_rdma_post_recv(struct svcxprt_rdma *, gfp_t);
-extern int svc_rdma_repost_recv(struct svcxprt_rdma *, gfp_t);
 extern int svc_rdma_create_listen(struct svc_serv *, int, struct sockaddr *);
 extern struct svc_rdma_op_ctxt *svc_rdma_get_context(struct svcxprt_rdma *);
 extern void svc_rdma_put_context(struct svc_rdma_op_ctxt *, int);
diff --git a/include/linux/sunrpc/xprtrdma.h b/include/linux/sunrpc/xprtrdma.h
index 221b7a2e5406..5859563e3c1f 100644
--- a/include/linux/sunrpc/xprtrdma.h
+++ b/include/linux/sunrpc/xprtrdma.h
@@ -64,7 +64,7 @@ enum rpcrdma_memreg {
         RPCRDMA_MEMWINDOWS,
         RPCRDMA_MEMWINDOWS_ASYNC,
         RPCRDMA_MTHCAFMR,
-        RPCRDMA_FRMR,
+        RPCRDMA_FRWR,
         RPCRDMA_ALLPHYSICAL,
         RPCRDMA_LAST
 };
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index cc22a24516d6..440b62f7502e 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -384,6 +384,8 @@ extern int swsusp_page_is_forbidden(struct page *);
 extern void swsusp_set_page_free(struct page *);
 extern void swsusp_unset_page_free(struct page *);
 extern unsigned long get_safe_page(gfp_t gfp_mask);
+extern asmlinkage int swsusp_arch_suspend(void);
+extern asmlinkage int swsusp_arch_resume(void);
 
 extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
 extern int hibernate(void);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index c2b8128799c1..7b6a59f722a3 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -332,7 +332,6 @@ extern void mark_page_accessed(struct page *);
 extern void lru_add_drain(void);
 extern void lru_add_drain_cpu(int cpu);
 extern void lru_add_drain_all(void);
-extern void lru_add_drain_all_cpuslocked(void);
 extern void rotate_reclaimable_page(struct page *page);
 extern void deactivate_file_page(struct page *page);
 extern void mark_page_lazyfree(struct page *page);
@@ -345,7 +344,6 @@ extern void lru_cache_add_active_or_unevictable(struct page *page,
 
 /* linux/mm/vmscan.c */
 extern unsigned long zone_reclaimable_pages(struct zone *zone);
-extern unsigned long pgdat_reclaimable_pages(struct pglist_data *pgdat);
 extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
                                         gfp_t gfp_mask, nodemask_t *mask);
 extern int __isolate_lru_page(struct page *page, isolate_mode_t mode);
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index 24ed817082ee..5b1f2a00491c 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -66,6 +66,12 @@ extern void swiotlb_tbl_sync_single(struct device *hwdev,
                                     enum dma_sync_target target);
 
 /* Accessory functions. */
+
+void *swiotlb_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,
+                gfp_t flags, unsigned long attrs);
+void swiotlb_free(struct device *dev, size_t size, void *vaddr,
+                dma_addr_t dma_addr, unsigned long attrs);
+
 extern void
 *swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                         dma_addr_t *dma_handle, gfp_t flags);
@@ -115,10 +121,10 @@ extern int
 swiotlb_dma_supported(struct device *hwdev, u64 mask);
 
 #ifdef CONFIG_SWIOTLB
-extern void __init swiotlb_free(void);
+extern void __init swiotlb_exit(void);
 unsigned int swiotlb_max_segment(void);
 #else
-static inline void swiotlb_free(void) { }
+static inline void swiotlb_exit(void) { }
 static inline unsigned int swiotlb_max_segment(void) { return 0; }
 #endif
 
@@ -126,4 +132,6 @@ extern void swiotlb_print_info(void);
 extern int is_swiotlb_buffer(phys_addr_t paddr);
 extern void swiotlb_set_max_segment(unsigned int);
 
+extern const struct dma_map_ops swiotlb_dma_ops;
+
 #endif /* __LINUX_SWIOTLB_H */
diff --git a/include/linux/switchtec.h b/include/linux/switchtec.h
index 09d73d0d1aa8..ec93e93371fa 100644
--- a/include/linux/switchtec.h
+++ b/include/linux/switchtec.h
@@ -100,6 +100,9 @@ struct sw_event_regs {
         u32 gpio_interrupt_hdr;
         u32 gpio_interrupt_data;
         u32 reserved16[4];
+        u32 gfms_event_hdr;
+        u32 gfms_event_data;
+        u32 reserved17[4];
 } __packed;
 
 enum {
@@ -168,6 +171,14 @@ struct ntb_info_regs {
         u16 reserved1;
         u64 ep_map;
         u16 requester_id;
+        u16 reserved2;
+        u32 reserved3[4];
+        struct nt_partition_info {
+                u32 xlink_enabled;
+                u32 target_part_low;
+                u32 target_part_high;
+                u32 reserved;
+        } ntp_info[48];
 } __packed;
 
 struct part_cfg_regs {
@@ -284,7 +295,20 @@ enum {
 struct pff_csr_regs {
         u16 vendor_id;
         u16 device_id;
-        u32 pci_cfg_header[15];
+        u16 pcicmd;
+        u16 pcists;
+        u32 pci_class;
+        u32 pci_opts;
+        union {
+                u32 pci_bar[6];
+                u64 pci_bar64[3];
+        };
+        u32 pci_cardbus;
+        u32 pci_subsystem_id;
+        u32 pci_expansion_rom;
+        u32 pci_cap_ptr;
+        u32 reserved1;
+        u32 pci_irq;
         u32 pci_cap_region[48];
         u32 pcie_cap_region[448];
         u32 indirect_gas_window[128];
diff --git a/include/linux/sync_core.h b/include/linux/sync_core.h
new file mode 100644
index 000000000000..013da4b8b327
--- /dev/null
+++ b/include/linux/sync_core.h
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_SYNC_CORE_H
+#define _LINUX_SYNC_CORE_H
+
+#ifdef CONFIG_ARCH_HAS_SYNC_CORE_BEFORE_USERMODE
+#include <asm/sync_core.h>
+#else
+/*
+ * This is a dummy sync_core_before_usermode() implementation that can be used
+ * on all architectures which return to user-space through core serializing
+ * instructions.
+ * If your architecture returns to user-space through non-core-serializing
+ * instructions, you need to write your own functions.
+ */
+static inline void sync_core_before_usermode(void)
+{
+}
+#endif
+
+#endif /* _LINUX_SYNC_CORE_H */
+
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 992bc9948232..b769ecfcc3bd 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -51,9 +51,6 @@ extern int proc_dointvec_minmax(struct ctl_table *, int,
 extern int proc_douintvec_minmax(struct ctl_table *table, int write,
                                  void __user *buffer, size_t *lenp,
                                  loff_t *ppos);
-extern int proc_dopipe_max_size(struct ctl_table *table, int write,
-                                void __user *buffer, size_t *lenp,
-                                loff_t *ppos);
 extern int proc_dointvec_jiffies(struct ctl_table *, int,
                                  void __user *, size_t *, loff_t *);
 extern int proc_dointvec_userhz_jiffies(struct ctl_table *, int,
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 40839c02d28c..b8bfdc173ec0 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -113,7 +113,7 @@ struct attribute_group {
 }
 
 #define __ATTR_RO(_name) {                                              \
-        .attr   = { .name = __stringify(_name), .mode = S_IRUGO },      \
+        .attr   = { .name = __stringify(_name), .mode = 0444 },         \
         .show   = _name##_show,                                         \
 }
 
@@ -124,12 +124,11 @@ struct attribute_group {
 }
 
 #define __ATTR_WO(_name) {                                              \
-        .attr   = { .name = __stringify(_name), .mode = S_IWUSR },      \
+        .attr   = { .name = __stringify(_name), .mode = 0200 },         \
         .store  = _name##_store,                                        \
 }
 
-#define __ATTR_RW(_name) __ATTR(_name, (S_IWUSR | S_IRUGO),             \
-                         _name##_show, _name##_store)
+#define __ATTR_RW(_name) __ATTR(_name, 0644, _name##_show, _name##_store)
 
 #define __ATTR_NULL { .attr = { .name = NULL } }
 
@@ -192,14 +191,13 @@ struct bin_attribute {
 }
 
 #define __BIN_ATTR_RO(_name, _size) {                                   \
-        .attr   = { .name = __stringify(_name), .mode = S_IRUGO },      \
+        .attr   = { .name = __stringify(_name), .mode = 0444 },         \
         .read   = _name##_read,                                         \
         .size   = _size,                                                \
 }
 
-#define __BIN_ATTR_RW(_name, _size) __BIN_ATTR(_name,                   \
-                                   (S_IWUSR | S_IRUGO), _name##_read,   \
-                                   _name##_write, _size)
+#define __BIN_ATTR_RW(_name, _size)                                     \
+        __BIN_ATTR(_name, 0644, _name##_read, _name##_write, _size)
 
 #define __BIN_ATTR_NULL __ATTR_NULL
 
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index ca4a6361389b..8f4c54986f97 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -335,6 +335,17 @@ struct tcp_sock {
 
         int                     linger2;
 
+
+/* Sock_ops bpf program related variables */
+#ifdef CONFIG_BPF
+        u8      bpf_sock_ops_cb_flags;  /* Control calling BPF programs
+                                         * values defined in uapi/linux/tcp.h
+                                         */
+#define BPF_SOCK_OPS_TEST_FLAG(TP, ARG) (TP->bpf_sock_ops_cb_flags & ARG)
+#else
+#define BPF_SOCK_OPS_TEST_FLAG(TP, ARG) 0
+#endif
+
 /* Receiver side RTT estimation */
         struct {
                 u32     rtt_us;
@@ -344,7 +355,7 @@ struct tcp_sock {
 
 /* Receiver queue space */
         struct {
-                int     space;
+                u32     space;
                 u32     seq;
                 u64     time;
         } rcvq_space;
diff --git a/include/linux/tee_drv.h b/include/linux/tee_drv.h
index cb889afe576b..a2b3dfcee0b5 100644
--- a/include/linux/tee_drv.h
+++ b/include/linux/tee_drv.h
@@ -17,6 +17,7 @@
 
 #include <linux/types.h>
 #include <linux/idr.h>
+#include <linux/kref.h>
 #include <linux/list.h>
 #include <linux/tee.h>
 
@@ -25,8 +26,12 @@
  * specific TEE driver.
  */
 
-#define TEE_SHM_MAPPED          0x1     /* Memory mapped by the kernel */
-#define TEE_SHM_DMA_BUF         0x2     /* Memory with dma-buf handle */
+#define TEE_SHM_MAPPED          BIT(0)  /* Memory mapped by the kernel */
+#define TEE_SHM_DMA_BUF         BIT(1)  /* Memory with dma-buf handle */
+#define TEE_SHM_EXT_DMA_BUF     BIT(2)  /* Memory with dma-buf handle */
+#define TEE_SHM_REGISTER        BIT(3)  /* Memory registered in secure world */
+#define TEE_SHM_USER_MAPPED     BIT(4)  /* Memory mapped in user space */
+#define TEE_SHM_POOL            BIT(5)  /* Memory allocated from pool */
 
 struct device;
 struct tee_device;
@@ -38,11 +43,17 @@ struct tee_shm_pool;
  * @teedev:     pointer to this drivers struct tee_device
  * @list_shm:   List of shared memory object owned by this context
  * @data:       driver specific context data, managed by the driver
+ * @refcount:   reference counter for this structure
+ * @releasing:  flag that indicates if context is being released right now.
+ *              It is needed to break circular dependency on context during
+ *              shared memory release.
  */
 struct tee_context {
         struct tee_device *teedev;
         struct list_head list_shm;
         void *data;
+        struct kref refcount;
+        bool releasing;
 };
 
 struct tee_param_memref {
@@ -76,6 +87,8 @@ struct tee_param {
  * @cancel_req:         request cancel of an ongoing invoke or open
  * @supp_revc:          called for supplicant to get a command
  * @supp_send:          called for supplicant to send a response
+ * @shm_register:       register shared memory buffer in TEE
+ * @shm_unregister:     unregister shared memory buffer in TEE
  */
 struct tee_driver_ops {
         void (*get_version)(struct tee_device *teedev,
@@ -94,6 +107,10 @@ struct tee_driver_ops {
                          struct tee_param *param);
         int (*supp_send)(struct tee_context *ctx, u32 ret, u32 num_params,
                          struct tee_param *param);
+        int (*shm_register)(struct tee_context *ctx, struct tee_shm *shm,
+                            struct page **pages, size_t num_pages,
+                            unsigned long start);
+        int (*shm_unregister)(struct tee_context *ctx, struct tee_shm *shm);
 };
 
 /**
@@ -150,6 +167,97 @@ int tee_device_register(struct tee_device *teedev);
 void tee_device_unregister(struct tee_device *teedev);
 
 /**
+ * struct tee_shm - shared memory object
+ * @teedev:     device used to allocate the object
+ * @ctx:        context using the object, if NULL the context is gone
+ * @link        link element
+ * @paddr:      physical address of the shared memory
+ * @kaddr:      virtual address of the shared memory
+ * @size:       size of shared memory
+ * @offset:     offset of buffer in user space
+ * @pages:      locked pages from userspace
+ * @num_pages:  number of locked pages
+ * @dmabuf:     dmabuf used to for exporting to user space
+ * @flags:      defined by TEE_SHM_* in tee_drv.h
+ * @id:         unique id of a shared memory object on this device
+ *
+ * This pool is only supposed to be accessed directly from the TEE
+ * subsystem and from drivers that implements their own shm pool manager.
+ */
+struct tee_shm {
+        struct tee_device *teedev;
+        struct tee_context *ctx;
+        struct list_head link;
+        phys_addr_t paddr;
+        void *kaddr;
+        size_t size;
+        unsigned int offset;
+        struct page **pages;
+        size_t num_pages;
+        struct dma_buf *dmabuf;
+        u32 flags;
+        int id;
+};
+
+/**
+ * struct tee_shm_pool_mgr - shared memory manager
+ * @ops:                operations
+ * @private_data:       private data for the shared memory manager
+ */
+struct tee_shm_pool_mgr {
+        const struct tee_shm_pool_mgr_ops *ops;
+        void *private_data;
+};
+
+/**
+ * struct tee_shm_pool_mgr_ops - shared memory pool manager operations
+ * @alloc:              called when allocating shared memory
+ * @free:               called when freeing shared memory
+ * @destroy_poolmgr:    called when destroying the pool manager
+ */
+struct tee_shm_pool_mgr_ops {
+        int (*alloc)(struct tee_shm_pool_mgr *poolmgr, struct tee_shm *shm,
+                     size_t size);
+        void (*free)(struct tee_shm_pool_mgr *poolmgr, struct tee_shm *shm);
+        void (*destroy_poolmgr)(struct tee_shm_pool_mgr *poolmgr);
+};
+
+/**
+ * tee_shm_pool_alloc() - Create a shared memory pool from shm managers
+ * @priv_mgr:   manager for driver private shared memory allocations
+ * @dmabuf_mgr: manager for dma-buf shared memory allocations
+ *
+ * Allocation with the flag TEE_SHM_DMA_BUF set will use the range supplied
+ * in @dmabuf, others will use the range provided by @priv.
+ *
+ * @returns pointer to a 'struct tee_shm_pool' or an ERR_PTR on failure.
+ */
+struct tee_shm_pool *tee_shm_pool_alloc(struct tee_shm_pool_mgr *priv_mgr,
+                                        struct tee_shm_pool_mgr *dmabuf_mgr);
+
+/*
+ * tee_shm_pool_mgr_alloc_res_mem() - Create a shm manager for reserved
+ * memory
+ * @vaddr:      Virtual address of start of pool
+ * @paddr:      Physical address of start of pool
+ * @size:       Size in bytes of the pool
+ *
+ * @returns pointer to a 'struct tee_shm_pool_mgr' or an ERR_PTR on failure.
+ */
+struct tee_shm_pool_mgr *tee_shm_pool_mgr_alloc_res_mem(unsigned long vaddr,
+                                                        phys_addr_t paddr,
+                                                        size_t size,
+                                                        int min_alloc_order);
+
+/**
+ * tee_shm_pool_mgr_destroy() - Free a shared memory manager
+ */
+static inline void tee_shm_pool_mgr_destroy(struct tee_shm_pool_mgr *poolm)
+{
+        poolm->ops->destroy_poolmgr(poolm);
+}
+
+/**
  * struct tee_shm_pool_mem_info - holds information needed to create a shared
  * memory pool
  * @vaddr:      Virtual address of start of pool
@@ -211,6 +319,40 @@ void *tee_get_drvdata(struct tee_device *teedev);
 struct tee_shm *tee_shm_alloc(struct tee_context *ctx, size_t size, u32 flags);
 
 /**
+ * tee_shm_priv_alloc() - Allocate shared memory privately
+ * @dev:        Device that allocates the shared memory
+ * @size:       Requested size of shared memory
+ *
+ * Allocates shared memory buffer that is not associated with any client
+ * context. Such buffers are owned by TEE driver and used for internal calls.
+ *
+ * @returns a pointer to 'struct tee_shm'
+ */
+struct tee_shm *tee_shm_priv_alloc(struct tee_device *teedev, size_t size);
+
+/**
+ * tee_shm_register() - Register shared memory buffer
+ * @ctx:        Context that registers the shared memory
+ * @addr:       Address is userspace of the shared buffer
+ * @length:     Length of the shared buffer
+ * @flags:      Flags setting properties for the requested shared memory.
+ *
+ * @returns a pointer to 'struct tee_shm'
+ */
+struct tee_shm *tee_shm_register(struct tee_context *ctx, unsigned long addr,
+                                 size_t length, u32 flags);
+
+/**
+ * tee_shm_is_registered() - Check if shared memory object in registered in TEE
+ * @shm:        Shared memory handle
+ * @returns true if object is registered in TEE
+ */
+static inline bool tee_shm_is_registered(struct tee_shm *shm)
+{
+        return shm && (shm->flags & TEE_SHM_REGISTER);
+}
+
+/**
  * tee_shm_free() - Free shared memory
  * @shm:        Handle to shared memory to free
  */
@@ -260,11 +402,47 @@ void *tee_shm_get_va(struct tee_shm *shm, size_t offs);
 int tee_shm_get_pa(struct tee_shm *shm, size_t offs, phys_addr_t *pa);
 
 /**
+ * tee_shm_get_size() - Get size of shared memory buffer
+ * @shm:        Shared memory handle
+ * @returns size of shared memory
+ */
+static inline size_t tee_shm_get_size(struct tee_shm *shm)
+{
+        return shm->size;
+}
+
+/**
+ * tee_shm_get_pages() - Get list of pages that hold shared buffer
+ * @shm:        Shared memory handle
+ * @num_pages:  Number of pages will be stored there
+ * @returns pointer to pages array
+ */
+static inline struct page **tee_shm_get_pages(struct tee_shm *shm,
+                                              size_t *num_pages)
+{
+        *num_pages = shm->num_pages;
+        return shm->pages;
+}
+
+/**
+ * tee_shm_get_page_offset() - Get shared buffer offset from page start
+ * @shm:        Shared memory handle
+ * @returns page offset of shared buffer
+ */
+static inline size_t tee_shm_get_page_offset(struct tee_shm *shm)
+{
+        return shm->offset;
+}
+
+/**
  * tee_shm_get_id() - Get id of a shared memory object
  * @shm:        Shared memory handle
  * @returns id
  */
-int tee_shm_get_id(struct tee_shm *shm);
+static inline int tee_shm_get_id(struct tee_shm *shm)
+{
+        return shm->id;
+}
 
 /**
  * tee_shm_get_from_id() - Find shared memory object and increase reference
@@ -275,4 +453,16 @@ int tee_shm_get_id(struct tee_shm *shm);
  */
 struct tee_shm *tee_shm_get_from_id(struct tee_context *ctx, int id);
 
+static inline bool tee_param_is_memref(struct tee_param *param)
+{
+        switch (param->attr & TEE_IOCTL_PARAM_ATTR_TYPE_MASK) {
+        case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT:
+        case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT:
+        case TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT:
+                return true;
+        default:
+                return false;
+        }
+}
+
 #endif /*__TEE_DRV_H*/
diff --git a/include/linux/ti-emif-sram.h b/include/linux/ti-emif-sram.h
new file mode 100644
index 000000000000..45bc6b376492
--- /dev/null
+++ b/include/linux/ti-emif-sram.h
@@ -0,0 +1,69 @@
+/*
+ * TI AM33XX EMIF Routines
+ *
+ * Copyright (C) 2016-2017 Texas Instruments Inc.
+ *      Dave Gerlach
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef __LINUX_TI_EMIF_H
+#define __LINUX_TI_EMIF_H
+
+#include <linux/kbuild.h>
+#include <linux/types.h>
+#ifndef __ASSEMBLY__
+
+struct emif_regs_amx3 {
+        u32 emif_sdcfg_val;
+        u32 emif_timing1_val;
+        u32 emif_timing2_val;
+        u32 emif_timing3_val;
+        u32 emif_ref_ctrl_val;
+        u32 emif_zqcfg_val;
+        u32 emif_pmcr_val;
+        u32 emif_pmcr_shdw_val;
+        u32 emif_rd_wr_level_ramp_ctrl;
+        u32 emif_rd_wr_exec_thresh;
+        u32 emif_cos_config;
+        u32 emif_priority_to_cos_mapping;
+        u32 emif_connect_id_serv_1_map;
+        u32 emif_connect_id_serv_2_map;
+        u32 emif_ocp_config_val;
+        u32 emif_lpddr2_nvm_tim;
+        u32 emif_lpddr2_nvm_tim_shdw;
+        u32 emif_dll_calib_ctrl_val;
+        u32 emif_dll_calib_ctrl_val_shdw;
+        u32 emif_ddr_phy_ctlr_1;
+        u32 emif_ext_phy_ctrl_vals[120];
+};
+
+struct ti_emif_pm_data {
+        void __iomem *ti_emif_base_addr_virt;
+        phys_addr_t ti_emif_base_addr_phys;
+        unsigned long ti_emif_sram_config;
+        struct emif_regs_amx3 *regs_virt;
+        phys_addr_t regs_phys;
+} __packed __aligned(8);
+
+struct ti_emif_pm_functions {
+        u32 save_context;
+        u32 restore_context;
+        u32 enter_sr;
+        u32 exit_sr;
+        u32 abort_sr;
+} __packed __aligned(8);
+
+struct gen_pool;
+
+int ti_emif_copy_pm_function_table(struct gen_pool *sram_pool, void *dst);
+int ti_emif_get_mem_type(void);
+
+#endif
+#endif /* __LINUX_TI_EMIF_H */
diff --git a/include/linux/torture.h b/include/linux/torture.h
index a45702eb3e7b..66272862070b 100644
--- a/include/linux/torture.h
+++ b/include/linux/torture.h
@@ -79,7 +79,7 @@ void stutter_wait(const char *title);
 int torture_stutter_init(int s);
 
 /* Initialization and cleanup. */
-bool torture_init_begin(char *ttype, bool v, int *runnable);
+bool torture_init_begin(char *ttype, bool v);
 void torture_init_end(void);
 bool torture_cleanup_begin(void);
 void torture_cleanup_end(void);
@@ -96,4 +96,10 @@ void _torture_stop_kthread(char *m, struct task_struct **tp);
 #define torture_stop_kthread(n, tp) \
         _torture_stop_kthread("Stopping " #n " task", &(tp))
 
+#ifdef CONFIG_PREEMPT
+#define torture_preempt_schedule() preempt_schedule()
+#else
+#define torture_preempt_schedule()
+#endif
+
 #endif /* __LINUX_TORTURE_H */
diff --git a/include/linux/tpm.h b/include/linux/tpm.h
index 5a090f5ab335..bcdd3790e94d 100644
--- a/include/linux/tpm.h
+++ b/include/linux/tpm.h
@@ -24,11 +24,6 @@
 
 #define TPM_DIGEST_SIZE 20      /* Max TPM v1.2 PCR size */
 
-/*
- * Chip num is this value or a valid tpm idx
- */
-#define TPM_ANY_NUM 0xFFFF
-
 struct tpm_chip;
 struct trusted_key_payload;
 struct trusted_key_options;
@@ -50,46 +45,52 @@ struct tpm_class_ops {
                                 unsigned long *timeout_cap);
         int (*request_locality)(struct tpm_chip *chip, int loc);
         void (*relinquish_locality)(struct tpm_chip *chip, int loc);
+        void (*clk_enable)(struct tpm_chip *chip, bool value);
 };
 
 #if defined(CONFIG_TCG_TPM) || defined(CONFIG_TCG_TPM_MODULE)
 
-extern int tpm_is_tpm2(u32 chip_num);
-extern int tpm_pcr_read(u32 chip_num, int pcr_idx, u8 *res_buf);
-extern int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash);
-extern int tpm_send(u32 chip_num, void *cmd, size_t buflen);
-extern int tpm_get_random(u32 chip_num, u8 *data, size_t max);
-extern int tpm_seal_trusted(u32 chip_num,
+extern int tpm_is_tpm2(struct tpm_chip *chip);
+extern int tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf);
+extern int tpm_pcr_extend(struct tpm_chip *chip, int pcr_idx, const u8 *hash);
+extern int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen);
+extern int tpm_get_random(struct tpm_chip *chip, u8 *data, size_t max);
+extern int tpm_seal_trusted(struct tpm_chip *chip,
                             struct trusted_key_payload *payload,
                             struct trusted_key_options *options);
-extern int tpm_unseal_trusted(u32 chip_num,
+extern int tpm_unseal_trusted(struct tpm_chip *chip,
                               struct trusted_key_payload *payload,
                               struct trusted_key_options *options);
 #else
-static inline int tpm_is_tpm2(u32 chip_num)
+static inline int tpm_is_tpm2(struct tpm_chip *chip)
 {
         return -ENODEV;
 }
-static inline int tpm_pcr_read(u32 chip_num, int pcr_idx, u8 *res_buf) {
+static inline int tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
+{
         return -ENODEV;
 }
-static inline int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash) {
+static inline int tpm_pcr_extend(struct tpm_chip *chip, int pcr_idx,
+                                 const u8 *hash)
+{
         return -ENODEV;
 }
-static inline int tpm_send(u32 chip_num, void *cmd, size_t buflen) {
+static inline int tpm_send(struct tpm_chip *chip, void *cmd, size_t buflen)
+{
         return -ENODEV;
 }
-static inline int tpm_get_random(u32 chip_num, u8 *data, size_t max) {
+static inline int tpm_get_random(struct tpm_chip *chip, u8 *data, size_t max)
+{
         return -ENODEV;
 }
 
-static inline int tpm_seal_trusted(u32 chip_num,
+static inline int tpm_seal_trusted(struct tpm_chip *chip,
                                    struct trusted_key_payload *payload,
                                    struct trusted_key_options *options)
 {
         return -ENODEV;
 }
-static inline int tpm_unseal_trusted(u32 chip_num,
+static inline int tpm_unseal_trusted(struct tpm_chip *chip,
                                      struct trusted_key_payload *payload,
                                      struct trusted_key_options *options)
 {
diff --git a/include/linux/tpm_eventlog.h b/include/linux/tpm_eventlog.h
new file mode 100644
index 000000000000..20d9da77fc11
--- /dev/null
+++ b/include/linux/tpm_eventlog.h
@@ -0,0 +1,124 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef __LINUX_TPM_EVENTLOG_H__
+#define __LINUX_TPM_EVENTLOG_H__
+
+#include <crypto/hash_info.h>
+
+#define TCG_EVENT_NAME_LEN_MAX  255
+#define MAX_TEXT_EVENT          1000    /* Max event string length */
+#define ACPI_TCPA_SIG           "TCPA"  /* 0x41504354 /'TCPA' */
+#define TPM2_ACTIVE_PCR_BANKS   3
+
+#define EFI_TCG2_EVENT_LOG_FORMAT_TCG_1_2 0x1
+#define EFI_TCG2_EVENT_LOG_FORMAT_TCG_2   0x2
+
+#ifdef CONFIG_PPC64
+#define do_endian_conversion(x) be32_to_cpu(x)
+#else
+#define do_endian_conversion(x) x
+#endif
+
+enum bios_platform_class {
+        BIOS_CLIENT = 0x00,
+        BIOS_SERVER = 0x01,
+};
+
+struct tcpa_event {
+        u32 pcr_index;
+        u32 event_type;
+        u8 pcr_value[20];       /* SHA1 */
+        u32 event_size;
+        u8 event_data[0];
+};
+
+enum tcpa_event_types {
+        PREBOOT = 0,
+        POST_CODE,
+        UNUSED,
+        NO_ACTION,
+        SEPARATOR,
+        ACTION,
+        EVENT_TAG,
+        SCRTM_CONTENTS,
+        SCRTM_VERSION,
+        CPU_MICROCODE,
+        PLATFORM_CONFIG_FLAGS,
+        TABLE_OF_DEVICES,
+        COMPACT_HASH,
+        IPL,
+        IPL_PARTITION_DATA,
+        NONHOST_CODE,
+        NONHOST_CONFIG,
+        NONHOST_INFO,
+};
+
+struct tcpa_pc_event {
+        u32 event_id;
+        u32 event_size;
+        u8 event_data[0];
+};
+
+enum tcpa_pc_event_ids {
+        SMBIOS = 1,
+        BIS_CERT,
+        POST_BIOS_ROM,
+        ESCD,
+        CMOS,
+        NVRAM,
+        OPTION_ROM_EXEC,
+        OPTION_ROM_CONFIG,
+        OPTION_ROM_MICROCODE = 10,
+        S_CRTM_VERSION,
+        S_CRTM_CONTENTS,
+        POST_CONTENTS,
+        HOST_TABLE_OF_DEVICES,
+};
+
+/* http://www.trustedcomputinggroup.org/tcg-efi-protocol-specification/ */
+
+struct tcg_efi_specid_event_algs {
+        u16 alg_id;
+        u16 digest_size;
+} __packed;
+
+struct tcg_efi_specid_event {
+        u8 signature[16];
+        u32 platform_class;
+        u8 spec_version_minor;
+        u8 spec_version_major;
+        u8 spec_errata;
+        u8 uintnsize;
+        u32 num_algs;
+        struct tcg_efi_specid_event_algs digest_sizes[TPM2_ACTIVE_PCR_BANKS];
+        u8 vendor_info_size;
+        u8 vendor_info[0];
+} __packed;
+
+struct tcg_pcr_event {
+        u32 pcr_idx;
+        u32 event_type;
+        u8 digest[20];
+        u32 event_size;
+        u8 event[0];
+} __packed;
+
+struct tcg_event_field {
+        u32 event_size;
+        u8 event[0];
+} __packed;
+
+struct tpm2_digest {
+        u16 alg_id;
+        u8 digest[SHA512_DIGEST_SIZE];
+} __packed;
+
+struct tcg_pcr_event2 {
+        u32 pcr_idx;
+        u32 event_type;
+        u32 count;
+        struct tpm2_digest digests[TPM2_ACTIVE_PCR_BANKS];
+        struct tcg_event_field event;
+} __packed;
+
+#endif
diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
index af44e7c2d577..8a1442c4e513 100644
--- a/include/linux/trace_events.h
+++ b/include/linux/trace_events.h
@@ -467,6 +467,7 @@ trace_trigger_soft_disabled(struct trace_event_file *file)
 unsigned int trace_call_bpf(struct trace_event_call *call, void *ctx);
 int perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog);
 void perf_event_detach_bpf_prog(struct perf_event *event);
+int perf_event_query_prog_array(struct perf_event *event, void __user *info);
 #else
 static inline unsigned int trace_call_bpf(struct trace_event_call *call, void *ctx)
 {
@@ -481,6 +482,11 @@ perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog)
 
 static inline void perf_event_detach_bpf_prog(struct perf_event *event) { }
 
+static inline int
+perf_event_query_prog_array(struct perf_event *event, void __user *info)
+{
+        return -EOPNOTSUPP;
+}
 #endif
 
 enum {
@@ -528,6 +534,7 @@ do {									\
 struct perf_event;
 
 DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);
+DECLARE_PER_CPU(int, bpf_kprobe_override);
 
 extern int  perf_trace_init(struct perf_event *event);
 extern void perf_trace_destroy(struct perf_event *event);
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index a26ffbe09e71..c94f466d57ef 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -137,11 +137,8 @@ extern void syscall_unregfunc(void);
                                                                         \
                 if (!(cond))                                            \
                         return;                                         \
-                if (rcucheck) {                                         \
-                        if (WARN_ON_ONCE(rcu_irq_enter_disabled()))     \
-                                return;                                 \
+                if (rcucheck)                                           \
                         rcu_irq_enter_irqson();                         \
-                }                                                       \
                 rcu_read_lock_sched_notrace();                          \
                 it_func_ptr = rcu_dereference_sched((tp)->funcs);       \
                 if (it_func_ptr) {                                      \
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 7ac8ba208b1f..0a6c71e0ad01 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -405,6 +405,8 @@ extern const char *tty_name(const struct tty_struct *tty);
 extern struct tty_struct *tty_kopen(dev_t device);
 extern void tty_kclose(struct tty_struct *tty);
 extern int tty_dev_name_to_number(const char *name, dev_t *number);
+extern int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout);
+extern void tty_ldisc_unlock(struct tty_struct *tty);
 #else
 static inline void tty_kref_put(struct tty_struct *tty)
 { }
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 3bc5144b1c7e..1ef64d4ad887 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -187,7 +187,7 @@ struct tty_ldisc_ops {
         long    (*compat_ioctl)(struct tty_struct *tty, struct file *file,
                                 unsigned int cmd, unsigned long arg);
         void    (*set_termios)(struct tty_struct *tty, struct ktermios *old);
-        unsigned int (*poll)(struct tty_struct *, struct file *,
+        __poll_t (*poll)(struct tty_struct *, struct file *,
                              struct poll_table_struct *);
         int     (*hangup)(struct tty_struct *tty);
 
diff --git a/include/linux/uaccess.h b/include/linux/uaccess.h
index 251e655d407f..efe79c1cdd47 100644
--- a/include/linux/uaccess.h
+++ b/include/linux/uaccess.h
@@ -273,4 +273,12 @@ extern long strncpy_from_unsafe(char *dst, const void *unsafe_addr, long count);
 #define unsafe_put_user(x, ptr, err) do { if (unlikely(__put_user(x, ptr))) goto err; } while (0)
 #endif
 
+#ifdef CONFIG_HARDENED_USERCOPY
+void usercopy_warn(const char *name, const char *detail, bool to_user,
+                   unsigned long offset, unsigned long len);
+void __noreturn usercopy_abort(const char *name, const char *detail,
+                               bool to_user, unsigned long offset,
+                               unsigned long len);
+#endif
+
 #endif          /* __LINUX_UACCESS_H__ */
diff --git a/include/linux/usb.h b/include/linux/usb.h
index fbbe974661f2..0173597e59aa 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -609,6 +609,10 @@ struct usb3_lpm_parameters {
  *      to keep track of the number of functions that require USB 3.0 Link Power
  *      Management to be disabled for this usb_device.  This count should only
  *      be manipulated by those functions, with the bandwidth_mutex is held.
+ * @hub_delay: cached value consisting of:
+ *              parent->hub_delay + wHubDelay + tTPTransmissionDelay (40ns)
+ *
+ *      Will be used as wValue for SetIsochDelay requests.
  *
  * Notes:
  * Usbcore drivers should not set usbdev->state directly.  Instead use
@@ -689,6 +693,8 @@ struct usb_device {
         struct usb3_lpm_parameters u1_params;
         struct usb3_lpm_parameters u2_params;
         unsigned lpm_disable_count;
+
+        u16 hub_delay;
 };
 #define to_usb_device(d) container_of(d, struct usb_device, dev)
 
@@ -1293,7 +1299,6 @@ extern int usb_disabled(void);
 #define URB_ISO_ASAP            0x0002  /* iso-only; use the first unexpired
                                          * slot in the schedule */
 #define URB_NO_TRANSFER_DMA_MAP 0x0004  /* urb->transfer_dma valid on submit */
-#define URB_NO_FSBR             0x0020  /* UHCI-specific */
 #define URB_ZERO_PACKET         0x0040  /* Finish bulk OUT with short packet */
 #define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt
                                          * needed */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 0142f3af0da6..66a5cff7ee14 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -330,6 +330,7 @@ struct usb_gadget_ops {
  * @name: Identifies the controller hardware type.  Used in diagnostics
  *      and sometimes configuration.
  * @dev: Driver model state for this abstract device.
+ * @isoch_delay: value from Set Isoch Delay request. Only valid on SS/SSP
  * @out_epnum: last used out ep number
  * @in_epnum: last used in ep number
  * @mA: last set mA value
@@ -394,6 +395,7 @@ struct usb_gadget {
         enum usb_device_state           state;
         const char                      *name;
         struct device                   dev;
+        unsigned                        isoch_delay;
         unsigned                        out_epnum;
         unsigned                        in_epnum;
         unsigned                        mA;
diff --git a/include/linux/usb/of.h b/include/linux/usb/of.h
index 6cbe7a5c2b57..dba55ccb9b53 100644
--- a/include/linux/usb/of.h
+++ b/include/linux/usb/of.h
@@ -12,13 +12,17 @@
 #include <linux/usb/otg.h>
 #include <linux/usb/phy.h>
 
+struct usb_device;
+
 #if IS_ENABLED(CONFIG_OF)
 enum usb_dr_mode of_usb_get_dr_mode_by_phy(struct device_node *np, int arg0);
 bool of_usb_host_tpl_support(struct device_node *np);
 int of_usb_update_otg_caps(struct device_node *np,
                         struct usb_otg_caps *otg_caps);
-struct device_node *usb_of_get_child_node(struct device_node *parent,
-                        int portnum);
+struct device_node *usb_of_get_device_node(struct usb_device *hub, int port1);
+bool usb_of_has_combined_node(struct usb_device *udev);
+struct device_node *usb_of_get_interface_node(struct usb_device *udev,
+                u8 config, u8 ifnum);
 struct device *usb_of_get_companion_dev(struct device *dev);
 #else
 static inline enum usb_dr_mode
@@ -35,8 +39,17 @@ static inline int of_usb_update_otg_caps(struct device_node *np,
 {
         return 0;
 }
-static inline struct device_node *usb_of_get_child_node
-                (struct device_node *parent, int portnum)
+static inline struct device_node *
+usb_of_get_device_node(struct usb_device *hub, int port1)
+{
+        return NULL;
+}
+static inline bool usb_of_has_combined_node(struct usb_device *udev)
+{
+        return false;
+}
+static inline struct device_node *
+usb_of_get_interface_node(struct usb_device *udev, u8 config, u8 ifnum)
 {
         return NULL;
 }
diff --git a/include/linux/usb/pd.h b/include/linux/usb/pd.h
index e00051ced806..b3d41d7409b3 100644
--- a/include/linux/usb/pd.h
+++ b/include/linux/usb/pd.h
@@ -148,6 +148,8 @@ enum pd_pdo_type {
         (PDO_TYPE(PDO_TYPE_FIXED) | (flags) |           \
          PDO_FIXED_VOLT(mv) | PDO_FIXED_CURR(ma))
 
+#define VSAFE5V 5000 /* mv units */
+
 #define PDO_BATT_MAX_VOLT_SHIFT 20      /* 50mV units */
 #define PDO_BATT_MIN_VOLT_SHIFT 10      /* 50mV units */
 #define PDO_BATT_MAX_PWR_SHIFT  0       /* 250mW units */
diff --git a/include/linux/usb/pd_vdo.h b/include/linux/usb/pd_vdo.h
index d92259f8de0a..2b64d23ace5c 100644
--- a/include/linux/usb/pd_vdo.h
+++ b/include/linux/usb/pd_vdo.h
@@ -65,7 +65,7 @@
 #define CMD_EXIT_MODE           5
 #define CMD_ATTENTION           6
 
-#define VDO_CMD_VENDOR(x)    (((10 + (x)) & 0x1f))
+#define VDO_CMD_VENDOR(x)    (((0x10 + (x)) & 0x1f))
 
 /* ChromeOS specific commands */
 #define VDO_CMD_VERSION         VDO_CMD_VENDOR(0)
diff --git a/include/linux/usb/renesas_usbhs.h b/include/linux/usb/renesas_usbhs.h
index 67102f3d59d4..53924f8e840c 100644
--- a/include/linux/usb/renesas_usbhs.h
+++ b/include/linux/usb/renesas_usbhs.h
@@ -17,6 +17,7 @@
  */
 #ifndef RENESAS_USB_H
 #define RENESAS_USB_H
+#include <linux/notifier.h>
 #include <linux/platform_device.h>
 #include <linux/usb/ch9.h>
 
@@ -98,6 +99,13 @@ struct renesas_usbhs_platform_callback {
          * VBUS control is needed for Host
          */
         int (*set_vbus)(struct platform_device *pdev, int enable);
+
+        /*
+         * option:
+         * extcon notifier to set host/peripheral mode.
+         */
+        int (*notifier)(struct notifier_block *nb, unsigned long event,
+                        void *data);
 };
 
 /*
@@ -187,6 +195,7 @@ struct renesas_usbhs_driver_param {
 #define USBHS_TYPE_RCAR_GEN2            1
 #define USBHS_TYPE_RCAR_GEN3            2
 #define USBHS_TYPE_RCAR_GEN3_WITH_PLL   3
+#define USBHS_TYPE_RZA1                 4
 
 /*
  * option:
diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h
index 073197f0d2bb..ca1c0b57f03f 100644
--- a/include/linux/usb/tcpm.h
+++ b/include/linux/usb/tcpm.h
@@ -183,14 +183,14 @@ struct tcpm_port;
 struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc);
 void tcpm_unregister_port(struct tcpm_port *port);
 
-void tcpm_update_source_capabilities(struct tcpm_port *port, const u32 *pdo,
-                                     unsigned int nr_pdo);
-void tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo,
-                                   unsigned int nr_pdo,
-                                   unsigned int max_snk_mv,
-                                   unsigned int max_snk_ma,
-                                   unsigned int max_snk_mw,
-                                   unsigned int operating_snk_mw);
+int tcpm_update_source_capabilities(struct tcpm_port *port, const u32 *pdo,
+                                    unsigned int nr_pdo);
+int tcpm_update_sink_capabilities(struct tcpm_port *port, const u32 *pdo,
+                                  unsigned int nr_pdo,
+                                  unsigned int max_snk_mv,
+                                  unsigned int max_snk_ma,
+                                  unsigned int max_snk_mw,
+                                  unsigned int operating_snk_mw);
 
 void tcpm_vbus_change(struct tcpm_port *port);
 void tcpm_cc_change(struct tcpm_port *port);
diff --git a/include/linux/uuid.h b/include/linux/uuid.h
index 33b0bdbb613c..d9c4a6cce3c2 100644
--- a/include/linux/uuid.h
+++ b/include/linux/uuid.h
@@ -17,6 +17,7 @@
 #define _LINUX_UUID_H_
 
 #include <uapi/linux/uuid.h>
+#include <linux/string.h>
 
 #define UUID_SIZE 16
 
diff --git a/include/linux/vbox_utils.h b/include/linux/vbox_utils.h
new file mode 100644
index 000000000000..c71def6b310f
--- /dev/null
+++ b/include/linux/vbox_utils.h
@@ -0,0 +1,79 @@
+/* SPDX-License-Identifier: (GPL-2.0 OR CDDL-1.0) */
+/* Copyright (C) 2006-2016 Oracle Corporation */
+
+#ifndef __VBOX_UTILS_H__
+#define __VBOX_UTILS_H__
+
+#include <linux/printk.h>
+#include <linux/vbox_vmmdev_types.h>
+
+struct vbg_dev;
+
+/**
+ * vboxguest logging functions, these log both to the backdoor and call
+ * the equivalent kernel pr_foo function.
+ */
+__printf(1, 2) void vbg_info(const char *fmt, ...);
+__printf(1, 2) void vbg_warn(const char *fmt, ...);
+__printf(1, 2) void vbg_err(const char *fmt, ...);
+
+/* Only use backdoor logging for non-dynamic debug builds */
+#if defined(DEBUG) && !defined(CONFIG_DYNAMIC_DEBUG)
+__printf(1, 2) void vbg_debug(const char *fmt, ...);
+#else
+#define vbg_debug pr_debug
+#endif
+
+/**
+ * Allocate memory for generic request and initialize the request header.
+ *
+ * Return: the allocated memory
+ * @len:                Size of memory block required for the request.
+ * @req_type:           The generic request type.
+ */
+void *vbg_req_alloc(size_t len, enum vmmdev_request_type req_type);
+
+/**
+ * Perform a generic request.
+ *
+ * Return: VBox status code
+ * @gdev:               The Guest extension device.
+ * @req:                Pointer to the request structure.
+ */
+int vbg_req_perform(struct vbg_dev *gdev, void *req);
+
+int vbg_hgcm_connect(struct vbg_dev *gdev,
+                     struct vmmdev_hgcm_service_location *loc,
+                     u32 *client_id, int *vbox_status);
+
+int vbg_hgcm_disconnect(struct vbg_dev *gdev, u32 client_id, int *vbox_status);
+
+int vbg_hgcm_call(struct vbg_dev *gdev, u32 client_id, u32 function,
+                  u32 timeout_ms, struct vmmdev_hgcm_function_parameter *parms,
+                  u32 parm_count, int *vbox_status);
+
+int vbg_hgcm_call32(
+        struct vbg_dev *gdev, u32 client_id, u32 function, u32 timeout_ms,
+        struct vmmdev_hgcm_function_parameter32 *parm32, u32 parm_count,
+        int *vbox_status);
+
+/**
+ * Convert a VirtualBox status code to a standard Linux kernel return value.
+ * Return: 0 or negative errno value.
+ * @rc:                 VirtualBox status code to convert.
+ */
+int vbg_status_code_to_errno(int rc);
+
+/**
+ * Helper for the vboxsf driver to get a reference to the guest device.
+ * Return: a pointer to the gdev; or a ERR_PTR value on error.
+ */
+struct vbg_dev *vbg_get_gdev(void);
+
+/**
+ * Helper for the vboxsf driver to put a guest device reference.
+ * @gdev:               Reference returned by vbg_get_gdev to put.
+ */
+void vbg_put_gdev(struct vbg_dev *gdev);
+
+#endif
diff --git a/include/linux/vfio.h b/include/linux/vfio.h
index a47b985341d1..66741ab087c1 100644
--- a/include/linux/vfio.h
+++ b/include/linux/vfio.h
@@ -145,7 +145,8 @@ extern struct vfio_info_cap_header *vfio_info_cap_add(
 extern void vfio_info_cap_shift(struct vfio_info_cap *caps, size_t offset);
 
 extern int vfio_info_add_capability(struct vfio_info_cap *caps,
-                                    int cap_type_id, void *cap_type);
+                                    struct vfio_info_cap_header *cap,
+                                    size_t size);
 
 extern int vfio_set_irqs_validate_and_prepare(struct vfio_irq_set *hdr,
                                               int num_irqs, int max_irq_type,
diff --git a/include/linux/visorbus.h b/include/linux/visorbus.h
new file mode 100644
index 000000000000..0d8bd6769b13
--- /dev/null
+++ b/include/linux/visorbus.h
@@ -0,0 +1,344 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (C) 2010 - 2013 UNISYS CORPORATION
+ * All rights reserved.
+ */
+
+/*
+ *  This header file is to be included by other kernel mode components that
+ *  implement a particular kind of visor_device.  Each of these other kernel
+ *  mode components is called a visor device driver.  Refer to visortemplate
+ *  for a minimal sample visor device driver.
+ *
+ *  There should be nothing in this file that is private to the visorbus
+ *  bus implementation itself.
+ */
+
+#ifndef __VISORBUS_H__
+#define __VISORBUS_H__
+
+#include <linux/device.h>
+
+#define VISOR_CHANNEL_SIGNATURE ('L' << 24 | 'N' << 16 | 'C' << 8 | 'E')
+
+/*
+ * enum channel_serverstate
+ * @CHANNELSRV_UNINITIALIZED: Channel is in an undefined state.
+ * @CHANNELSRV_READY:         Channel has been initialized by server.
+ */
+enum channel_serverstate {
+        CHANNELSRV_UNINITIALIZED = 0,
+        CHANNELSRV_READY = 1
+};
+
+/*
+ * enum channel_clientstate
+ * @CHANNELCLI_DETACHED:
+ * @CHANNELCLI_DISABLED:  Client can see channel but is NOT allowed to use it
+ *                        unless given TBD* explicit request
+ *                        (should actually be < DETACHED).
+ * @CHANNELCLI_ATTACHING: Legacy EFI client request for EFI server to attach.
+ * @CHANNELCLI_ATTACHED:  Idle, but client may want to use channel any time.
+ * @CHANNELCLI_BUSY:      Client either wants to use or is using channel.
+ * @CHANNELCLI_OWNED:     "No worries" state - client can access channel
+ *                        anytime.
+ */
+enum channel_clientstate {
+        CHANNELCLI_DETACHED = 0,
+        CHANNELCLI_DISABLED = 1,
+        CHANNELCLI_ATTACHING = 2,
+        CHANNELCLI_ATTACHED = 3,
+        CHANNELCLI_BUSY = 4,
+        CHANNELCLI_OWNED = 5
+};
+
+/*
+ * Values for VISOR_CHANNEL_PROTOCOL.Features: This define exists so that
+ * a guest can look at the FeatureFlags in the io channel, and configure the
+ * driver to use interrupts or not based on this setting. All feature bits for
+ * all channels should be defined here. The io channel feature bits are defined
+ * below.
+ */
+#define VISOR_DRIVER_ENABLES_INTS (0x1ULL << 1)
+#define VISOR_CHANNEL_IS_POLLING (0x1ULL << 3)
+#define VISOR_IOVM_OK_DRIVER_DISABLING_INTS (0x1ULL << 4)
+#define VISOR_DRIVER_DISABLES_INTS (0x1ULL << 5)
+#define VISOR_DRIVER_ENHANCED_RCVBUF_CHECKING (0x1ULL << 6)
+
+/*
+ * struct channel_header - Common Channel Header
+ * @signature:         Signature.
+ * @legacy_state:      DEPRECATED - being replaced by.
+ * @header_size:       sizeof(struct channel_header).
+ * @size:              Total size of this channel in bytes.
+ * @features:          Flags to modify behavior.
+ * @chtype:            Channel type: data, bus, control, etc..
+ * @partition_handle:  ID of guest partition.
+ * @handle:            Device number of this channel in client.
+ * @ch_space_offset:   Offset in bytes to channel specific area.
+ * @version_id:        Struct channel_header Version ID.
+ * @partition_index:   Index of guest partition.
+ * @zone_uuid:         Guid of Channel's zone.
+ * @cli_str_offset:    Offset from channel header to null-terminated
+ *                     ClientString (0 if ClientString not present).
+ * @cli_state_boot:    CHANNEL_CLIENTSTATE of pre-boot EFI client of this
+ *                     channel.
+ * @cmd_state_cli:     CHANNEL_COMMANDSTATE (overloaded in Windows drivers, see
+ *                     ServerStateUp, ServerStateDown, etc).
+ * @cli_state_os:      CHANNEL_CLIENTSTATE of Guest OS client of this channel.
+ * @ch_characteristic: CHANNEL_CHARACTERISTIC_<xxx>.
+ * @cmd_state_srv:     CHANNEL_COMMANDSTATE (overloaded in Windows drivers, see
+ *                     ServerStateUp, ServerStateDown, etc).
+ * @srv_state:         CHANNEL_SERVERSTATE.
+ * @cli_error_boot:    Bits to indicate err states for boot clients, so err
+ *                     messages can be throttled.
+ * @cli_error_os:      Bits to indicate err states for OS clients, so err
+ *                     messages can be throttled.
+ * @filler:            Pad out to 128 byte cacheline.
+ * @recover_channel:   Please add all new single-byte values below here.
+ */
+struct channel_header {
+        u64 signature;
+        u32 legacy_state;
+        /* SrvState, CliStateBoot, and CliStateOS below */
+        u32 header_size;
+        u64 size;
+        u64 features;
+        guid_t chtype;
+        u64 partition_handle;
+        u64 handle;
+        u64 ch_space_offset;
+        u32 version_id;
+        u32 partition_index;
+        guid_t zone_guid;
+        u32 cli_str_offset;
+        u32 cli_state_boot;
+        u32 cmd_state_cli;
+        u32 cli_state_os;
+        u32 ch_characteristic;
+        u32 cmd_state_srv;
+        u32 srv_state;
+        u8 cli_error_boot;
+        u8 cli_error_os;
+        u8 filler[1];
+        u8 recover_channel;
+} __packed;
+
+#define VISOR_CHANNEL_ENABLE_INTS (0x1ULL << 0)
+
+/*
+ * struct signal_queue_header - Subheader for the Signal Type variation of the
+ *                              Common Channel.
+ * @version:          SIGNAL_QUEUE_HEADER Version ID.
+ * @chtype:           Queue type: storage, network.
+ * @size:             Total size of this queue in bytes.
+ * @sig_base_offset:  Offset to signal queue area.
+ * @features:         Flags to modify behavior.
+ * @num_sent:         Total # of signals placed in this queue.
+ * @num_overflows:    Total # of inserts failed due to full queue.
+ * @signal_size:      Total size of a signal for this queue.
+ * @max_slots:        Max # of slots in queue, 1 slot is always empty.
+ * @max_signals:      Max # of signals in queue (MaxSignalSlots-1).
+ * @head:             Queue head signal #.
+ * @num_received:     Total # of signals removed from this queue.
+ * @tail:             Queue tail signal.
+ * @reserved1:        Reserved field.
+ * @reserved2:        Reserved field.
+ * @client_queue:
+ * @num_irq_received: Total # of Interrupts received. This is incremented by the
+ *                    ISR in the guest windows driver.
+ * @num_empty:        Number of times that visor_signal_remove is called and
+ *                    returned Empty Status.
+ * @errorflags:       Error bits set during SignalReinit to denote trouble with
+ *                    client's fields.
+ * @filler:           Pad out to 64 byte cacheline.
+ */
+struct signal_queue_header {
+        /* 1st cache line */
+        u32 version;
+        u32 chtype;
+        u64 size;
+        u64 sig_base_offset;
+        u64 features;
+        u64 num_sent;
+        u64 num_overflows;
+        u32 signal_size;
+        u32 max_slots;
+        u32 max_signals;
+        u32 head;
+        /* 2nd cache line */
+        u64 num_received;
+        u32 tail;
+        u32 reserved1;
+        u64 reserved2;
+        u64 client_queue;
+        u64 num_irq_received;
+        u64 num_empty;
+        u32 errorflags;
+        u8 filler[12];
+} __packed;
+
+/* VISORCHANNEL Guids */
+/* {414815ed-c58c-11da-95a9-00e08161165f} */
+#define VISOR_VHBA_CHANNEL_GUID \
+        GUID_INIT(0x414815ed, 0xc58c, 0x11da, \
+                  0x95, 0xa9, 0x0, 0xe0, 0x81, 0x61, 0x16, 0x5f)
+#define VISOR_VHBA_CHANNEL_GUID_STR \
+        "414815ed-c58c-11da-95a9-00e08161165f"
+struct visorchipset_state {
+        u32 created:1;
+        u32 attached:1;
+        u32 configured:1;
+        u32 running:1;
+        /* Remaining bits in this 32-bit word are reserved. */
+};
+
+/**
+ * struct visor_device - A device type for things "plugged" into the visorbus
+ *                       bus
+ * @visorchannel:               Points to the channel that the device is
+ *                              associated with.
+ * @channel_type_guid:          Identifies the channel type to the bus driver.
+ * @device:                     Device struct meant for use by the bus driver
+ *                              only.
+ * @list_all:                   Used by the bus driver to enumerate devices.
+ * @timer:                      Timer fired periodically to do interrupt-type
+ *                              activity.
+ * @being_removed:              Indicates that the device is being removed from
+ *                              the bus. Private bus driver use only.
+ * @visordriver_callback_lock:  Used by the bus driver to lock when adding and
+ *                              removing devices.
+ * @pausing:                    Indicates that a change towards a paused state.
+ *                              is in progress. Only modified by the bus driver.
+ * @resuming:                   Indicates that a change towards a running state
+ *                              is in progress. Only modified by the bus driver.
+ * @chipset_bus_no:             Private field used by the bus driver.
+ * @chipset_dev_no:             Private field used the bus driver.
+ * @state:                      Used to indicate the current state of the
+ *                              device.
+ * @inst:                       Unique GUID for this instance of the device.
+ * @name:                       Name of the device.
+ * @pending_msg_hdr:            For private use by bus driver to respond to
+ *                              hypervisor requests.
+ * @vbus_hdr_info:              A pointer to header info. Private use by bus
+ *                              driver.
+ * @partition_guid:             Indicates client partion id. This should be the
+ *                              same across all visor_devices in the current
+ *                              guest. Private use by bus driver only.
+ */
+struct visor_device {
+        struct visorchannel *visorchannel;
+        guid_t channel_type_guid;
+        /* These fields are for private use by the bus driver only. */
+        struct device device;
+        struct list_head list_all;
+        struct timer_list timer;
+        bool timer_active;
+        bool being_removed;
+        struct mutex visordriver_callback_lock; /* synchronize probe/remove */
+        bool pausing;
+        bool resuming;
+        u32 chipset_bus_no;
+        u32 chipset_dev_no;
+        struct visorchipset_state state;
+        guid_t inst;
+        u8 *name;
+        struct controlvm_message_header *pending_msg_hdr;
+        void *vbus_hdr_info;
+        guid_t partition_guid;
+        struct dentry *debugfs_dir;
+        struct dentry *debugfs_bus_info;
+};
+
+#define to_visor_device(x) container_of(x, struct visor_device, device)
+
+typedef void (*visorbus_state_complete_func) (struct visor_device *dev,
+                                              int status);
+
+/*
+ * This struct describes a specific visor channel, by providing its GUID, name,
+ * and sizes.
+ */
+struct visor_channeltype_descriptor {
+        const guid_t guid;
+        const char *name;
+        u64 min_bytes;
+        u32 version;
+};
+
+/**
+ * struct visor_driver - Information provided by each visor driver when it
+ *                       registers with the visorbus driver
+ * @name:               Name of the visor driver.
+ * @owner:              The module owner.
+ * @channel_types:      Types of channels handled by this driver, ending with
+ *                      a zero GUID. Our specialized BUS.match() method knows
+ *                      about this list, and uses it to determine whether this
+ *                      driver will in fact handle a new device that it has
+ *                      detected.
+ * @probe:              Called when a new device comes online, by our probe()
+ *                      function specified by driver.probe() (triggered
+ *                      ultimately by some call to driver_register(),
+ *                      bus_add_driver(), or driver_attach()).
+ * @remove:             Called when a new device is removed, by our remove()
+ *                      function specified by driver.remove() (triggered
+ *                      ultimately by some call to device_release_driver()).
+ * @channel_interrupt:  Called periodically, whenever there is a possiblity
+ *                      that "something interesting" may have happened to the
+ *                      channel.
+ * @pause:              Called to initiate a change of the device's state.  If
+ *                      the return valu`e is < 0, there was an error and the
+ *                      state transition will NOT occur.  If the return value
+ *                      is >= 0, then the state transition was INITIATED
+ *                      successfully, and complete_func() will be called (or
+ *                      was just called) with the final status when either the
+ *                      state transition fails or completes successfully.
+ * @resume:             Behaves similar to pause.
+ * @driver:             Private reference to the device driver. For use by bus
+ *                      driver only.
+ */
+struct visor_driver {
+        const char *name;
+        struct module *owner;
+        struct visor_channeltype_descriptor *channel_types;
+        int (*probe)(struct visor_device *dev);
+        void (*remove)(struct visor_device *dev);
+        void (*channel_interrupt)(struct visor_device *dev);
+        int (*pause)(struct visor_device *dev,
+                     visorbus_state_complete_func complete_func);
+        int (*resume)(struct visor_device *dev,
+                      visorbus_state_complete_func complete_func);
+
+        /* These fields are for private use by the bus driver only. */
+        struct device_driver driver;
+};
+
+#define to_visor_driver(x) (container_of(x, struct visor_driver, driver))
+
+int visor_check_channel(struct channel_header *ch, struct device *dev,
+                        const guid_t *expected_uuid, char *chname,
+                        u64 expected_min_bytes, u32 expected_version,
+                        u64 expected_signature);
+
+int visorbus_register_visor_driver(struct visor_driver *drv);
+void visorbus_unregister_visor_driver(struct visor_driver *drv);
+int visorbus_read_channel(struct visor_device *dev,
+                          unsigned long offset, void *dest,
+                          unsigned long nbytes);
+int visorbus_write_channel(struct visor_device *dev,
+                           unsigned long offset, void *src,
+                           unsigned long nbytes);
+int visorbus_enable_channel_interrupts(struct visor_device *dev);
+void visorbus_disable_channel_interrupts(struct visor_device *dev);
+
+int visorchannel_signalremove(struct visorchannel *channel, u32 queue,
+                              void *msg);
+int visorchannel_signalinsert(struct visorchannel *channel, u32 queue,
+                              void *msg);
+bool visorchannel_signalempty(struct visorchannel *channel, u32 queue);
+const guid_t *visorchannel_get_guid(struct visorchannel *channel);
+
+#define BUS_ROOT_DEVICE UINT_MAX
+struct visor_device *visorbus_get_device_by_id(u32 bus_no, u32 dev_no,
+                                               struct visor_device *from);
+#endif
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index 1779c9817b39..a4c2317d8b9f 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -216,23 +216,6 @@ static inline unsigned long zone_page_state_snapshot(struct zone *zone,
         return x;
 }
 
-static inline unsigned long node_page_state_snapshot(pg_data_t *pgdat,
-                                        enum node_stat_item item)
-{
-        long x = atomic_long_read(&pgdat->vm_stat[item]);
-
-#ifdef CONFIG_SMP
-        int cpu;
-        for_each_online_cpu(cpu)
-                x += per_cpu_ptr(pgdat->per_cpu_nodestats, cpu)->vm_node_stat_diff[item];
-
-        if (x < 0)
-                x = 0;
-#endif
-        return x;
-}
-
-
 #ifdef CONFIG_NUMA
 extern void __inc_numa_state(struct zone *zone, enum numa_stat_item item);
 extern unsigned long sum_zone_node_page_state(int node,
diff --git a/include/linux/w1-gpio.h b/include/linux/w1-gpio.h
index d58594a32324..78901ecd2f95 100644
--- a/include/linux/w1-gpio.h
+++ b/include/linux/w1-gpio.h
@@ -10,16 +10,15 @@
 #ifndef _LINUX_W1_GPIO_H
 #define _LINUX_W1_GPIO_H
 
+struct gpio_desc;
+
 /**
  * struct w1_gpio_platform_data - Platform-dependent data for w1-gpio
- * @pin: GPIO pin to use
- * @is_open_drain: GPIO pin is configured as open drain
  */
 struct w1_gpio_platform_data {
-        unsigned int pin;
-        unsigned int is_open_drain:1;
+        struct gpio_desc *gpiod;
+        struct gpio_desc *pullup_gpiod;
         void (*enable_external_pullup)(int enable);
-        unsigned int ext_pullup_enable_pin;
         unsigned int pullup_duration;
 };
 
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 158715445ffb..55a611486bac 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -206,14 +206,16 @@ void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode, int nr);
 /*
  * Wakeup macros to be used to report events to the targets.
  */
+#define poll_to_key(m) ((void *)(__force uintptr_t)(__poll_t)(m))
+#define key_to_poll(m) ((__force __poll_t)(uintptr_t)(void *)(m))
 #define wake_up_poll(x, m)                                                      \
-        __wake_up(x, TASK_NORMAL, 1, (void *) (m))
+        __wake_up(x, TASK_NORMAL, 1, poll_to_key(m))
 #define wake_up_locked_poll(x, m)                                               \
-        __wake_up_locked_key((x), TASK_NORMAL, (void *) (m))
+        __wake_up_locked_key((x), TASK_NORMAL, poll_to_key(m))
 #define wake_up_interruptible_poll(x, m)                                        \
-        __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m))
+        __wake_up(x, TASK_INTERRUPTIBLE, 1, poll_to_key(m))
 #define wake_up_interruptible_sync_poll(x, m)                                   \
-        __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m))
+        __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, poll_to_key(m))
 
 #define ___wait_cond_timeout(condition)                                         \
 ({                                                                              \
diff --git a/include/linux/zpool.h b/include/linux/zpool.h
index 004ba807df96..7238865e75b0 100644
--- a/include/linux/zpool.h
+++ b/include/linux/zpool.h
@@ -108,4 +108,6 @@ void zpool_register_driver(struct zpool_driver *driver);
 
 int zpool_unregister_driver(struct zpool_driver *driver);
 
+bool zpool_evictable(struct zpool *pool);
+
 #endif